Repository: fossology/Nirjas (language: python)

Issue:
Code Formatting and Linting is required.
Currently, Nirjas codebase is not following any specific Linters and formatters. Having a linter is useful for uniformity in coding style.

### What to do?
- [ ] Either Flake8 or Pylint can be introduced as a linter.
- [ ] Separate code linting stage can be introduced in CI pipeline.



Discussion / hints:
Hi! Can I take this one?
Hello @itmecho , sure. I'll assign the issue to you.
Hey , I can contribute to this issue. It would be probably my first contribution and I'll like to work on this.
@GMishx I'm happy for @thevectorguy to take this instead =]
@thevectorguy assigning this to you!

Fix patch:
diff --git a/.github/workflows/main.yml b/.github/workflows/main.yml
new file mode 100644
index 0000000..c4214b3
--- /dev/null
+++ b/.github/workflows/main.yml
@@ -0,0 +1,15 @@
+name: Lint
+on: [push, pull_request]
+jobs:
+  CI-Linter:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v2
+      - name: Set up Python 3.8
+        uses: actions/setup-python@v2
+        with:
+          python-version: 3.8
+      - name: Install flake8
+        run: pip install flake8
+      - name: Run flake8
+        run: flake8 --ignore=E501 ./nirjas
diff --git a/nirjas/__init__.py b/nirjas/__init__.py
index f8a3350..1544941 100644
--- a/nirjas/__init__.py
+++ b/nirjas/__init__.py
@@ -1,6 +1,6 @@
 #!/usr/bin/env python3
 
-'''
+"""
 nirjas module which can be imported by other tools
 
 SPDX-License-Identifier: LGPL-2.1
@@ -16,17 +16,19 @@
 You should have received a copy of the GNU Lesser General Public
 License along with this library; if not, write to the Free Software
 Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
-'''
+"""
+
+from nirjas.main import file_runner  # noqa
 
-from nirjas.main import *
 
 def extract(file):
-    '''
+    """
     Extract the information from the given file.
     :param file: File or directory to get information from
     :type file: string
     :return: Returns comments and other meta information about the given file.
-    '''
-    return file_runner(file)
+    """
+    return file_runner(file)  # noqa
+
 
-__all__ = ['file_runner', 'extract', 'LanguageMapper']
+__all__ = ["file_runner", "extract", "LanguageMapper"]
diff --git a/nirjas/binder.py b/nirjas/binder.py
index 52f9ca6..da7bda4 100644
--- a/nirjas/binder.py
+++ b/nirjas/binder.py
@@ -1,6 +1,6 @@
 #!/usr/bin/env python3
 # -*- coding: utf-8 -*-
-'''
+"""
 Copyright (C) 2020  Ayush Bhardwaj (classicayush@gmail.com),
 Kaushlendra Pratap (kaushlendrapratap.9837@gmail.com)
 
@@ -19,7 +19,7 @@
 You should have received a copy of the GNU Lesser General Public
 License along with this library; if not, write to the Free Software
 Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
-'''
+"""
 
 import re
 from itertools import groupby
@@ -27,10 +27,10 @@
 
 
 def readSingleLine(file, regex):
-    '''
+    """
     Read file line by line and match the given regex to get comment.
     Return comments, lines read, blank lines, and lines with comments.
-    '''
+    """
     content = []
     total_lines, line_of_comments, blank_lines = 0, 0, 0
     with open(file) as f:
@@ -39,23 +39,23 @@ def readSingleLine(file, regex):
             output = re.findall(regex, line, re.I)
             if len(output) > 0:
                 line_of_comments += 1
-            output = ''.join(output)
+            output = "".join(output)
 
             if output:
                 content.append([line_number, output.strip()])
 
             line = line.strip()
 
-            if line == '':
+            if line == "":
                 blank_lines += 1
 
     return content, total_lines, blank_lines, line_of_comments
 
 
 def contSingleLines(data):
-    '''
+    """
     Merge consecutive single line comments as cont_single_line_comment
-    '''
+    """
     lines, start_line, end_line, output = [], [], [], []
     content = ""
     for i in data[0]:
@@ -73,15 +73,15 @@ def contSingleLines(data):
                 for index, x in enumerate(data[0]):
                     if x[0] == i:
                         del data[0][index]
-                content = content + ' ' + comment[0]
+                content = content + " " + comment[0]
             output.append(content)
     return data, start_line, end_line, output
 
 
 def readMultiLineSame(file, syntax: str):
-    '''
+    """
     Read multiline comments where starting and ending symbols are same.
-    '''
+    """
     start_line, end_line, output = [], [], []
     content = ""
     if '"' in syntax:
@@ -92,14 +92,13 @@ def readMultiLineSame(file, syntax: str):
     copy = False
     with open(file) as f:
         for line_number, line in enumerate(f, start=1):
-            if syntax in line and \
-                    syntax_in_string not in line:
+            if syntax in line and syntax_in_string not in line:
                 closingCount += 1
                 copy = True
                 if line.count(syntax) == 2:
                     # Start and end on same line
                     closingCount = 2
-                    content = line.replace('\n', ' ')
+                    content = line.replace("\n", " ")
                     start_line.append(line_number)
                 if closingCount % 2 == 0 and closingCount != 0:
                     copy = False
@@ -111,16 +110,16 @@ def readMultiLineSame(file, syntax: str):
 
             if copy:
                 lines_of_comment += 1
-                content = content + line.replace('\n', ' ')
+                content = content + line.replace("\n", " ")
 
     output = [s.strip(syntax).strip() for s in output]
     return start_line, end_line, output, lines_of_comment
 
 
 def readMultiLineDiff(file, startSyntax: str, endSyntax: str):
-    '''
+    """
     Read multiline comments where starting and ending symbols are different.
-    '''
+    """
     output, startLine, endLine = [], [], []
     content = ""
     total_lines, line_of_comments, blank_lines = 0, 0, 0
@@ -134,31 +133,38 @@ def readMultiLineDiff(file, startSyntax: str, endSyntax: str):
                 line = line[line.find(startSyntax) + len(startSyntax):]
             if endSyntax in line:
                 copy = False
-                line = line[:line.rfind(endSyntax) + len(endSyntax)]
-                content = content + line.replace('\n', ' ')
+                line = line[: line.rfind(endSyntax) + len(endSyntax)]
+                content = content + line.replace("\n", " ")
                 content = content.strip(startSyntax).strip(endSyntax).strip()
                 output.append(content)
                 content = ""
                 endLine.append(lineNumber)
                 continue
             if copy:
-                content = content + (line.replace('\n', ' ')).strip()
-            if line.strip() == '':
+                content = content + (line.replace("\n", " ")).strip()
+            if line.strip() == "":
                 blank_lines += 1
         for idx, _ in enumerate(endLine):
             line_of_comments = line_of_comments + (endLine[idx] - startLine[idx]) + 1
         line_of_comments += len(output)
-        output = [s.strip(startSyntax).strip(endSyntax).strip()for s in output]
-    return startLine, endLine, output, line_of_comments, total_lines, blank_lines
+        output = [s.strip(startSyntax).strip(endSyntax).strip() for s in output]
+    return (
+        startLine,
+        endLine,
+        output,
+        line_of_comments,
+        total_lines,
+        blank_lines,
+    )  # noqa
 
 
 def extractAssignedString(file):
-    '''
+    """
     Read file line by line and match string type variable to get string.
     Return the content of the string.
-    '''
+    """
     content = []
-    regex = r'(?<=(=\s*[\'\"]))(.*?)(?=[\'\"])'
+    regex = r"(?<=(=\s*[\'\"]))(.*?)(?=[\'\"])"
     total_lines, line_of_assignedString = 0, 0
     with open(file) as f:
         for line_number, line in enumerate(f, start=1):
@@ -166,7 +172,7 @@ def extractAssignedString(file):
             output = re.findall(regex, line, re.S)
             if len(output) >= 2:
                 line_of_assignedString += 1
-            output = ''.join(output)
+            output = "".join(output)
             if output and len(output) > 1:
                 content.append([line_number, output.strip()])
             line = line.strip()
@@ -174,10 +180,10 @@ def extractAssignedString(file):
 
 
 class CommentSyntax:
-    '''
+    """
     Class to hold various regex and helper functions based on comment format
     used by a language.
-    '''
+    """
 
     def __init__(self):
         self.sign = None
@@ -186,43 +192,43 @@ def __init__(self):
         self.end = None
 
     def hash(self, file):
-        '''
+        """
         sign: #
-        '''
-        self.sign = '#'
-        self.pattern = r'''(?<!["'`])#+\s*(.*)'''
+        """
+        self.sign = "#"
+        self.pattern = r"""(?<!["'`])#+\s*(.*)"""
         return readSingleLine(file, self.pattern)
 
     def hashNoCurl(self, file):
-        '''
+        """
         sign: #
-        '''
-        self.sign = '#'
-        self.pattern = r'''(?<!["'`])#+(?!\{)\s*(.*)'''
+        """
+        self.sign = "#"
+        self.pattern = r"""(?<!["'`])#+(?!\{)\s*(.*)"""
         return readSingleLine(file, self.pattern)
 
     def percentage(self, file):
-        '''
+        """
         sign: %
-        '''
-        self.sign = '%'
-        self.pattern = r'''(?<!["'`])\%\s*(.*)'''
+        """
+        self.sign = "%"
+        self.pattern = r"""(?<!["'`])\%\s*(.*)"""
         return readSingleLine(file, self.pattern)
 
     def doubleSlash(self, file):
-        '''
+        """
         sign: //
-        '''
-        self.sign = '//'
-        self.pattern = r'''(?<![pst'"`]:)\/\/\s*(.*)'''
+        """
+        self.sign = "//"
+        self.pattern = r"""(?<![pst'"`]:)\/\/\s*(.*)"""
         return readSingleLine(file, self.pattern)
 
     def doubleNotTripleSlash(self, file):
-        '''
+        """
         sign: //
-        '''
-        self.sign = '//'
-        self.pattern = r'''(?<!\/)\/\/(?!\/)\s*(.*)'''
+        """
+        self.sign = "//"
+        self.pattern = r"""(?<!\/)\/\/(?!\/)\s*(.*)"""
         return readSingleLine(file, self.pattern)
 
     def singleQuotes(self, file):
@@ -240,73 +246,73 @@ def doubleQuotes(self, file):
         return readMultiLineSame(file, self.sign)
 
     def doubleDash(self, file):
-        '''
+        """
         sign: --
-        '''
-        self.sign = '--'
-        self.pattern = r'''(?<!["'`])\-\-\s*(.*)'''
+        """
+        self.sign = "--"
+        self.pattern = r"""(?<!["'`])\-\-\s*(.*)"""
         return readSingleLine(file, self.pattern)
 
     def slashStar(self, file):
-        '''
+        """
         sign: /* ~ */
-        '''
+        """
         self.start = "/*"
         self.end = "*/"
         return readMultiLineDiff(file, self.start, self.end)
 
     def gtExclamationDash(self, file):
-        '''
+        """
         sign : <!-- ~ -->
-        '''
+        """
         self.start = "<!--"
         self.end = "-->"
         return readMultiLineDiff(file, self.start, self.end)
 
     def beginCut(self, file):
-        '''
+        """
         sign: =begin ~ =cut
-        '''
+        """
         self.start = "=begin"
         self.end = "=cut"
         return readMultiLineDiff(file, self.start, self.end)
 
     def beginEnd(self, file):
-        '''
+        """
         sign: =begin ~ =end
-        '''
+        """
         self.start = "=begin"
         self.end = "=end"
         return readMultiLineDiff(file, self.start, self.end)
 
     def curlybracesDash(self, file):
-        '''
+        """
         sign: {- ~ -}
-        '''
+        """
         self.start = "{-"
         self.end = "-}"
         return readMultiLineDiff(file, self.start, self.end)
 
     def percentageCurlybraces(self, file):
-        '''
+        """
         sign: %{ ~ %}
-        '''
+        """
         self.start = "%{"
         self.end = "%}"
         return readMultiLineDiff(file, self.start, self.end)
 
     def tripleSlash(self, file):
-        '''
+        """
         sign: ///
-        '''
-        self.sign = '///'
-        self.pattern = r'''(?<!["'`])\/\/\/\s*(.*)'''
+        """
+        self.sign = "///"
+        self.pattern = r"""(?<!["'`])\/\/\/\s*(.*)"""
         return readSingleLine(file, self.pattern)
 
     def slashDoubleStar(self, file):
-        '''
+        """
         sign: /** ~ */
-        '''
+        """
         self.start = "/**"
         self.end = "*/"
         return readMultiLineDiff(file, self.start, self.end)
diff --git a/nirjas/languages/__init__.py b/nirjas/languages/__init__.py
index c364e17..9a25074 100644
--- a/nirjas/languages/__init__.py
+++ b/nirjas/languages/__init__.py
@@ -1,6 +1,6 @@
 #!/usr/bin/env python3
 # -*- coding: utf-8 -*-
-'''
+"""
 SPDX-License-Identifier: LGPL-2.1
 
 This library is free software; you can redistribute it and/or
@@ -18,9 +18,31 @@
 Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
 
 Module holding different language syntax
-'''
+"""
 
-__all__ = ["c", "c_sharp", "cpp", "css", "dart", "go", "haskell", "html",
-           "java", "javascript", "kotlin", "matlab", "perl", "php", "python",
-           "r", "ruby", "rust", "scala", "scss", "shell", "swift", "text",
-           "typescript"]
+__all__ = [
+    "c",
+    "c_sharp",
+    "cpp",
+    "css",
+    "dart",
+    "go",
+    "haskell",
+    "html",
+    "java",
+    "javascript",
+    "kotlin",
+    "matlab",
+    "perl",
+    "php",
+    "python",
+    "r",
+    "ruby",
+    "rust",
+    "scala",
+    "scss",
+    "shell",
+    "swift",
+    "text",
+    "typescript",
+]
diff --git a/nirjas/languages/c.py b/nirjas/languages/c.py
index e363246..1a2c1f8 100644
--- a/nirjas/languages/c.py
+++ b/nirjas/languages/c.py
@@ -1,6 +1,6 @@
 #!/usr/bin/env python3
 # -*- coding: utf-8 -*-
-'''
+"""
 Copyright (C) 2020  Ayush Bhardwaj (classicayush@gmail.com),
 Kaushlendra Pratap (kaushlendrapratap.9837@gmail.com)
 
@@ -19,20 +19,20 @@
 You should have received a copy of the GNU Lesser General Public
 License along with this library; if not, write to the Free Software
 Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
-'''
+"""
 
 from nirjas.binder import CommentSyntax, contSingleLines
 from nirjas.output import ScanOutput, SingleLine, MultiLine
 
 
 def cExtractor(file):
-    '''
+    """
     Extract comments from C file.
     :param file: File to scan
     :type file: string
     :return: Scan output
     :rtype: ScanOutput
-    '''
+    """
     result = CommentSyntax()
     single_line_comment = result.doubleSlash(file)
     multiline_comment = result.slashStar(file)
@@ -40,7 +40,7 @@ def cExtractor(file):
     file = file.split("/")
     output = ScanOutput()
     output.filename = file[-1]
-    output.lang = 'C'
+    output.lang = "C"
     output.total_lines = single_line_comment[1]
     output.total_lines_of_comments = single_line_comment[3] + multiline_comment[3]
     output.blank_lines = single_line_comment[2]
@@ -52,23 +52,31 @@ def cExtractor(file):
         output.single_line_comment.append(SingleLine(i[0], i[1]))
 
     for idx, _ in enumerate(cont_single_line_comment[1]):
-        output.cont_single_line_comment.append(MultiLine(
-            cont_single_line_comment[1][idx], cont_single_line_comment[2][idx],
-            cont_single_line_comment[3][idx]))
+        output.cont_single_line_comment.append(
+            MultiLine(
+                cont_single_line_comment[1][idx],
+                cont_single_line_comment[2][idx],
+                cont_single_line_comment[3][idx],
+            )
+        )
 
     try:
         for idx, _ in enumerate(multiline_comment[0]):
-            output.multi_line_comment.append(MultiLine(multiline_comment[0][idx],
-                                                       multiline_comment[1][idx],
-                                                       multiline_comment[2][idx]))
-    except:
+            output.multi_line_comment.append(
+                MultiLine(
+                    multiline_comment[0][idx],
+                    multiline_comment[1][idx],
+                    multiline_comment[2][idx],
+                )
+            )
+    except BaseException:
         pass
 
     return output
 
 
 def cSource(file, new_file: str):
-    '''
+    """
     Extract source from C file and put at new_file.
     :param file: File to process
     :type file: string
@@ -76,34 +84,34 @@ def cSource(file, new_file: str):
     :type new_file: string
     :return: Path to new file
     :rtype: string
-    '''
+    """
     copy = True
-    with open(new_file, 'w+') as f1:
+    with open(new_file, "w+") as f1:
         with open(file) as f:
             for line in f:
                 content = ""
                 found = False
-                if '/*' in line:
-                    pos = line.find('/*')
+                if "/*" in line:
+                    pos = line.find("/*")
                     content = line[:pos].rstrip()
                     line = line[pos:]
                     copy = False
                     found = True
-                if '*/' in line:
-                    content = content + line[line.rfind('*/') + 2:]
+                if "*/" in line:
+                    content = content + line[line.rfind("*/") + 2:]
                     line = content
                     copy = True
                     found = True
-                if '//' in line:
-                    if line[line.find('//') - 1] != ':':
-                        line = line[:line.find('//')].rstrip() + '\n'
-                    elif line[line.rfind('//') - 1] != ':':
-                        line = line[:line.rfind('//')].rstrip() + '\n'
+                if "//" in line:
+                    if line[line.find("//") - 1] != ":":
+                        line = line[: line.find("//")].rstrip() + "\n"
+                    elif line[line.rfind("//") - 1] != ":":
+                        line = line[: line.rfind("//")].rstrip() + "\n"
                     content = line
                     found = True
                 if not found:
                     content = line
-                if copy and content.strip() != '':
+                if copy and content.strip() != "":
                     f1.write(content)
     f.close()
     f1.close()
diff --git a/nirjas/languages/c_sharp.py b/nirjas/languages/c_sharp.py
index 2d61a35..3cbffe7 100644
--- a/nirjas/languages/c_sharp.py
+++ b/nirjas/languages/c_sharp.py
@@ -1,6 +1,6 @@
 #!/usr/bin/env python3
 # -*- coding: utf-8 -*-
-'''
+"""
 Copyright (C) 2020  Ayush Bhardwaj (classicayush@gmail.com),
 Kaushlendra Pratap (kaushlendrapratap.9837@gmail.com)
 
@@ -19,20 +19,20 @@
 You should have received a copy of the GNU Lesser General Public
 License along with this library; if not, write to the Free Software
 Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
-'''
+"""
 
 from nirjas.binder import CommentSyntax, contSingleLines
 from nirjas.output import ScanOutput, SingleLine, MultiLine
 
 
 def c_sharpExtractor(file):
-    '''
+    """
     Extract comments from C# file.
     :param file: File to scan
     :type file: string
     :return: Scan output
     :rtype: ScanOutput
-    '''
+    """
     result = CommentSyntax()
     single_line_comment = result.doubleSlash(file)
     multiline_comment = result.slashStar(file)
@@ -40,7 +40,7 @@ def c_sharpExtractor(file):
     file = file.split("/")
     output = ScanOutput()
     output.filename = file[-1]
-    output.lang = 'C#'
+    output.lang = "C#"
     output.total_lines = single_line_comment[1]
     output.total_lines_of_comments = single_line_comment[3] + multiline_comment[3]
     output.blank_lines = single_line_comment[2]
@@ -52,20 +52,28 @@ def c_sharpExtractor(file):
         output.single_line_comment.append(SingleLine(i[0], i[1]))
 
     for idx, _ in enumerate(cont_single_line_comment[1]):
-        output.cont_single_line_comment.append(MultiLine(
-            cont_single_line_comment[1][idx], cont_single_line_comment[2][idx],
-            cont_single_line_comment[3][idx]))
+        output.cont_single_line_comment.append(
+            MultiLine(
+                cont_single_line_comment[1][idx],
+                cont_single_line_comment[2][idx],
+                cont_single_line_comment[3][idx],
+            )
+        )
 
     for idx, _ in enumerate(multiline_comment[0]):
-        output.multi_line_comment.append(MultiLine(multiline_comment[0][idx],
-                                                   multiline_comment[1][idx],
-                                                   multiline_comment[2][idx]))
+        output.multi_line_comment.append(
+            MultiLine(
+                multiline_comment[0][idx],
+                multiline_comment[1][idx],
+                multiline_comment[2][idx],
+            )
+        )
 
     return output
 
 
 def c_sharpSource(file, new_file: str):
-    '''
+    """
     Extract source from C# file and put at new_file.
     :param file: File to process
     :type file: string
@@ -73,34 +81,34 @@ def c_sharpSource(file, new_file: str):
     :type new_file: string
     :return: Path to new file
     :rtype: string
-    '''
+    """
     copy = True
-    with open(new_file, 'w+') as f1:
-        with open(file, 'r') as f:
+    with open(new_file, "w+") as f1:
+        with open(file, "r") as f:
             for line in f:
                 content = ""
                 found = False
-                if '/*' in line:
-                    pos = line.find('/*')
+                if "/*" in line:
+                    pos = line.find("/*")
                     content = line[:pos].rstrip()
                     line = line[pos:]
                     copy = False
                     found = True
-                if '*/' in line:
-                    content = content + line[line.rfind('*/') + 2:]
+                if "*/" in line:
+                    content = content + line[line.rfind("*/") + 2:]
                     line = content
                     copy = True
                     found = True
-                if '//' in line:
-                    if line[line.find('//') - 1] != ':':
-                        line = line[:line.find('//')].rstrip() + '\n'
-                    elif line[line.rfind('//') - 1] != ':':
-                        line = line[:line.rfind('//')].rstrip() + '\n'
+                if "//" in line:
+                    if line[line.find("//") - 1] != ":":
+                        line = line[: line.find("//")].rstrip() + "\n"
+                    elif line[line.rfind("//") - 1] != ":":
+                        line = line[: line.rfind("//")].rstrip() + "\n"
                     content = line
                     found = True
                 if not found:
                     content = line
-                if copy and content.strip() != '':
+                if copy and content.strip() != "":
                     f1.write(content)
     f.close()
     f1.close()
diff --git a/nirjas/languages/cpp.py b/nirjas/languages/cpp.py
index 310b1b3..6b745e0 100644
--- a/nirjas/languages/cpp.py
+++ b/nirjas/languages/cpp.py
@@ -1,6 +1,6 @@
 #!/usr/bin/env python3
 # -*- coding: utf-8 -*-
-'''
+"""
 Copyright (C) 2020  Ayush Bhardwaj (classicayush@gmail.com),
 Kaushlendra Pratap (kaushlendrapratap.9837@gmail.com)
 
@@ -19,20 +19,20 @@
 You should have received a copy of the GNU Lesser General Public
 License along with this library; if not, write to the Free Software
 Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
-'''
+"""
 
 from nirjas.binder import CommentSyntax, contSingleLines
 from nirjas.output import ScanOutput, SingleLine, MultiLine
 
 
 def cppExtractor(file):
-    '''
+    """
     Extract comments from C++ file.
     :param file: File to scan
     :type file: string
     :return: Scan output
     :rtype: ScanOutput
-    '''
+    """
     result = CommentSyntax()
     single_line_comment = result.doubleSlash(file)
     multiline_comment = result.slashStar(file)
@@ -40,7 +40,7 @@ def cppExtractor(file):
     file = file.split("/")
     output = ScanOutput()
     output.filename = file[-1]
-    output.lang = 'C++'
+    output.lang = "C++"
     output.total_lines = single_line_comment[1]
     output.total_lines_of_comments = single_line_comment[3] + multiline_comment[3]
     output.blank_lines = single_line_comment[2]
@@ -52,23 +52,31 @@ def cppExtractor(file):
         output.single_line_comment.append(SingleLine(i[0], i[1]))
 
     for idx, _ in enumerate(cont_single_line_comment[1]):
-        output.cont_single_line_comment.append(MultiLine(
-            cont_single_line_comment[1][idx], cont_single_line_comment[2][idx],
-            cont_single_line_comment[3][idx]))
+        output.cont_single_line_comment.append(
+            MultiLine(
+                cont_single_line_comment[1][idx],
+                cont_single_line_comment[2][idx],
+                cont_single_line_comment[3][idx],
+            )
+        )
 
     try:
         for idx, _ in enumerate(multiline_comment[0]):
-            output.multi_line_comment.append(MultiLine(multiline_comment[0][idx],
-                                                       multiline_comment[1][idx],
-                                                       multiline_comment[2][idx]))
-    except:
+            output.multi_line_comment.append(
+                MultiLine(
+                    multiline_comment[0][idx],
+                    multiline_comment[1][idx],
+                    multiline_comment[2][idx],
+                )
+            )
+    except BaseException:
         pass
 
     return output
 
 
 def cppSource(file, new_file: str):
-    '''
+    """
     Extract source from C++ file and put at new_file.
     :param file: File to process
     :type file: string
@@ -76,34 +84,34 @@ def cppSource(file, new_file: str):
     :type new_file: string
     :return: Path to new file
     :rtype: string
-    '''
+    """
     copy = True
-    with open(new_file, 'w+') as f1:
+    with open(new_file, "w+") as f1:
         with open(file) as f:
             for line in f:
                 content = ""
                 found = False
-                if '/*' in line:
-                    pos = line.find('/*')
+                if "/*" in line:
+                    pos = line.find("/*")
                     content = line[:pos].rstrip()
                     line = line[pos:]
                     copy = False
                     found = True
-                if '*/' in line:
-                    content = content + line[line.rfind('*/') + 2:]
+                if "*/" in line:
+                    content = content + line[line.rfind("*/") + 2:]
                     line = content
                     copy = True
                     found = True
-                if '//' in line:
-                    if line[line.find('//') - 1] != ':':
-                        line = line[:line.find('//')].rstrip() + '\n'
-                    elif line[line.rfind('//') - 1] != ':':
-                        line = line[:line.rfind('//')].rstrip() + '\n'
+                if "//" in line:
+                    if line[line.find("//") - 1] != ":":
+                        line = line[: line.find("//")].rstrip() + "\n"
+                    elif line[line.rfind("//") - 1] != ":":
+                        line = line[: line.rfind("//")].rstrip() + "\n"
                     content = line
                     found = True
                 if not found:
                     content = line
-                if copy and content.strip() != '':
+                if copy and content.strip() != "":
                     f1.write(content)
     f.close()
     f1.close()
diff --git a/nirjas/languages/css.py b/nirjas/languages/css.py
index f5b945b..2fed371 100644
--- a/nirjas/languages/css.py
+++ b/nirjas/languages/css.py
@@ -1,6 +1,6 @@
 #!/usr/bin/env python3
 # -*- coding: utf-8 -*-
-'''
+"""
 Copyright (C) 2020  Ayush Bhardwaj (classicayush@gmail.com),
 Kaushlendra Pratap (kaushlendrapratap.9837@gmail.com)
 
@@ -19,43 +19,47 @@
 You should have received a copy of the GNU Lesser General Public
 License along with this library; if not, write to the Free Software
 Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
-'''
+"""
 
 from nirjas.binder import CommentSyntax
 from nirjas.output import ScanOutput, MultiLine
 
 
 def cssExtractor(file):
-    '''
+    """
     Extract comments from CSS file.
     :param file: File to scan
     :type file: string
     :return: Scan output
     :rtype: ScanOutput
-    '''
+    """
     result = CommentSyntax()
     multiline_comment = result.slashStar(file)
     file = file.split("/")
     output = ScanOutput()
     output.filename = file[-1]
-    output.lang = 'CSS'
+    output.lang = "CSS"
     output.total_lines = multiline_comment[4]
     output.total_lines_of_comments = multiline_comment[3]
     output.blank_lines = multiline_comment[5]
 
     try:
         for idx, _ in enumerate(multiline_comment[0]):
-            output.multi_line_comment.append(MultiLine(multiline_comment[0][idx],
-                                                       multiline_comment[1][idx],
-                                                       multiline_comment[2][idx]))
-    except:
+            output.multi_line_comment.append(
+                MultiLine(
+                    multiline_comment[0][idx],
+                    multiline_comment[1][idx],
+                    multiline_comment[2][idx],
+                )
+            )
+    except BaseException:
         pass
 
     return output
 
 
 def cssSource(file, new_file: str):
-    '''
+    """
     Extract source from CSS file and put at new_file.
     :param file: File to process
     :type file: string
@@ -63,27 +67,27 @@ def cssSource(file, new_file: str):
     :type new_file: string
     :return: Path to new file
     :rtype: string
-    '''
+    """
     copy = True
-    with open(new_file, 'w+') as f1:
+    with open(new_file, "w+") as f1:
         with open(file) as f:
             for line in f:
                 content = ""
                 found = False
-                if '/*' in line:
-                    pos = line.find('/*')
+                if "/*" in line:
+                    pos = line.find("/*")
                     content = line[:pos].rstrip()
                     line = line[pos:]
                     copy = False
                     found = True
-                if '*/' in line:
-                    content = content + line[line.rfind('*/') + 2:]
+                if "*/" in line:
+                    content = content + line[line.rfind("*/") + 2:]
                     line = content
                     copy = True
                     found = True
                 if not found:
                     content = line
-                if copy and content.strip() != '':
+                if copy and content.strip() != "":
                     f1.write(content)
     f.close()
     f1.close()
diff --git a/nirjas/languages/dart.py b/nirjas/languages/dart.py
index 52f8a73..c519ee8 100644
--- a/nirjas/languages/dart.py
+++ b/nirjas/languages/dart.py
@@ -1,6 +1,6 @@
 #!/usr/bin/env python3
 # -*- coding: utf-8 -*-
-'''
+"""
 Copyright (C) 2020  Aman Dwivedi (aman.dwivedi5@gmail.com)
 
 SPDX-License-Identifier: LGPL-2.1
@@ -18,20 +18,20 @@
 You should have received a copy of the GNU Lesser General Public
 License along with this library; if not, write to the Free Software
 Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
-'''
+"""
 
 from nirjas.binder import CommentSyntax, contSingleLines
 from nirjas.output import ScanOutput, SingleLine, MultiLine
 
 
 def dartExtractor(file):
-    '''
+    """
     Extract comments from Dart file.
     :param file: File to scan
     :type file: string
     :return: Scan output
     :rtype: ScanOutput
-    '''
+    """
     result = CommentSyntax()
     single_line_comment = result.doubleNotTripleSlash(file)
     doc_comment = result.tripleSlash(file)
@@ -41,9 +41,11 @@ def dartExtractor(file):
     file = file.split("/")
     output = ScanOutput()
     output.filename = file[-1]
-    output.lang = 'Dart'
+    output.lang = "Dart"
     output.total_lines = single_line_comment[1]
-    output.total_lines_of_comments = single_line_comment[3] + multiline_comment[3] + doc_comment[3]
+    output.total_lines_of_comments = (
+        single_line_comment[3] + multiline_comment[3] + doc_comment[3]
+    )
     output.blank_lines = single_line_comment[2]
 
     if cont_single_line_comment:
@@ -59,28 +61,40 @@ def dartExtractor(file):
         output.single_line_comment.append(SingleLine(i[0], i[1]))
 
     for idx, _ in enumerate(cont_single_line_comment[1]):
-        output.cont_single_line_comment.append(MultiLine(
-            cont_single_line_comment[1][idx], cont_single_line_comment[2][idx],
-            cont_single_line_comment[3][idx]))
+        output.cont_single_line_comment.append(
+            MultiLine(
+                cont_single_line_comment[1][idx],
+                cont_single_line_comment[2][idx],
+                cont_single_line_comment[3][idx],
+            )
+        )
 
     for idx, _ in enumerate(cont_doc_line_comment[1]):
-        output.cont_single_line_comment.append(MultiLine(
-            cont_doc_line_comment[1][idx], cont_doc_line_comment[2][idx],
-            cont_doc_line_comment[3][idx]))
+        output.cont_single_line_comment.append(
+            MultiLine(
+                cont_doc_line_comment[1][idx],
+                cont_doc_line_comment[2][idx],
+                cont_doc_line_comment[3][idx],
+            )
+        )
 
     try:
         for idx, _ in enumerate(multiline_comment[0]):
-            output.multi_line_comment.append(MultiLine(multiline_comment[0][idx],
-                                                       multiline_comment[1][idx],
-                                                       multiline_comment[2][idx]))
-    except:
+            output.multi_line_comment.append(
+                MultiLine(
+                    multiline_comment[0][idx],
+                    multiline_comment[1][idx],
+                    multiline_comment[2][idx],
+                )
+            )
+    except BaseException:
         pass
 
     return output
 
 
 def dartSource(file, new_file: str):
-    '''
+    """
     Extract source from Dart file and put at new_file.
     :param file: File to process
     :type file: string
@@ -88,39 +102,39 @@ def dartSource(file, new_file: str):
     :type new_file: string
     :return: Path to new file
     :rtype: string
-    '''
+    """
     copy = True
-    with open(new_file, 'w+') as f1:
+    with open(new_file, "w+") as f1:
         with open(file) as f:
             for line in f:
                 content = ""
                 found = False
-                if '/*' in line:
-                    pos = line.find('/*')
+                if "/*" in line:
+                    pos = line.find("/*")
                     content = line[:pos].rstrip()
                     line = line[pos:]
                     copy = False
                     found = True
-                if '*/' in line:
-                    content = content + line[line.rfind('*/') + 2:]
+                if "*/" in line:
+                    content = content + line[line.rfind("*/") + 2:]
                     line = content
                     copy = True
                     found = True
-                if '///' in line:
-                    pos = line.find('///')
+                if "///" in line:
+                    pos = line.find("///")
                     content = line[:pos].rstrip()
                     line = line[pos:]
                     found = True
-                if '//' in line:
-                    if line[line.find('//') - 1] != ':':
-                        line = line[:line.find('//')].rstrip() + '\n'
-                    elif line[line.rfind('//') - 1] != ':':
-                        line = line[:line.rfind('//')].rstrip() + '\n'
+                if "//" in line:
+                    if line[line.find("//") - 1] != ":":
+                        line = line[: line.find("//")].rstrip() + "\n"
+                    elif line[line.rfind("//") - 1] != ":":
+                        line = line[: line.rfind("//")].rstrip() + "\n"
                     content = line
                     found = True
                 if not found:
                     content = line
-                if copy and content.strip() != '':
+                if copy and content.strip() != "":
                     f1.write(content)
     f.close()
     f1.close()
diff --git a/nirjas/languages/go.py b/nirjas/languages/go.py
index 0e1ea2e..068bff1 100644
--- a/nirjas/languages/go.py
+++ b/nirjas/languages/go.py
@@ -1,6 +1,6 @@
 #!/usr/bin/env python3
 # -*- coding: utf-8 -*-
-'''
+"""
 Copyright (C) 2020  Ayush Bhardwaj (classicayush@gmail.com),
 Kaushlendra Pratap (kaushlendrapratap.9837@gmail.com)
 
@@ -19,20 +19,20 @@
 You should have received a copy of the GNU Lesser General Public
 License along with this library; if not, write to the Free Software
 Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
-'''
+"""
 
 from nirjas.binder import CommentSyntax, contSingleLines
 from nirjas.output import ScanOutput, SingleLine, MultiLine
 
 
 def goExtractor(file):
-    '''
+    """
     Extract comments from Go file.
     :param file: File to scan
     :type file: string
     :return: Scan output
     :rtype: ScanOutput
-    '''
+    """
     result = CommentSyntax()
     single_line_comment = result.doubleSlash(file)
     multiline_comment = result.slashStar(file)
@@ -40,7 +40,7 @@ def goExtractor(file):
     file = file.split("/")
     output = ScanOutput()
     output.filename = file[-1]
-    output.lang = 'Go'
+    output.lang = "Go"
     output.total_lines = single_line_comment[1]
     output.total_lines_of_comments = single_line_comment[3] + multiline_comment[3]
     output.blank_lines = single_line_comment[2]
@@ -52,20 +52,28 @@ def goExtractor(file):
         output.single_line_comment.append(SingleLine(i[0], i[1]))
 
     for idx, _ in enumerate(cont_single_line_comment[1]):
-        output.cont_single_line_comment.append(MultiLine(
-            cont_single_line_comment[1][idx], cont_single_line_comment[2][idx],
-            cont_single_line_comment[3][idx]))
+        output.cont_single_line_comment.append(
+            MultiLine(
+                cont_single_line_comment[1][idx],
+                cont_single_line_comment[2][idx],
+                cont_single_line_comment[3][idx],
+            )
+        )
 
     for idx, _ in enumerate(multiline_comment[0]):
-        output.multi_line_comment.append(MultiLine(multiline_comment[0][idx],
-                                                   multiline_comment[1][idx],
-                                                   multiline_comment[2][idx]))
+        output.multi_line_comment.append(
+            MultiLine(
+                multiline_comment[0][idx],
+                multiline_comment[1][idx],
+                multiline_comment[2][idx],
+            )
+        )
 
     return output
 
 
 def goSource(file, new_file: str):
-    '''
+    """
     Extract source from Go file and put at new_file.
     :param file: File to process
     :type file: string
@@ -73,34 +81,34 @@ def goSource(file, new_file: str):
     :type new_file: string
     :return: Path to new file
     :rtype: string
-    '''
+    """
     copy = True
-    with open(new_file, 'w+') as f1:
+    with open(new_file, "w+") as f1:
         with open(file) as f:
             for line in f:
                 content = ""
                 found = False
-                if '/*' in line:
-                    pos = line.find('/*')
+                if "/*" in line:
+                    pos = line.find("/*")
                     content = line[:pos].rstrip()
                     line = line[pos:]
                     copy = False
                     found = True
-                if '*/' in line:
-                    content = content + line[line.rfind('*/') + 2:]
+                if "*/" in line:
+                    content = content + line[line.rfind("*/") + 2:]
                     line = content
                     copy = True
                     found = True
-                if '//' in line:
-                    if line[line.find('//') - 1] != ':':
-                        line = line[:line.find('//')].rstrip() + '\n'
-                    elif line[line.rfind('//') - 1] != ':':
-                        line = line[:line.rfind('//')].rstrip() + '\n'
+                if "//" in line:
+                    if line[line.find("//") - 1] != ":":
+                        line = line[: line.find("//")].rstrip() + "\n"
+                    elif line[line.rfind("//") - 1] != ":":
+                        line = line[: line.rfind("//")].rstrip() + "\n"
                     content = line
                     found = True
                 if not found:
                     content = line
-                if copy and content.strip() != '':
+                if copy and content.strip() != "":
                     f1.write(content)
     f.close()
     f1.close()
diff --git a/nirjas/languages/haskell.py b/nirjas/languages/haskell.py
index 8e2c3db..e704d21 100644
--- a/nirjas/languages/haskell.py
+++ b/nirjas/languages/haskell.py
@@ -1,6 +1,6 @@
 #!/usr/bin/env python3
 # -*- coding: utf-8 -*-
-'''
+"""
 Copyright (C) 2020  Ayush Bhardwaj (classicayush@gmail.com),
 Kaushlendra Pratap (kaushlendrapratap.9837@gmail.com)
 
@@ -19,20 +19,20 @@
 You should have received a copy of the GNU Lesser General Public
 License along with this library; if not, write to the Free Software
 Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
-'''
+"""
 
 from nirjas.binder import CommentSyntax, contSingleLines
 from nirjas.output import ScanOutput, SingleLine, MultiLine
 
 
 def haskellExtractor(file):
-    '''
+    """
     Extract comments from Haskell file.
     :param file: File to scan
     :type file: string
     :return: Scan output
     :rtype: ScanOutput
-    '''
+    """
     result = CommentSyntax()
     single_line_comment = result.doubleDash(file)
     multiline_comment = result.curlybracesDash(file)
@@ -40,7 +40,7 @@ def haskellExtractor(file):
     file = file.split("/")
     output = ScanOutput()
     output.filename = file[-1]
-    output.lang = 'Haskell'
+    output.lang = "Haskell"
     output.total_lines = single_line_comment[1]
     output.total_lines_of_comments = single_line_comment[3] + multiline_comment[3]
     output.blank_lines = single_line_comment[2]
@@ -52,20 +52,28 @@ def haskellExtractor(file):
         output.single_line_comment.append(SingleLine(i[0], i[1]))
 
     for idx, _ in enumerate(cont_single_line_comment[1]):
-        output.cont_single_line_comment.append(MultiLine(
-            cont_single_line_comment[1][idx], cont_single_line_comment[2][idx],
-            cont_single_line_comment[3][idx]))
+        output.cont_single_line_comment.append(
+            MultiLine(
+                cont_single_line_comment[1][idx],
+                cont_single_line_comment[2][idx],
+                cont_single_line_comment[3][idx],
+            )
+        )
 
     for idx, _ in enumerate(multiline_comment[0]):
-        output.multi_line_comment.append(MultiLine(multiline_comment[0][idx],
-                                                   multiline_comment[1][idx],
-                                                   multiline_comment[2][idx]))
+        output.multi_line_comment.append(
+            MultiLine(
+                multiline_comment[0][idx],
+                multiline_comment[1][idx],
+                multiline_comment[2][idx],
+            )
+        )
 
     return output
 
 
 def haskellSource(file, new_file: str):
-    '''
+    """
     Extract source from Haskell file and put at new_file.
     :param file: File to process
     :type file: string
@@ -73,30 +81,30 @@ def haskellSource(file, new_file: str):
     :type new_file: string
     :return: Path to new file
     :rtype: string
-    '''
+    """
     copy = True
-    with open(new_file, 'w+') as f1:
+    with open(new_file, "w+") as f1:
         with open(file) as f:
             for line in f:
                 content = ""
                 found = False
-                if '{-' in line:
-                    pos = line.find('{-')
+                if "{-" in line:
+                    pos = line.find("{-")
                     content = line[:pos].rstrip()
                     line = line[pos:]
                     copy = False
                     found = True
-                if '-}' in line:
-                    content = content + line[line.rfind('-}') + 2:]
+                if "-}" in line:
+                    content = content + line[line.rfind("-}") + 2:]
                     line = content
                     copy = True
                     found = True
-                if '--' in line:
-                    content = line[:line.find('--')].rstrip() + '\n'
+                if "--" in line:
+                    content = line[: line.find("--")].rstrip() + "\n"
                     found = True
                 if not found:
                     content = line
-                if copy and content.strip() != '':
+                if copy and content.strip() != "":
                     f1.write(content)
     f.close()
     f1.close()
diff --git a/nirjas/languages/html.py b/nirjas/languages/html.py
index b6363c8..8035de3 100644
--- a/nirjas/languages/html.py
+++ b/nirjas/languages/html.py
@@ -1,6 +1,6 @@
 #!/usr/bin/env python3
 # -*- coding: utf-8 -*-
-'''
+"""
 Copyright (C) 2020  Ayush Bhardwaj (classicayush@gmail.com),
 Kaushlendra Pratap (kaushlendrapratap.9837@gmail.com)
 
@@ -19,52 +19,62 @@
 You should have received a copy of the GNU Lesser General Public
 License along with this library; if not, write to the Free Software
 Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
-'''
+"""
 
 from nirjas.binder import CommentSyntax
 from nirjas.output import ScanOutput, MultiLine
 
 
 def htmlExtractor(file):
-    '''
+    """
     Extract comments from HTML file.
     :param file: File to scan
     :type file: string
     :return: Scan output
     :rtype: ScanOutput
-    '''
+    """
     result = CommentSyntax()
     multiline_dash_comment = result.gtExclamationDash(file)
     multiline_star_comment = result.slashStar(file)
     file = file.split("/")
     output = ScanOutput()
     output.filename = file[-1]
-    output.lang = 'HTML'
+    output.lang = "HTML"
     output.total_lines = multiline_dash_comment[4]
-    output.total_lines_of_comments = multiline_dash_comment[3] + multiline_star_comment[3]
+    output.total_lines_of_comments = (
+        multiline_dash_comment[3] + multiline_star_comment[3]
+    )
     output.blank_lines = multiline_dash_comment[5]
 
     try:
         for idx, _ in enumerate(multiline_dash_comment[0]):
-            output.multi_line_comment.append(MultiLine(
-                multiline_dash_comment[0][idx], multiline_dash_comment[1][idx],
-                multiline_dash_comment[2][idx]))
-    except:
+            output.multi_line_comment.append(
+                MultiLine(
+                    multiline_dash_comment[0][idx],
+                    multiline_dash_comment[1][idx],
+                    multiline_dash_comment[2][idx],
+                )
+            )
+    except BaseException:
         pass
 
     try:
         for idx, _ in enumerate(multiline_star_comment[0]):
-            output.multi_line_comment.append(MultiLine(
-                multiline_star_comment[0][idx], multiline_star_comment[1][idx],
-                multiline_star_comment[2][idx]))
-    except:
+            output.multi_line_comment.append(
+                MultiLine(
+                    multiline_star_comment[0][idx],
+                    multiline_star_comment[1][idx],
+                    multiline_star_comment[2][idx],
+                )
+            )
+    except BaseException:
         pass
 
     return output
 
 
 def htmlSource(file, new_file: str):
-    '''
+    """
     Extract source from HTML file and put at new_file.
     :param file: File to process
     :type file: string
@@ -72,38 +82,38 @@ def htmlSource(file, new_file: str):
     :type new_file: string
     :return: Path to new file
     :rtype: string
-    '''
+    """
     copy = True
-    with open(new_file, 'w+') as f1:
+    with open(new_file, "w+") as f1:
         with open(file) as f:
             for line in f:
                 content = ""
                 found = False
-                if '/*' in line:
-                    pos = line.find('/*')
+                if "/*" in line:
+                    pos = line.find("/*")
                     content = line[:pos].rstrip()
                     line = line[pos:]
                     copy = False
                     found = True
-                if '*/' in line:
-                    content = content + line[line.rfind('*/') + 2:]
+                if "*/" in line:
+                    content = content + line[line.rfind("*/") + 2:]
                     line = content
                     copy = True
                     found = True
-                if '<!--' in line:
-                    pos = line.find('<!--')
+                if "<!--" in line:
+                    pos = line.find("<!--")
                     content = line[:pos].rstrip()
                     line = line[pos:]
                     copy = False
                     found = True
-                if '-->' in line:
-                    content = content + line[line.rfind('-->') + 3:]
+                if "-->" in line:
+                    content = content + line[line.rfind("-->") + 3:]
                     line = content
                     copy = True
                     found = True
                 if not found:
                     content = line
-                if copy and content.strip() != '':
+                if copy and content.strip() != "":
                     f1.write(content)
     f.close()
     f1.close()
diff --git a/nirjas/languages/java.py b/nirjas/languages/java.py
index 0c5257f..af93fe4 100644
--- a/nirjas/languages/java.py
+++ b/nirjas/languages/java.py
@@ -1,6 +1,6 @@
 #!/usr/bin/env python3
 # -*- coding: utf-8 -*-
-'''
+"""
 Copyright (C) 2020  Ayush Bhardwaj (classicayush@gmail.com),
 Kaushlendra Pratap (kaushlendrapratap.9837@gmail.com)
 
@@ -19,20 +19,20 @@
 You should have received a copy of the GNU Lesser General Public
 License along with this library; if not, write to the Free Software
 Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
-'''
+"""
 
 from nirjas.binder import CommentSyntax, contSingleLines
 from nirjas.output import ScanOutput, SingleLine, MultiLine
 
 
 def javaExtractor(file):
-    '''
+    """
     Extract comments from Java file.
     :param file: File to scan
     :type file: string
     :return: Scan output
     :rtype: ScanOutput
-    '''
+    """
     result = CommentSyntax()
     single_line_comment = result.doubleSlash(file)
     multiline_comment = result.slashStar(file)
@@ -40,7 +40,7 @@ def javaExtractor(file):
     file = file.split("/")
     output = ScanOutput()
     output.filename = file[-1]
-    output.lang = 'Java'
+    output.lang = "Java"
     output.total_lines = single_line_comment[1]
     output.total_lines_of_comments = single_line_comment[3] + multiline_comment[3]
     output.blank_lines = single_line_comment[2]
@@ -52,20 +52,28 @@ def javaExtractor(file):
         output.single_line_comment.append(SingleLine(i[0], i[1]))
 
     for idx, _ in enumerate(cont_single_line_comment[1]):
-        output.cont_single_line_comment.append(MultiLine(
-            cont_single_line_comment[1][idx], cont_single_line_comment[2][idx],
-            cont_single_line_comment[3][idx]))
+        output.cont_single_line_comment.append(
+            MultiLine(
+                cont_single_line_comment[1][idx],
+                cont_single_line_comment[2][idx],
+                cont_single_line_comment[3][idx],
+            )
+        )
 
     for idx, _ in enumerate(multiline_comment[0]):
-        output.multi_line_comment.append(MultiLine(multiline_comment[0][idx],
-                                                   multiline_comment[1][idx],
-                                                   multiline_comment[2][idx]))
+        output.multi_line_comment.append(
+            MultiLine(
+                multiline_comment[0][idx],
+                multiline_comment[1][idx],
+                multiline_comment[2][idx],
+            )
+        )
 
     return output
 
 
 def javaSource(file, new_file: str):
-    '''
+    """
     Extract source from Java file and put at new_file.
     :param file: File to process
     :type file: string
@@ -73,34 +81,34 @@ def javaSource(file, new_file: str):
     :type new_file: string
     :return: Path to new file
     :rtype: string
-    '''
+    """
     copy = True
-    with open(new_file, 'w+') as f1:
+    with open(new_file, "w+") as f1:
         with open(file) as f:
             for line in f:
                 content = ""
                 found = False
-                if '/*' in line:
-                    pos = line.find('/*')
+                if "/*" in line:
+                    pos = line.find("/*")
                     content = line[:pos].rstrip()
                     line = line[pos:]
                     copy = False
                     found = True
-                if '*/' in line:
-                    content = content + line[line.rfind('*/') + 2:]
+                if "*/" in line:
+                    content = content + line[line.rfind("*/") + 2:]
                     line = content
                     copy = True
                     found = True
-                if '//' in line:
-                    if line[line.find('//') - 1] != ':':
-                        line = line[:line.find('//')].rstrip() + '\n'
-                    elif line[line.rfind('//') - 1] != ':':
-                        line = line[:line.rfind('//')].rstrip() + '\n'
+                if "//" in line:
+                    if line[line.find("//") - 1] != ":":
+                        line = line[: line.find("//")].rstrip() + "\n"
+                    elif line[line.rfind("//") - 1] != ":":
+                        line = line[: line.rfind("//")].rstrip() + "\n"
                     content = line
                     found = True
                 if not found:
                     content = line
-                if copy and content.strip() != '':
+                if copy and content.strip() != "":
                     f1.write(content)
     f.close()
     f1.close()
diff --git a/nirjas/languages/javascript.py b/nirjas/languages/javascript.py
index aa6be49..9af7602 100644
--- a/nirjas/languages/javascript.py
+++ b/nirjas/languages/javascript.py
@@ -1,6 +1,6 @@
 #!/usr/bin/env python3
 # -*- coding: utf-8 -*-
-'''
+"""
 Copyright (C) 2020  Ayush Bhardwaj (classicayush@gmail.com),
 Kaushlendra Pratap (kaushlendrapratap.9837@gmail.com)
 
@@ -19,20 +19,20 @@
 You should have received a copy of the GNU Lesser General Public
 License along with this library; if not, write to the Free Software
 Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
-'''
+"""
 
 from nirjas.binder import CommentSyntax, contSingleLines
 from nirjas.output import ScanOutput, SingleLine, MultiLine
 
 
 def javascriptExtractor(file):
-    '''
+    """
     Extract comments from JavaScript file.
     :param file: File to scan
     :type file: string
     :return: Scan output
     :rtype: ScanOutput
-    '''
+    """
     result = CommentSyntax()
     single_line_comment = result.doubleSlash(file)
     multiline_comment = result.slashStar(file)
@@ -40,7 +40,7 @@ def javascriptExtractor(file):
     file = file.split("/")
     output = ScanOutput()
     output.filename = file[-1]
-    output.lang = 'JavaScript'
+    output.lang = "JavaScript"
     output.total_lines = single_line_comment[1]
     output.total_lines_of_comments = single_line_comment[3] + multiline_comment[3]
     output.blank_lines = single_line_comment[2]
@@ -52,23 +52,31 @@ def javascriptExtractor(file):
         output.single_line_comment.append(SingleLine(i[0], i[1]))
 
     for idx, _ in enumerate(cont_single_line_comment[1]):
-        output.cont_single_line_comment.append(MultiLine(
-            cont_single_line_comment[1][idx], cont_single_line_comment[2][idx],
-            cont_single_line_comment[3][idx]))
+        output.cont_single_line_comment.append(
+            MultiLine(
+                cont_single_line_comment[1][idx],
+                cont_single_line_comment[2][idx],
+                cont_single_line_comment[3][idx],
+            )
+        )
 
     try:
         for idx, _ in enumerate(multiline_comment[0]):
-            output.multi_line_comment.append(MultiLine(multiline_comment[0][idx],
-                                                       multiline_comment[1][idx],
-                                                       multiline_comment[2][idx]))
-    except:
+            output.multi_line_comment.append(
+                MultiLine(
+                    multiline_comment[0][idx],
+                    multiline_comment[1][idx],
+                    multiline_comment[2][idx],
+                )
+            )
+    except BaseException:
         pass
 
     return output
 
 
 def javascriptSource(file, new_file: str):
-    '''
+    """
     Extract source from JavaScript file and put at new_file.
     :param file: File to process
     :type file: string
@@ -76,34 +84,34 @@ def javascriptSource(file, new_file: str):
     :type new_file: string
     :return: Path to new file
     :rtype: string
-    '''
+    """
     copy = True
-    with open(new_file, 'w+') as f1:
+    with open(new_file, "w+") as f1:
         with open(file) as f:
             for line in f:
                 content = ""
                 found = False
-                if '/*' in line:
-                    pos = line.find('/*')
+                if "/*" in line:
+                    pos = line.find("/*")
                     content = line[:pos].rstrip()
                     line = line[pos:]
                     copy = False
                     found = True
-                if '*/' in line:
-                    content = content + line[line.rfind('*/') + 2:]
+                if "*/" in line:
+                    content = content + line[line.rfind("*/") + 2:]
                     line = content
                     copy = True
                     found = True
-                if '//' in line:
-                    if line[line.find('//') - 1] != ':':
-                        line = line[:line.find('//')].rstrip() + '\n'
-                    elif line[line.rfind('//') - 1] != ':':
-                        line = line[:line.rfind('//')].rstrip() + '\n'
+                if "//" in line:
+                    if line[line.find("//") - 1] != ":":
+                        line = line[: line.find("//")].rstrip() + "\n"
+                    elif line[line.rfind("//") - 1] != ":":
+                        line = line[: line.rfind("//")].rstrip() + "\n"
                     content = line
                     found = True
                 if not found:
                     content = line
-                if copy and content.strip() != '':
+                if copy and content.strip() != "":
                     f1.write(content)
     f.close()
     f1.close()
diff --git a/nirjas/languages/kotlin.py b/nirjas/languages/kotlin.py
index 8f0c64d..c3f3a8c 100644
--- a/nirjas/languages/kotlin.py
+++ b/nirjas/languages/kotlin.py
@@ -1,6 +1,6 @@
 #!/usr/bin/env python3
 # -*- coding: utf-8 -*-
-'''
+"""
 Copyright (C) 2020  Ayush Bhardwaj (classicayush@gmail.com),
 Kaushlendra Pratap (kaushlendrapratap.9837@gmail.com)
 
@@ -19,20 +19,20 @@
 You should have received a copy of the GNU Lesser General Public
 License along with this library; if not, write to the Free Software
 Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
-'''
+"""
 
 from nirjas.binder import CommentSyntax, contSingleLines
 from nirjas.output import ScanOutput, SingleLine, MultiLine
 
 
 def kotlinExtractor(file):
-    '''
+    """
     Extract comments from Kotlin file.
     :param file: File to scan
     :type file: string
     :return: Scan output
     :rtype: ScanOutput
-    '''
+    """
     result = CommentSyntax()
     single_line_comment = result.doubleSlash(file)
     multiline_comment = result.slashStar(file)
@@ -40,7 +40,7 @@ def kotlinExtractor(file):
     file = file.split("/")
     output = ScanOutput()
     output.filename = file[-1]
-    output.lang = 'Kotlin'
+    output.lang = "Kotlin"
     output.total_lines = single_line_comment[1]
     output.total_lines_of_comments = single_line_comment[3] + multiline_comment[3]
     output.blank_lines = single_line_comment[2]
@@ -52,20 +52,28 @@ def kotlinExtractor(file):
         output.single_line_comment.append(SingleLine(i[0], i[1]))
 
     for idx, _ in enumerate(cont_single_line_comment[1]):
-        output.cont_single_line_comment.append(MultiLine(
-            cont_single_line_comment[1][idx], cont_single_line_comment[2][idx],
-            cont_single_line_comment[3][idx]))
+        output.cont_single_line_comment.append(
+            MultiLine(
+                cont_single_line_comment[1][idx],
+                cont_single_line_comment[2][idx],
+                cont_single_line_comment[3][idx],
+            )
+        )
 
     for idx, _ in enumerate(multiline_comment[0]):
-        output.multi_line_comment.append(MultiLine(multiline_comment[0][idx],
-                                                   multiline_comment[1][idx],
-                                                   multiline_comment[2][idx]))
+        output.multi_line_comment.append(
+            MultiLine(
+                multiline_comment[0][idx],
+                multiline_comment[1][idx],
+                multiline_comment[2][idx],
+            )
+        )
 
     return output
 
 
 def kotlinSource(file, new_file: str):
-    '''
+    """
     Extract source from Kotlin file and put at new_file.
     :param file: File to process
     :type file: string
@@ -73,34 +81,34 @@ def kotlinSource(file, new_file: str):
     :type new_file: string
     :return: Path to new file
     :rtype: string
-    '''
+    """
     copy = True
-    with open(new_file, 'w+') as f1:
+    with open(new_file, "w+") as f1:
         with open(file) as f:
             for line in f:
                 content = ""
                 found = False
-                if '/*' in line:
-                    pos = line.find('/*')
+                if "/*" in line:
+                    pos = line.find("/*")
                     content = line[:pos].rstrip()
                     line = line[pos:]
                     copy = False
                     found = True
-                if '*/' in line:
-                    content = content + line[line.rfind('*/') + 2:]
+                if "*/" in line:
+                    content = content + line[line.rfind("*/") + 2:]
                     line = content
                     copy = True
                     found = True
-                if '//' in line:
-                    if line[line.find('//') - 1] != ':':
-                        line = line[:line.find('//')].rstrip() + '\n'
-                    elif line[line.rfind('//') - 1] != ':':
-                        line = line[:line.rfind('//')].rstrip() + '\n'
+                if "//" in line:
+                    if line[line.find("//") - 1] != ":":
+                        line = line[: line.find("//")].rstrip() + "\n"
+                    elif line[line.rfind("//") - 1] != ":":
+                        line = line[: line.rfind("//")].rstrip() + "\n"
                     content = line
                     found = True
                 if not found:
                     content = line
-                if copy and content.strip() != '':
+                if copy and content.strip() != "":
                     f1.write(content)
     f.close()
     f1.close()
diff --git a/nirjas/languages/matlab.py b/nirjas/languages/matlab.py
index ae46054..31bcbbd 100644
--- a/nirjas/languages/matlab.py
+++ b/nirjas/languages/matlab.py
@@ -1,6 +1,6 @@
 #!/usr/bin/env python3
 # -*- coding: utf-8 -*-
-'''
+"""
 Copyright (C) 2020  Ayush Bhardwaj (classicayush@gmail.com),
 Kaushlendra Pratap (kaushlendrapratap.9837@gmail.com)
 
@@ -19,20 +19,20 @@
 You should have received a copy of the GNU Lesser General Public
 License along with this library; if not, write to the Free Software
 Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
-'''
+"""
 
 from nirjas.binder import CommentSyntax, contSingleLines
 from nirjas.output import ScanOutput, SingleLine, MultiLine
 
 
 def matlabExtractor(file):
-    '''
+    """
     Extract comments from MATLAB file.
     :param file: File to scan
     :type file: string
     :return: Scan output
     :rtype: ScanOutput
-    '''
+    """
     result = CommentSyntax()
     single_line_comment = result.percentage(file)
     multiline_comment = result.percentageCurlybraces(file)
@@ -40,7 +40,7 @@ def matlabExtractor(file):
     file = file.split("/")
     output = ScanOutput()
     output.filename = file[-1]
-    output.lang = 'MATLAB'
+    output.lang = "MATLAB"
     output.total_lines = single_line_comment[1]
     output.total_lines_of_comments = single_line_comment[3] + multiline_comment[3]
     output.blank_lines = single_line_comment[2]
@@ -52,20 +52,28 @@ def matlabExtractor(file):
         output.single_line_comment.append(SingleLine(i[0], i[1]))
 
     for idx, _ in enumerate(cont_single_line_comment[1]):
-        output.cont_single_line_comment.append(MultiLine(
-            cont_single_line_comment[1][idx], cont_single_line_comment[2][idx],
-            cont_single_line_comment[3][idx]))
+        output.cont_single_line_comment.append(
+            MultiLine(
+                cont_single_line_comment[1][idx],
+                cont_single_line_comment[2][idx],
+                cont_single_line_comment[3][idx],
+            )
+        )
 
     for idx, _ in enumerate(multiline_comment[0]):
-        output.multi_line_comment.append(MultiLine(multiline_comment[0][idx],
-                                                   multiline_comment[1][idx],
-                                                   multiline_comment[2][idx]))
+        output.multi_line_comment.append(
+            MultiLine(
+                multiline_comment[0][idx],
+                multiline_comment[1][idx],
+                multiline_comment[2][idx],
+            )
+        )
 
     return output
 
 
 def matlabSource(file, new_file: str):
-    '''
+    """
     Extract source from MATLAB file and put at new_file.
     :param file: File to process
     :type file: string
@@ -73,30 +81,30 @@ def matlabSource(file, new_file: str):
     :type new_file: string
     :return: Path to new file
     :rtype: string
-    '''
+    """
     copy = True
-    with open(new_file, 'w+') as f1:
+    with open(new_file, "w+") as f1:
         with open(file) as f:
             for line in f:
                 content = ""
                 found = False
-                if '%{' in line:
-                    pos = line.find('%{')
+                if "%{" in line:
+                    pos = line.find("%{")
                     content = line[:pos].rstrip()
                     line = line[pos:]
                     copy = False
                     found = True
-                if '}%' in line:
-                    content = content + line[line.rfind('}%') + 2:]
+                if "}%" in line:
+                    content = content + line[line.rfind("}%") + 2:]
                     line = content
                     copy = True
                     found = True
-                if '%' in line:
-                    content = line[:line.find('%')].rstrip() + '\n'
+                if "%" in line:
+                    content = line[: line.find("%")].rstrip() + "\n"
                     found = True
                 if not found:
                     content = line
-                if copy and content.strip() != '':
+                if copy and content.strip() != "":
                     f1.write(content)
     f.close()
     f1.close()
diff --git a/nirjas/languages/perl.py b/nirjas/languages/perl.py
index fe91f6e..ac940a9 100644
--- a/nirjas/languages/perl.py
+++ b/nirjas/languages/perl.py
@@ -1,6 +1,6 @@
 #!/usr/bin/env python3
 # -*- coding: utf-8 -*-
-'''
+"""
 Copyright (C) 2020  Ayush Bhardwaj (classicayush@gmail.com),
 Kaushlendra Pratap (kaushlendrapratap.9837@gmail.com)
 
@@ -19,20 +19,20 @@
 You should have received a copy of the GNU Lesser General Public
 License along with this library; if not, write to the Free Software
 Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
-'''
+"""
 
 from nirjas.binder import CommentSyntax, contSingleLines
 from nirjas.output import ScanOutput, SingleLine, MultiLine
 
 
 def perlExtractor(file):
-    '''
+    """
     Extract comments from Perl file.
     :param file: File to scan
     :type file: string
     :return: Scan output
     :rtype: ScanOutput
-    '''
+    """
     result = CommentSyntax()
     single_line_comment = result.hash(file)
     multiline_comment = result.beginCut(file)
@@ -40,7 +40,7 @@ def perlExtractor(file):
     file = file.split("/")
     output = ScanOutput()
     output.filename = file[-1]
-    output.lang = 'Perl'
+    output.lang = "Perl"
     output.total_lines = single_line_comment[1]
     output.total_lines_of_comments = single_line_comment[3] + multiline_comment[3]
     output.blank_lines = single_line_comment[2]
@@ -52,20 +52,28 @@ def perlExtractor(file):
         output.single_line_comment.append(SingleLine(i[0], i[1]))
 
     for idx, i in enumerate(cont_single_line_comment[1]):
-        output.cont_single_line_comment.append(MultiLine(
-            cont_single_line_comment[1][idx], cont_single_line_comment[2][idx],
-            cont_single_line_comment[3][idx]))
+        output.cont_single_line_comment.append(
+            MultiLine(
+                cont_single_line_comment[1][idx],
+                cont_single_line_comment[2][idx],
+                cont_single_line_comment[3][idx],
+            )
+        )
 
     for idx, i in enumerate(multiline_comment[0]):
-        output.multi_line_comment.append(MultiLine(multiline_comment[0][idx],
-                                                   multiline_comment[1][idx],
-                                                   multiline_comment[2][idx]))
+        output.multi_line_comment.append(
+            MultiLine(
+                multiline_comment[0][idx],
+                multiline_comment[1][idx],
+                multiline_comment[2][idx],
+            )
+        )
 
     return output
 
 
 def perlSource(file, new_file: str):
-    '''
+    """
     Extract source from Perl file and put at new_file.
     :param file: File to process
     :type file: string
@@ -73,30 +81,30 @@ def perlSource(file, new_file: str):
     :type new_file: string
     :return: Path to new file
     :rtype: string
-    '''
+    """
     copy = True
-    with open(new_file, 'w+') as f1:
+    with open(new_file, "w+") as f1:
         with open(file) as f:
             for line in f:
                 content = ""
                 found = False
-                if '=begin' in line:
-                    pos = line.find('=begin')
+                if "=begin" in line:
+                    pos = line.find("=begin")
                     content = line[:pos].rstrip()
                     line = line[pos:]
                     copy = False
                     found = True
-                if '=cut' in line:
-                    content = content + line[line.rfind('=cut') + 4:]
+                if "=cut" in line:
+                    content = content + line[line.rfind("=cut") + 4:]
                     line = content
                     copy = True
                     found = True
-                if '#' in line:
-                    content = line[:line.find('#')].rstrip() + '\n'
+                if "#" in line:
+                    content = line[: line.find("#")].rstrip() + "\n"
                     found = True
                 if not found:
                     content = line
-                if copy and content.strip() != '':
+                if copy and content.strip() != "":
                     f1.write(content)
     f.close()
     f1.close()
diff --git a/nirjas/languages/php.py b/nirjas/languages/php.py
index c756d14..9481301 100644
--- a/nirjas/languages/php.py
+++ b/nirjas/languages/php.py
@@ -1,6 +1,6 @@
 #!/usr/bin/env python3
 # -*- coding: utf-8 -*-
-'''
+"""
 Copyright (C) 2020  Ayush Bhardwaj (classicayush@gmail.com),
 Kaushlendra Pratap (kaushlendrapratap.9837@gmail.com)
 
@@ -19,20 +19,20 @@
 You should have received a copy of the GNU Lesser General Public
 License along with this library; if not, write to the Free Software
 Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
-'''
+"""
 
 from nirjas.binder import CommentSyntax, contSingleLines
 from nirjas.output import ScanOutput, SingleLine, MultiLine
 
 
 def phpExtractor(file):
-    '''
+    """
     Extract comments from PHP file.
     :param file: File to scan
     :type file: string
     :return: Scan output
     :rtype: ScanOutput
-    '''
+    """
     result = CommentSyntax()
     single_line_comment = result.doubleSlash(file)
     multiline_comment = result.slashStar(file)
@@ -40,7 +40,7 @@ def phpExtractor(file):
     file = file.split("/")
     output = ScanOutput()
     output.filename = file[-1]
-    output.lang = 'PHP'
+    output.lang = "PHP"
     output.total_lines = single_line_comment[1]
     output.total_lines_of_comments = single_line_comment[3] + multiline_comment[3]
     output.blank_lines = single_line_comment[2]
@@ -52,20 +52,28 @@ def phpExtractor(file):
         output.single_line_comment.append(SingleLine(i[0], i[1]))
 
     for idx, _ in enumerate(cont_single_line_comment[1]):
-        output.cont_single_line_comment.append(MultiLine(
-            cont_single_line_comment[1][idx], cont_single_line_comment[2][idx],
-            cont_single_line_comment[3][idx]))
+        output.cont_single_line_comment.append(
+            MultiLine(
+                cont_single_line_comment[1][idx],
+                cont_single_line_comment[2][idx],
+                cont_single_line_comment[3][idx],
+            )
+        )
 
     for idx, _ in enumerate(multiline_comment[0]):
-        output.multi_line_comment.append(MultiLine(multiline_comment[0][idx],
-                                                   multiline_comment[1][idx],
-                                                   multiline_comment[2][idx]))
+        output.multi_line_comment.append(
+            MultiLine(
+                multiline_comment[0][idx],
+                multiline_comment[1][idx],
+                multiline_comment[2][idx],
+            )
+        )
 
     return output
 
 
 def phpSource(file, new_file: str):
-    '''
+    """
     Extract source from PHP file and put at new_file.
     :param file: File to process
     :type file: string
@@ -73,34 +81,34 @@ def phpSource(file, new_file: str):
     :type new_file: string
     :return: Path to new file
     :rtype: string
-    '''
+    """
     copy = True
-    with open(new_file, 'w+') as f1:
+    with open(new_file, "w+") as f1:
         with open(file) as f:
             for line in f:
                 content = ""
                 found = False
-                if '/*' in line:
-                    pos = line.find('/*')
+                if "/*" in line:
+                    pos = line.find("/*")
                     content = line[:pos].rstrip()
                     line = line[pos:]
                     copy = False
                     found = True
-                if '*/' in line:
-                    content = content + line[line.rfind('*/') + 2:]
+                if "*/" in line:
+                    content = content + line[line.rfind("*/") + 2:]
                     line = content
                     copy = True
                     found = True
-                if '//' in line:
-                    if line[line.find('//') - 1] != ':':
-                        line = line[:line.find('//')].rstrip() + '\n'
-                    elif line[line.rfind('//') - 1] != ':':
-                        line = line[:line.rfind('//')].rstrip() + '\n'
+                if "//" in line:
+                    if line[line.find("//") - 1] != ":":
+                        line = line[: line.find("//")].rstrip() + "\n"
+                    elif line[line.rfind("//") - 1] != ":":
+                        line = line[: line.rfind("//")].rstrip() + "\n"
                     content = line
                     found = True
                 if not found:
                     content = line
-                if copy and content.strip() != '':
+                if copy and content.strip() != "":
                     f1.write(content)
     f.close()
     f1.close()
diff --git a/nirjas/languages/python.py b/nirjas/languages/python.py
index 435ed6c..cbb7613 100644
--- a/nirjas/languages/python.py
+++ b/nirjas/languages/python.py
@@ -1,6 +1,6 @@
 #!/usr/bin/env python3
 # -*- coding: utf-8 -*-
-'''
+"""
 Copyright (C) 2020  Ayush Bhardwaj (classicayush@gmail.com),
 Kaushlendra Pratap (kaushlendrapratap.9837@gmail.com)
 
@@ -19,20 +19,20 @@
 You should have received a copy of the GNU Lesser General Public
 License along with this library; if not, write to the Free Software
 Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
-'''
+"""
 
 from nirjas.binder import CommentSyntax, contSingleLines
 from nirjas.output import ScanOutput, SingleLine, MultiLine
 
 
 def pythonExtractor(file):
-    '''
+    """
     Extract comments from Python file.
     :param file: File to scan
     :type file: string
     :return: Scan output
     :rtype: ScanOutput
-    '''
+    """
     result = CommentSyntax()
     single_line_comment = result.hash(file)
     multiline_single_comment = result.singleQuotes(file)
@@ -41,11 +41,10 @@ def pythonExtractor(file):
     file = file.split("/")
     output = ScanOutput()
     output.filename = file[-1]
-    output.lang = 'Python'
+    output.lang = "Python"
     output.total_lines = single_line_comment[1]
-    output.total_lines_of_comments = single_line_comment[3] + \
-                                     multiline_single_comment[3] + \
-                                     multiline_double_comment[3]
+    output.total_lines_of_comments = (
+        single_line_comment[3] + multiline_single_comment[3] + multiline_double_comment[3])
     output.blank_lines = single_line_comment[2]
 
     if cont_single_line_comment:
@@ -55,33 +54,43 @@ def pythonExtractor(file):
         output.single_line_comment.append(SingleLine(i[0], i[1]))
 
     for idx, _ in enumerate(cont_single_line_comment[1]):
-        output.cont_single_line_comment.append(MultiLine(
-            cont_single_line_comment[1][idx], cont_single_line_comment[2][idx],
-            cont_single_line_comment[3][idx]))
+        output.cont_single_line_comment.append(
+            MultiLine(
+                cont_single_line_comment[1][idx],
+                cont_single_line_comment[2][idx],
+                cont_single_line_comment[3][idx],
+            )
+        )
 
     try:
         for idx, _ in enumerate(multiline_single_comment[0]):
-            output.multi_line_comment.append(MultiLine(
-                multiline_single_comment[0][idx],
-                multiline_single_comment[1][idx],
-                multiline_single_comment[2][idx]))
-    except:
+            output.multi_line_comment.append(
+                MultiLine(
+                    multiline_single_comment[0][idx],
+                    multiline_single_comment[1][idx],
+                    multiline_single_comment[2][idx],
+                )
+            )
+    except BaseException:
         pass
 
     try:
         for idx, _ in enumerate(multiline_double_comment[0]):
-            output.multi_line_comment.append(MultiLine(
-                multiline_double_comment[0][idx],
-                multiline_double_comment[1][idx],
-                multiline_double_comment[2][idx]))
-    except:
+            output.multi_line_comment.append(
+                MultiLine(
+                    multiline_double_comment[0][idx],
+                    multiline_double_comment[1][idx],
+                    multiline_double_comment[2][idx],
+                )
+            )
+    except BaseException:
         pass
 
     return output
 
 
 def pythonSource(file, new_file: str):
-    '''
+    """
     Extract source from Python file and put at new_file.
     :param file: File to process
     :type file: string
@@ -89,9 +98,9 @@ def pythonSource(file, new_file: str):
     :type new_file: string
     :return: Path to new file
     :rtype: string
-    '''
+    """
     copy = True
-    with open(new_file, 'w+') as f1:
+    with open(new_file, "w+") as f1:
         with open(file) as f:
             for line in f:
                 content = ""
@@ -120,12 +129,12 @@ def pythonSource(file, new_file: str):
                         line = content
                         copy = True
                         found = True
-                if '#' in line:
-                    content = line[:line.find('#')].rstrip() + '\n'
+                if "#" in line:
+                    content = line[: line.find("#")].rstrip() + "\n"
                     found = True
                 if not found:
                     content = line
-                if copy and content.strip() != '':
+                if copy and content.strip() != "":
                     f1.write(content)
     f.close()
     f1.close()
diff --git a/nirjas/languages/r.py b/nirjas/languages/r.py
index 2b1fde4..762534d 100644
--- a/nirjas/languages/r.py
+++ b/nirjas/languages/r.py
@@ -1,6 +1,6 @@
 #!/usr/bin/env python3
 # -*- coding: utf-8 -*-
-'''
+"""
 Copyright (C) 2020  Ayush Bhardwaj (classicayush@gmail.com),
 Kaushlendra Pratap (kaushlendrapratap.9837@gmail.com)
 
@@ -19,26 +19,26 @@
 You should have received a copy of the GNU Lesser General Public
 License along with this library; if not, write to the Free Software
 Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
-'''
+"""
 
 from nirjas.binder import CommentSyntax
 from nirjas.output import ScanOutput, SingleLine
 
 
 def rExtractor(file):
-    '''
+    """
     Extract comments from R file.
     :param file: File to scan
     :type file: string
     :return: Scan output
     :rtype: ScanOutput
-    '''
+    """
     result = CommentSyntax()
     single_line_comment = result.hash(file)
     file = file.split("/")
     output = ScanOutput()
     output.filename = file[-1]
-    output.lang = 'R'
+    output.lang = "R"
     output.total_lines = single_line_comment[1]
     output.total_lines_of_comments = single_line_comment[3]
     output.blank_lines = single_line_comment[2]
@@ -50,7 +50,7 @@ def rExtractor(file):
 
 
 def rSource(file, new_file: str):
-    '''
+    """
     Extract source from R file and put at new_file.
     :param file: File to process
     :type file: string
@@ -58,14 +58,14 @@ def rSource(file, new_file: str):
     :type new_file: string
     :return: Path to new file
     :rtype: string
-    '''
-    with open(new_file, 'w+') as f1:
+    """
+    with open(new_file, "w+") as f1:
         with open(file) as f:
             for line in f:
                 content = line
-                if '#' in line:
-                    content = line[:line.find('#')].rstrip() + '\n'
-                if content.strip() != '':
+                if "#" in line:
+                    content = line[: line.find("#")].rstrip() + "\n"
+                if content.strip() != "":
                     f1.write(content)
     f.close()
     f1.close()
diff --git a/nirjas/languages/ruby.py b/nirjas/languages/ruby.py
index 772fd22..79cb7f2 100644
--- a/nirjas/languages/ruby.py
+++ b/nirjas/languages/ruby.py
@@ -1,6 +1,6 @@
 #!/usr/bin/env python3
 # -*- coding: utf-8 -*-
-'''
+"""
 Copyright (C) 2020  Ayush Bhardwaj (classicayush@gmail.com),
 Kaushlendra Pratap (kaushlendrapratap.9837@gmail.com)
 
@@ -19,20 +19,20 @@
 You should have received a copy of the GNU Lesser General Public
 License along with this library; if not, write to the Free Software
 Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
-'''
+"""
 
 from nirjas.binder import CommentSyntax, contSingleLines
 from nirjas.output import ScanOutput, SingleLine, MultiLine
 
 
 def rubyExtractor(file):
-    '''
+    """
     Extract comments from Ruby file.
     :param file: File to scan
     :type file: string
     :return: Scan output
     :rtype: ScanOutput
-    '''
+    """
     result = CommentSyntax()
     single_line_comment = result.hashNoCurl(file)
     multiline_comment = result.beginEnd(file)
@@ -40,7 +40,7 @@ def rubyExtractor(file):
     file = file.split("/")
     output = ScanOutput()
     output.filename = file[-1]
-    output.lang = 'Ruby'
+    output.lang = "Ruby"
     output.total_lines = single_line_comment[1]
     output.total_lines_of_comments = single_line_comment[3] + multiline_comment[3]
     output.blank_lines = single_line_comment[2]
@@ -52,20 +52,28 @@ def rubyExtractor(file):
         output.single_line_comment.append(SingleLine(i[0], i[1]))
 
     for idx, _ in enumerate(cont_single_line_comment[1]):
-        output.cont_single_line_comment.append(MultiLine(
-            cont_single_line_comment[1][idx], cont_single_line_comment[2][idx],
-            cont_single_line_comment[3][idx]))
+        output.cont_single_line_comment.append(
+            MultiLine(
+                cont_single_line_comment[1][idx],
+                cont_single_line_comment[2][idx],
+                cont_single_line_comment[3][idx],
+            )
+        )
 
     for idx, _ in enumerate(multiline_comment[0]):
-        output.multi_line_comment.append(MultiLine(multiline_comment[0][idx],
-                                                   multiline_comment[1][idx],
-                                                   multiline_comment[2][idx]))
+        output.multi_line_comment.append(
+            MultiLine(
+                multiline_comment[0][idx],
+                multiline_comment[1][idx],
+                multiline_comment[2][idx],
+            )
+        )
 
     return output
 
 
 def rubySource(file, new_file: str):
-    '''
+    """
     Extract source from Ruby file and put at new_file.
     :param file: File to process
     :type file: string
@@ -73,30 +81,30 @@ def rubySource(file, new_file: str):
     :type new_file: string
     :return: Path to new file
     :rtype: string
-    '''
+    """
     copy = True
-    with open(new_file, 'w+') as f1:
+    with open(new_file, "w+") as f1:
         with open(file) as f:
             for line in f:
                 content = ""
                 found = False
-                if '=begin' in line:
-                    pos = line.find('=begin')
+                if "=begin" in line:
+                    pos = line.find("=begin")
                     content = line[:pos].rstrip()
                     line = line[pos:]
                     copy = False
                     found = True
-                if '=end' in line:
-                    content = content + line[line.rfind('=end') + 4:]
+                if "=end" in line:
+                    content = content + line[line.rfind("=end") + 4:]
                     line = content
                     copy = True
                     found = True
-                if '#' in line:
-                    content = line[:line.find('#')].rstrip() + '\n'
+                if "#" in line:
+                    content = line[: line.find("#")].rstrip() + "\n"
                     found = True
                 if not found:
                     content = line
-                if copy and content.strip() != '':
+                if copy and content.strip() != "":
                     f1.write(content)
     f.close()
     f1.close()
diff --git a/nirjas/languages/rust.py b/nirjas/languages/rust.py
index 72b6c6a..be66e04 100644
--- a/nirjas/languages/rust.py
+++ b/nirjas/languages/rust.py
@@ -1,6 +1,6 @@
 #!/usr/bin/env python3
 # -*- coding: utf-8 -*-
-'''
+"""
 Copyright (C) 2020  Ayush Bhardwaj (classicayush@gmail.com),
 Kaushlendra Pratap (kaushlendrapratap.9837@gmail.com)
 
@@ -19,20 +19,20 @@
 You should have received a copy of the GNU Lesser General Public
 License along with this library; if not, write to the Free Software
 Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
-'''
+"""
 
 from nirjas.binder import CommentSyntax, contSingleLines
 from nirjas.output import ScanOutput, SingleLine, MultiLine
 
 
 def rustExtractor(file):
-    '''
+    """
     Extract comments from Rust file.
     :param file: File to scan
     :type file: string
     :return: Scan output
     :rtype: ScanOutput
-    '''
+    """
     result = CommentSyntax()
     single_line_comment = result.doubleSlash(file)
     multiline_comment = result.slashStar(file)
@@ -40,7 +40,7 @@ def rustExtractor(file):
     file = file.split("/")
     output = ScanOutput()
     output.filename = file[-1]
-    output.lang = 'Rust'
+    output.lang = "Rust"
     output.total_lines = single_line_comment[1]
     output.total_lines_of_comments = single_line_comment[3] + multiline_comment[3]
     output.blank_lines = single_line_comment[2]
@@ -52,20 +52,28 @@ def rustExtractor(file):
         output.single_line_comment.append(SingleLine(i[0], i[1]))
 
     for idx, _ in enumerate(cont_single_line_comment[1]):
-        output.cont_single_line_comment.append(MultiLine(
-            cont_single_line_comment[1][idx], cont_single_line_comment[2][idx],
-            cont_single_line_comment[3][idx]))
+        output.cont_single_line_comment.append(
+            MultiLine(
+                cont_single_line_comment[1][idx],
+                cont_single_line_comment[2][idx],
+                cont_single_line_comment[3][idx],
+            )
+        )
 
     for idx, _ in enumerate(multiline_comment[0]):
-        output.multi_line_comment.append(MultiLine(multiline_comment[0][idx],
-                                                   multiline_comment[1][idx],
-                                                   multiline_comment[2][idx]))
+        output.multi_line_comment.append(
+            MultiLine(
+                multiline_comment[0][idx],
+                multiline_comment[1][idx],
+                multiline_comment[2][idx],
+            )
+        )
 
     return output
 
 
 def rustSource(file, new_file: str):
-    '''
+    """
     Extract source from Rust file and put at new_file.
     :param file: File to process
     :type file: string
@@ -73,34 +81,34 @@ def rustSource(file, new_file: str):
     :type new_file: string
     :return: Path to new file
     :rtype: string
-    '''
+    """
     copy = True
-    with open(new_file, 'w+') as f1:
+    with open(new_file, "w+") as f1:
         with open(file) as f:
             for line in f:
                 content = ""
                 found = False
-                if '/*' in line:
-                    pos = line.find('/*')
+                if "/*" in line:
+                    pos = line.find("/*")
                     content = line[:pos].rstrip()
                     line = line[pos:]
                     copy = False
                     found = True
-                if '*/' in line:
-                    content = content + line[line.rfind('*/') + 2:]
+                if "*/" in line:
+                    content = content + line[line.rfind("*/") + 2:]
                     line = content
                     copy = True
                     found = True
-                if '//' in line:
-                    if line[line.find('//') - 1] != ':':
-                        line = line[:line.find('//')].rstrip() + '\n'
-                    elif line[line.rfind('//') - 1] != ':':
-                        line = line[:line.rfind('//')].rstrip() + '\n'
+                if "//" in line:
+                    if line[line.find("//") - 1] != ":":
+                        line = line[: line.find("//")].rstrip() + "\n"
+                    elif line[line.rfind("//") - 1] != ":":
+                        line = line[: line.rfind("//")].rstrip() + "\n"
                     content = line
                     found = True
                 if not found:
                     content = line
-                if copy and content.strip() != '':
+                if copy and content.strip() != "":
                     f1.write(content)
     f.close()
     f1.close()
diff --git a/nirjas/languages/scala.py b/nirjas/languages/scala.py
index 0a2b0fe..5e9de11 100644
--- a/nirjas/languages/scala.py
+++ b/nirjas/languages/scala.py
@@ -1,6 +1,6 @@
 #!/usr/bin/env python3
 # -*- coding: utf-8 -*-
-'''
+"""
 Copyright (C) 2020  Ayush Bhardwaj (classicayush@gmail.com),
 Kaushlendra Pratap (kaushlendrapratap.9837@gmail.com)
 
@@ -19,20 +19,20 @@
 You should have received a copy of the GNU Lesser General Public
 License along with this library; if not, write to the Free Software
 Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
-'''
+"""
 
 from nirjas.binder import CommentSyntax, contSingleLines
 from nirjas.output import ScanOutput, SingleLine, MultiLine
 
 
 def scalaExtractor(file):
-    '''
+    """
     Extract comments from Scala file.
     :param file: File to scan
     :type file: string
     :return: Scan output
     :rtype: ScanOutput
-    '''
+    """
     result = CommentSyntax()
     single_line_comment = result.doubleSlash(file)
     multiline_comment = result.slashStar(file)
@@ -40,7 +40,7 @@ def scalaExtractor(file):
     file = file.split("/")
     output = ScanOutput()
     output.filename = file[-1]
-    output.lang = 'Scala'
+    output.lang = "Scala"
     output.total_lines = single_line_comment[1]
     output.total_lines_of_comments = single_line_comment[3] + multiline_comment[3]
     output.blank_lines = single_line_comment[2]
@@ -52,20 +52,28 @@ def scalaExtractor(file):
         output.single_line_comment.append(SingleLine(i[0], i[1]))
 
     for idx, _ in enumerate(cont_single_line_comment[1]):
-        output.cont_single_line_comment.append(MultiLine(
-            cont_single_line_comment[1][idx], cont_single_line_comment[2][idx],
-            cont_single_line_comment[3][idx]))
+        output.cont_single_line_comment.append(
+            MultiLine(
+                cont_single_line_comment[1][idx],
+                cont_single_line_comment[2][idx],
+                cont_single_line_comment[3][idx],
+            )
+        )
 
     for idx, _ in enumerate(multiline_comment[0]):
-        output.multi_line_comment.append(MultiLine(multiline_comment[0][idx],
-                                                   multiline_comment[1][idx],
-                                                   multiline_comment[2][idx]))
+        output.multi_line_comment.append(
+            MultiLine(
+                multiline_comment[0][idx],
+                multiline_comment[1][idx],
+                multiline_comment[2][idx],
+            )
+        )
 
     return output
 
 
 def scalaSource(file, new_file: str):
-    '''
+    """
     Extract source from Scala file and put at new_file.
     :param file: File to process
     :type file: string
@@ -73,34 +81,34 @@ def scalaSource(file, new_file: str):
     :type new_file: string
     :return: Path to new file
     :rtype: string
-    '''
+    """
     copy = True
-    with open(new_file, 'w+') as f1:
+    with open(new_file, "w+") as f1:
         with open(file) as f:
             for line in f:
                 content = ""
                 found = False
-                if '/*' in line:
-                    pos = line.find('/*')
+                if "/*" in line:
+                    pos = line.find("/*")
                     content = line[:pos].rstrip()
                     line = line[pos:]
                     copy = False
                     found = True
-                if '*/' in line:
-                    content = content + line[line.rfind('*/') + 2:]
+                if "*/" in line:
+                    content = content + line[line.rfind("*/") + 2:]
                     line = content
                     copy = True
                     found = True
-                if '//' in line:
-                    if line[line.find('//') - 1] != ':':
-                        line = line[:line.find('//')].rstrip() + '\n'
-                    elif line[line.rfind('//') - 1] != ':':
-                        line = line[:line.rfind('//')].rstrip() + '\n'
+                if "//" in line:
+                    if line[line.find("//") - 1] != ":":
+                        line = line[: line.find("//")].rstrip() + "\n"
+                    elif line[line.rfind("//") - 1] != ":":
+                        line = line[: line.rfind("//")].rstrip() + "\n"
                     content = line
                     found = True
                 if not found:
                     content = line
-                if copy and content.strip() != '':
+                if copy and content.strip() != "":
                     f1.write(content)
     f.close()
     f1.close()
diff --git a/nirjas/languages/scss.py b/nirjas/languages/scss.py
index f26d6b7..6a40cb3 100644
--- a/nirjas/languages/scss.py
+++ b/nirjas/languages/scss.py
@@ -1,6 +1,6 @@
 #!/usr/bin/env python3
 # -*- coding: utf-8 -*-
-'''
+"""
 Copyright (C) 2020  Aman Dwivedi (aman.dwivedi5@gmail.com)
 
 SPDX-License-Identifier: LGPL-2.1
@@ -18,20 +18,20 @@
 You should have received a copy of the GNU Lesser General Public
 License along with this library; if not, write to the Free Software
 Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
-'''
+"""
 
 from nirjas.binder import CommentSyntax, contSingleLines
 from nirjas.output import ScanOutput, SingleLine, MultiLine
 
 
 def scssExtractor(file):
-    '''
+    """
     Extract comments from Scss file.
     :param file: File to scan
     :type file: string
     :return: Scan output
     :rtype: ScanOutput
-    '''
+    """
     result = CommentSyntax()
     single_line_comment = result.doubleNotTripleSlash(file)
     doc_comment = result.tripleSlash(file)
@@ -41,9 +41,11 @@ def scssExtractor(file):
     file = file.split("/")
     output = ScanOutput()
     output.filename = file[-1]
-    output.lang = 'Scss'
+    output.lang = "Scss"
     output.total_lines = single_line_comment[1]
-    output.total_lines_of_comments = single_line_comment[3] + doc_comment[3] + multiline_comment[3]
+    output.total_lines_of_comments = (
+        single_line_comment[3] + doc_comment[3] + multiline_comment[3]
+    )
     output.blank_lines = single_line_comment[2]
 
     if cont_single_line_comment:
@@ -59,28 +61,40 @@ def scssExtractor(file):
         output.single_line_comment.append(SingleLine(i[0], i[1]))
 
     for idx, _ in enumerate(cont_single_line_comment[1]):
-        output.cont_single_line_comment.append(MultiLine(
-            cont_single_line_comment[1][idx], cont_single_line_comment[2][idx],
-            cont_single_line_comment[3][idx]))
+        output.cont_single_line_comment.append(
+            MultiLine(
+                cont_single_line_comment[1][idx],
+                cont_single_line_comment[2][idx],
+                cont_single_line_comment[3][idx],
+            )
+        )
 
     for idx, _ in enumerate(cont_doc_comment[1]):
-        output.cont_single_line_comment.append(MultiLine(
-            cont_doc_comment[1][idx], cont_doc_comment[2][idx],
-            cont_doc_comment[3][idx]))
+        output.cont_single_line_comment.append(
+            MultiLine(
+                cont_doc_comment[1][idx],
+                cont_doc_comment[2][idx],
+                cont_doc_comment[3][idx],
+            )
+        )
 
     try:
         for idx, _ in enumerate(multiline_comment[0]):
-            output.multi_line_comment.append(MultiLine(multiline_comment[0][idx],
-                                                       multiline_comment[1][idx],
-                                                       multiline_comment[2][idx]))
-    except:
+            output.multi_line_comment.append(
+                MultiLine(
+                    multiline_comment[0][idx],
+                    multiline_comment[1][idx],
+                    multiline_comment[2][idx],
+                )
+            )
+    except BaseException:
         pass
 
     return output
 
 
 def scssSource(file, new_file: str):
-    '''
+    """
     Extract source from Scss file and put at new_file.
     :param file: File to process
     :type file: string
@@ -88,39 +102,39 @@ def scssSource(file, new_file: str):
     :type new_file: string
     :return: Path to new file
     :rtype: string
-    '''
+    """
     copy = True
-    with open(new_file, 'w+') as f1:
+    with open(new_file, "w+") as f1:
         with open(file) as f:
             for line in f:
                 content = ""
                 found = False
-                if '/*' in line:
-                    pos = line.find('/*')
+                if "/*" in line:
+                    pos = line.find("/*")
                     content = line[:pos].rstrip()
                     line = line[pos:]
                     copy = False
                     found = True
-                if '*/' in line:
-                    content = content + line[line.rfind('*/') + 2:]
+                if "*/" in line:
+                    content = content + line[line.rfind("*/") + 2:]
                     line = content
                     copy = True
                     found = True
-                if '///' in line:
-                    pos = line.find('///')
+                if "///" in line:
+                    pos = line.find("///")
                     content = line[:pos].rstrip()
                     line = line[pos:]
                     found = True
-                if '//' in line:
-                    if line[line.find('//') - 1] != ':':
-                        line = line[:line.find('//')].rstrip() + '\n'
-                    elif line[line.rfind('//') - 1] != ':':
-                        line = line[:line.rfind('//')].rstrip() + '\n'
+                if "//" in line:
+                    if line[line.find("//") - 1] != ":":
+                        line = line[: line.find("//")].rstrip() + "\n"
+                    elif line[line.rfind("//") - 1] != ":":
+                        line = line[: line.rfind("//")].rstrip() + "\n"
                     content = line
                     found = True
                 if not found:
                     content = line
-                if copy and content.strip() != '':
+                if copy and content.strip() != "":
                     f1.write(content)
     f.close()
     f1.close()
diff --git a/nirjas/languages/shell.py b/nirjas/languages/shell.py
index 66a46ce..ee109f9 100644
--- a/nirjas/languages/shell.py
+++ b/nirjas/languages/shell.py
@@ -1,6 +1,6 @@
 #!/usr/bin/env python3
 # -*- coding: utf-8 -*-
-'''
+"""
 Copyright (C) 2020  Ayush Bhardwaj (classicayush@gmail.com),
 Kaushlendra Pratap (kaushlendrapratap.9837@gmail.com)
 
@@ -19,27 +19,27 @@
 You should have received a copy of the GNU Lesser General Public
 License along with this library; if not, write to the Free Software
 Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
-'''
+"""
 
 from nirjas.binder import CommentSyntax, contSingleLines
 from nirjas.output import ScanOutput, SingleLine, MultiLine
 
 
 def shellExtractor(file):
-    '''
+    """
     Extract comments from Shell file.
     :param file: File to scan
     :type file: string
     :return: Scan output
     :rtype: ScanOutput
-    '''
+    """
     result = CommentSyntax()
     single_line_comment = result.hash(file)
     cont_single_line_comment = contSingleLines(single_line_comment)
     file = file.split("/")
     output = ScanOutput()
     output.filename = file[-1]
-    output.lang = 'Shell'
+    output.lang = "Shell"
     output.total_lines = single_line_comment[1]
     output.total_lines_of_comments = single_line_comment[3]
     output.blank_lines = single_line_comment[2]
@@ -51,15 +51,19 @@ def shellExtractor(file):
         output.single_line_comment.append(SingleLine(i[0], i[1]))
 
     for idx, _ in enumerate(cont_single_line_comment[1]):
-        output.cont_single_line_comment.append(MultiLine(
-            cont_single_line_comment[1][idx], cont_single_line_comment[2][idx],
-            cont_single_line_comment[3][idx]))
+        output.cont_single_line_comment.append(
+            MultiLine(
+                cont_single_line_comment[1][idx],
+                cont_single_line_comment[2][idx],
+                cont_single_line_comment[3][idx],
+            )
+        )
 
     return output
 
 
 def shellSource(file, new_file: str):
-    '''
+    """
     Extract source from Shell file and put at new_file.
     :param file: File to process
     :type file: string
@@ -67,14 +71,14 @@ def shellSource(file, new_file: str):
     :type new_file: string
     :return: Path to new file
     :rtype: string
-    '''
-    with open(new_file, 'w+') as f1:
+    """
+    with open(new_file, "w+") as f1:
         with open(file) as f:
             for line in f:
                 content = line
-                if '#' in line:
-                    content = line[:line.find('#')].rstrip() + '\n'
-                if content.strip() != '':
+                if "#" in line:
+                    content = line[: line.find("#")].rstrip() + "\n"
+                if content.strip() != "":
                     f1.write(content)
     f.close()
     f1.close()
diff --git a/nirjas/languages/swift.py b/nirjas/languages/swift.py
index 37043b6..2ab762f 100644
--- a/nirjas/languages/swift.py
+++ b/nirjas/languages/swift.py
@@ -1,6 +1,6 @@
 #!/usr/bin/env python3
 # -*- coding: utf-8 -*-
-'''
+"""
 Copyright (C) 2020  Ayush Bhardwaj (classicayush@gmail.com),
 Kaushlendra Pratap (kaushlendrapratap.9837@gmail.com)
 
@@ -19,20 +19,20 @@
 You should have received a copy of the GNU Lesser General Public
 License along with this library; if not, write to the Free Software
 Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
-'''
+"""
 
 from nirjas.binder import CommentSyntax, contSingleLines
 from nirjas.output import ScanOutput, SingleLine, MultiLine
 
 
 def swiftExtractor(file):
-    '''
+    """
     Extract comments from Swift file.
     :param file: File to scan
     :type file: string
     :return: Scan output
     :rtype: ScanOutput
-    '''
+    """
     result = CommentSyntax()
     single_line_comment = result.doubleSlash(file)
     multiline_comment = result.slashStar(file)
@@ -40,7 +40,7 @@ def swiftExtractor(file):
     file = file.split("/")
     output = ScanOutput()
     output.filename = file[-1]
-    output.lang = 'Swift'
+    output.lang = "Swift"
     output.total_lines = single_line_comment[1]
     output.total_lines_of_comments = single_line_comment[3] + multiline_comment[3]
     output.blank_lines = single_line_comment[2]
@@ -52,20 +52,28 @@ def swiftExtractor(file):
         output.single_line_comment.append(SingleLine(i[0], i[1]))
 
     for idx, _ in enumerate(cont_single_line_comment[1]):
-        output.cont_single_line_comment.append(MultiLine(
-            cont_single_line_comment[1][idx], cont_single_line_comment[2][idx],
-            cont_single_line_comment[3][idx]))
+        output.cont_single_line_comment.append(
+            MultiLine(
+                cont_single_line_comment[1][idx],
+                cont_single_line_comment[2][idx],
+                cont_single_line_comment[3][idx],
+            )
+        )
 
     for idx, _ in enumerate(multiline_comment[0]):
-        output.multi_line_comment.append(MultiLine(multiline_comment[0][idx],
-                                                   multiline_comment[1][idx],
-                                                   multiline_comment[2][idx]))
+        output.multi_line_comment.append(
+            MultiLine(
+                multiline_comment[0][idx],
+                multiline_comment[1][idx],
+                multiline_comment[2][idx],
+            )
+        )
 
     return output
 
 
 def swiftSource(file, new_file: str):
-    '''
+    """
     Extract source from Swift file and put at new_file.
     :param file: File to process
     :type file: string
@@ -73,34 +81,34 @@ def swiftSource(file, new_file: str):
     :type new_file: string
     :return: Path to new file
     :rtype: string
-    '''
+    """
     copy = True
-    with open(new_file, 'w+') as f1:
+    with open(new_file, "w+") as f1:
         with open(file) as f:
             for line in f:
                 content = ""
                 found = False
-                if '/*' in line:
-                    pos = line.find('/*')
+                if "/*" in line:
+                    pos = line.find("/*")
                     content = line[:pos].rstrip()
                     line = line[pos:]
                     copy = False
                     found = True
-                if '*/' in line:
-                    content = content + line[line.rfind('*/') + 2:]
+                if "*/" in line:
+                    content = content + line[line.rfind("*/") + 2:]
                     line = content
                     copy = True
                     found = True
-                if '//' in line:
-                    if line[line.find('//') - 1] != ':':
-                        line = line[:line.find('//')].rstrip() + '\n'
-                    elif line[line.rfind('//') - 1] != ':':
-                        line = line[:line.rfind('//')].rstrip() + '\n'
+                if "//" in line:
+                    if line[line.find("//") - 1] != ":":
+                        line = line[: line.find("//")].rstrip() + "\n"
+                    elif line[line.rfind("//") - 1] != ":":
+                        line = line[: line.rfind("//")].rstrip() + "\n"
                     content = line
                     found = True
                 if not found:
                     content = line
-                if copy and content.strip() != '':
+                if copy and content.strip() != "":
                     f1.write(content)
     f.close()
     f1.close()
diff --git a/nirjas/languages/text.py b/nirjas/languages/text.py
index 5a5bfff..d181393 100644
--- a/nirjas/languages/text.py
+++ b/nirjas/languages/text.py
@@ -1,6 +1,6 @@
 #!/usr/bin/env python3
 # -*- coding: utf-8 -*-
-'''
+"""
 Copyright (C) 2020  Ayush Bhardwaj (classicayush@gmail.com),
 Kaushlendra Pratap (kaushlendrapratap.9837@gmail.com)
 
@@ -19,34 +19,34 @@
 You should have received a copy of the GNU Lesser General Public
 License along with this library; if not, write to the Free Software
 Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
-'''
+"""
 
 from nirjas.output import ScanOutput, MultiLine
 
 
 def textExtractor(file):
-    '''
+    """
     Extract comments from txt file.
     :param file: File to scan
     :type file: string
     :return: Scan output
     :rtype: ScanOutput
-    '''
+    """
     content = ""
     total_lines, blank_lines = 0, 0
     with open(file) as f:
         for line in f:
             total_lines += 1
             line = line.strip()
-            content = content + line.replace('\n', ' ')
-            if line == '':
+            content = content + line.replace("\n", " ")
+            if line == "":
                 blank_lines += 1
 
-    file = file.split('/')
+    file = file.split("/")
 
     output = ScanOutput()
     output.filename = file[-1]
-    output.lang = 'text'
+    output.lang = "text"
     output.total_lines = total_lines
     output.total_lines_of_comments = total_lines - blank_lines
     output.blank_lines = blank_lines
diff --git a/nirjas/languages/typescript.py b/nirjas/languages/typescript.py
index 0ce364b..371fb8f 100644
--- a/nirjas/languages/typescript.py
+++ b/nirjas/languages/typescript.py
@@ -1,6 +1,6 @@
 #!/usr/bin/env python3
 # -*- coding: utf-8 -*-
-'''
+"""
 Copyright (C) 2020  Aman Dwivedi (aman.dwivedi5@gmail.com)
 
 SPDX-License-Identifier: LGPL-2.1
@@ -18,20 +18,20 @@
 You should have received a copy of the GNU Lesser General Public
 License along with this library; if not, write to the Free Software
 Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
-'''
+"""
 
 from nirjas.binder import CommentSyntax, contSingleLines
 from nirjas.output import ScanOutput, SingleLine, MultiLine
 
 
 def typescriptExtractor(file):
-    '''
+    """
     Extract comments from TypeScript file.
     :param file: File to scan
     :type file: string
     :return: Scan output
     :rtype: ScanOutput
-    '''
+    """
     result = CommentSyntax()
     single_line_comment = result.doubleSlash(file)
     multiline_comment = result.slashStar(file)
@@ -39,7 +39,7 @@ def typescriptExtractor(file):
     file = file.split("/")
     output = ScanOutput()
     output.filename = file[-1]
-    output.lang = 'TypeScript'
+    output.lang = "TypeScript"
     output.total_lines = single_line_comment[1]
     output.total_lines_of_comments = single_line_comment[3] + multiline_comment[3]
     output.blank_lines = single_line_comment[2]
@@ -51,23 +51,31 @@ def typescriptExtractor(file):
         output.single_line_comment.append(SingleLine(i[0], i[1]))
 
     for idx, _ in enumerate(cont_single_line_comment[1]):
-        output.cont_single_line_comment.append(MultiLine(
-            cont_single_line_comment[1][idx], cont_single_line_comment[2][idx],
-            cont_single_line_comment[3][idx]))
+        output.cont_single_line_comment.append(
+            MultiLine(
+                cont_single_line_comment[1][idx],
+                cont_single_line_comment[2][idx],
+                cont_single_line_comment[3][idx],
+            )
+        )
 
     try:
         for idx, _ in enumerate(multiline_comment[0]):
-            output.multi_line_comment.append(MultiLine(multiline_comment[0][idx],
-                                                       multiline_comment[1][idx],
-                                                       multiline_comment[2][idx]))
-    except:
+            output.multi_line_comment.append(
+                MultiLine(
+                    multiline_comment[0][idx],
+                    multiline_comment[1][idx],
+                    multiline_comment[2][idx],
+                )
+            )
+    except BaseException:
         pass
 
     return output
 
 
 def typescriptSource(file, new_file: str):
-    '''
+    """
     Extract source from TypeScript file and put at new_file.
     :param file: File to process
     :type file: string
@@ -75,34 +83,34 @@ def typescriptSource(file, new_file: str):
     :type new_file: string
     :return: Path to new file
     :rtype: string
-    '''
+    """
     copy = True
-    with open(new_file, 'w+') as f1:
+    with open(new_file, "w+") as f1:
         with open(file) as f:
             for line in f:
                 content = ""
                 found = False
-                if '/*' in line:
-                    pos = line.find('/*')
+                if "/*" in line:
+                    pos = line.find("/*")
                     content = line[:pos].rstrip()
                     line = line[pos:]
                     copy = False
                     found = True
-                if '*/' in line:
-                    content = content + line[line.rfind('*/') + 2:]
+                if "*/" in line:
+                    content = content + line[line.rfind("*/") + 2:]
                     line = content
                     copy = True
                     found = True
-                if '//' in line:
-                    if line[line.find('//') - 1] != ':':
-                        line = line[:line.find('//')].rstrip() + '\n'
-                    elif line[line.rfind('//') - 1] != ':':
-                        line = line[:line.rfind('//')].rstrip() + '\n'
+                if "//" in line:
+                    if line[line.find("//") - 1] != ":":
+                        line = line[: line.find("//")].rstrip() + "\n"
+                    elif line[line.rfind("//") - 1] != ":":
+                        line = line[: line.rfind("//")].rstrip() + "\n"
                     content = line
                     found = True
                 if not found:
                     content = line
-                if copy and content.strip() != '':
+                if copy and content.strip() != "":
                     f1.write(content)
     f.close()
     f1.close()
diff --git a/nirjas/main.py b/nirjas/main.py
index a3d0588..8ca7829 100644
--- a/nirjas/main.py
+++ b/nirjas/main.py
@@ -1,6 +1,6 @@
 #!/usr/bin/env python3
 # -*- coding: utf-8 -*-
-'''
+"""
 Copyright (C) 2020  Ayush Bhardwaj (classicayush@gmail.com),
 Kaushlendra Pratap (kaushlendrapratap.9837@gmail.com)
 
@@ -19,77 +19,79 @@
 You should have received a copy of the GNU Lesser General Public
 License along with this library; if not, write to the Free Software
 Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
-'''
+"""
 
 import os
 import json
 import argparse
 
-from nirjas.languages import *
+from nirjas.languages import *  # noqa
+
 
 class NotSupportedExtension(Exception):
-    '''
+    """
     Exception if file extension is not recognized
-    '''
+    """
+
     def __str__(self):
         return "extension '" + self.args[0] + "' not supported"
 
 
 class LanguageMapper:
-    '''
+    """
     Class to help identify language based on file extension
-    '''
+    """
 
     LANG_MAP = {
-        '.py': 'python',
-        '.m4': 'python',
-        '.nsi': 'python',
-        '.hpp': 'cpp',
-        '.c': 'c',
-        '.h': 'cpp',
-        '.cs': 'c_sharp',
-        '.cpp': 'cpp',
-        '.scss': 'scss',
-        '.sep': 'cpp',
-        '.hxx': 'cpp',
-        '.cc': 'cpp',
-        '.css': 'css',
-        '.dart': 'dart',
-        '.go': 'go',
-        '.hs': 'haskell',
-        '.html': 'html',
-        '.xml': 'html',
-        '.java': 'java',
-        '.js': 'javascript',
-        '.jsx': 'javascript',
-        '.kt': 'kotlin',
-        '.kts': 'kotlin',
-        '.ktm': 'kotlin',
-        '.m': 'matlab',
-        '.php': 'php',
-        '.pl': 'perl',
-        '.r': 'r',
-        '.R': 'r',
-        '.rb': 'ruby',
-        '.rs': 'rust',
-        '.sh': 'shell',
-        '.swift': 'swift',
-        '.scala': 'scala',
-        '.sc': 'scala',
-        '.ts': 'typescript',
-        '.tsx': 'typescript',
-        '.txt': 'text',
-        '.lic': 'text',
-        '.install': 'text',
-        '.OSS': 'text',
-        '.gl': 'text',
+        ".py": "python",
+        ".m4": "python",
+        ".nsi": "python",
+        ".hpp": "cpp",
+        ".c": "c",
+        ".h": "cpp",
+        ".cs": "c_sharp",
+        ".cpp": "cpp",
+        ".scss": "scss",
+        ".sep": "cpp",
+        ".hxx": "cpp",
+        ".cc": "cpp",
+        ".css": "css",
+        ".dart": "dart",
+        ".go": "go",
+        ".hs": "haskell",
+        ".html": "html",
+        ".xml": "html",
+        ".java": "java",
+        ".js": "javascript",
+        ".jsx": "javascript",
+        ".kt": "kotlin",
+        ".kts": "kotlin",
+        ".ktm": "kotlin",
+        ".m": "matlab",
+        ".php": "php",
+        ".pl": "perl",
+        ".r": "r",
+        ".R": "r",
+        ".rb": "ruby",
+        ".rs": "rust",
+        ".sh": "shell",
+        ".swift": "swift",
+        ".scala": "scala",
+        ".sc": "scala",
+        ".ts": "typescript",
+        ".tsx": "typescript",
+        ".txt": "text",
+        ".lic": "text",
+        ".install": "text",
+        ".OSS": "text",
+        ".gl": "text",
     }
 
     @staticmethod
     def langIdentifier(file):
-        '''
+        """
         Return the programming language based on extension of path passed.
-        '''
+        """
         extension = os.path.splitext(file)[1]
         if extension not in LanguageMapper.LANG_MAP:
             raise NotSupportedExtension(extension)
@@ -97,31 +99,43 @@ def langIdentifier(file):
 
 
 def run_and_print():
-    '''
+    """
     Call the run_cli() method and print results to stdout.
-    '''
+    """
     print(run_cli())
 
 
 def run_cli():
-    '''
-    Accept the parameters from CLI, run the nirjas logic and return the results.
-    '''
+    """
+    Accept the parameters from CLI,
+    run the nirjas logic and return the results.
+    """
     parser = argparse.ArgumentParser()
-    parser.add_argument("path", default=None, nargs='?',
-                        help="Specify the input file/directory path to scan")
-    parser.add_argument("-i", "--inputFile", default=None,
-                        help="Specify the input file to extract the source code from")
-    parser.add_argument("-o", "--outFile",
-                        help="The name of file to put the code in",
-                        default="source.txt")
+    parser.add_argument(
+        "path",
+        default=None,
+        nargs="?",
+        help="Specify the input file/directory path to scan",
+    )
+    parser.add_argument(
+        "-i",
+        "--inputFile",
+        default=None,
+        help="Specify the input file to extract the source code from",
+    )
+    parser.add_argument(
+        "-o",
+        "--outFile",
+        help="The name of file to put the code in",
+        default="source.txt",
+    )
     args = parser.parse_args()
     file = args.path
     inputfile = args.inputFile
     out_file = args.outFile
     try:
         if file is not None:
-            return file_runner(file, 'json')
+            return file_runner(file, "json")
         return inputfile_runner(inputfile, out_file)
     except NotSupportedExtension as e:
         print(e, file=os.sys.stderr)
@@ -129,27 +143,27 @@ def run_cli():
 
 
 def scan_the_file(file):
-    '''
+    """
     Run scanner on single file and return the results.
     :param file: File to scan
     :type file: string
     :return: Scan result
     :rtype: ScanOutput
-    '''
+    """
     langname = LanguageMapper.langIdentifier(file)
-    func = langname + '.' + langname + 'Extractor'
+    func = langname + "." + langname + "Extractor"
     return eval(func)(file)
 
 
-def file_runner(file, type='dictionary'):
-    '''
+def file_runner(file, type="dictionary"):
+    """
     Check if the input is a file or a directory and iterate with
     scan_the_file()
     :param file: Path to scan
     :type file: string
     :return: List of scan result
     :rtype: list
-    '''
+    """
     result = []
     if os.path.isfile(file):
         result = scan_the_file(file).get_dict()
@@ -162,21 +176,21 @@ def file_runner(file, type='dictionary'):
                         result.append(scan_the_file(file_to_scan).get_dict())
                 except Exception:
                     continue
-    if type == 'json':
+    if type == "json":
         return json.dumps(result, sort_keys=False, indent=4)
     return result
 
 
 def inputfile_runner(inputfile, out_file):
-    '''
+    """
     Extract the source from inputfile and put at out_file.
     :param inputfile: File to process
     :type inputfile: string
     :param out_file: Output file location
     :type out_file: string
-    '''
+    """
     langname = LanguageMapper.langIdentifier(inputfile)
-    func = langname + '.' + langname + 'Source'
+    func = langname + "." + langname + "Source"
     return eval(func)(inputfile, out_file)
 
 
diff --git a/nirjas/output/__init__.py b/nirjas/output/__init__.py
index c98f360..43753bc 100644
--- a/nirjas/output/__init__.py
+++ b/nirjas/output/__init__.py
@@ -1,6 +1,6 @@
 #!/usr/bin/env python3
 # -*- coding: utf-8 -*-
-'''
+"""
 Copyright (C) 2020 Siemens AG
 Author: Gaurav Mishra <mishra.gaurav@siemens.com>
 
@@ -21,9 +21,9 @@
 Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
 
 Module to hold output classes.
-'''
+"""
 
-from .scan_output import ScanOutput
-from .single_line import SingleLine
-from .multi_line import MultiLine
-from .output import Output
+from .scan_output import ScanOutput  # noqa
+from .single_line import SingleLine  # noqa
+from .multi_line import MultiLine  # noqa
+from .output import Output  # noqa
diff --git a/nirjas/output/multi_line.py b/nirjas/output/multi_line.py
index eb2ddcf..e01497b 100644
--- a/nirjas/output/multi_line.py
+++ b/nirjas/output/multi_line.py
@@ -1,6 +1,6 @@
 #!/usr/bin/env python3
 # -*- coding: utf-8 -*-
-'''
+"""
 Copyright (C) 2020 Siemens AG
 Author: Gaurav Mishra <mishra.gaurav@siemens.com>
 
@@ -19,15 +19,15 @@
 You should have received a copy of the GNU Lesser General Public
 License along with this library; if not, write to the Free Software
 Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
-'''
+"""
 
 from .output import Output
 
 
 class MultiLine:
-    '''
+    """
     Store result for multi line comments
-    '''
+    """
 
     def __init__(self, start, end, comment):
         self.start_line = start
@@ -35,9 +35,9 @@ def __init__(self, start, end, comment):
         self.comment = comment
 
     def get_dict(self):
-        '''
+        """
         Get the output as dictionary
-        '''
+        """
         return Output(
             start_line=self.start_line, end_line=self.end_line, comment=self.comment
         ).output
diff --git a/nirjas/output/output.py b/nirjas/output/output.py
index 4f87290..4facd6c 100644
--- a/nirjas/output/output.py
+++ b/nirjas/output/output.py
@@ -1,6 +1,6 @@
 #!/usr/bin/env python3
 # -*- coding: utf-8 -*-
-'''
+"""
 Copyright (C) 2021 Hamed Faramarzi
 Author: Hamed Faramarzi <hamed.faramarzi@gmail.com>
 
@@ -19,13 +19,13 @@
 You should have received a copy of the GNU Lesser General Public
 License along with this library; if not, write to the Free Software
 Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
-'''
+"""
 
 
 class Output(object):
-    '''
+    """
     return results
-    '''
+    """
 
     def __init__(self, **kwargs):
         self.result = {}
@@ -34,7 +34,7 @@ def __init__(self, **kwargs):
 
     @property
     def output(self):
-        '''
+        """
         return results
-        '''
+        """
         return self.result
diff --git a/nirjas/output/scan_output.py b/nirjas/output/scan_output.py
index 4a771b4..9706dab 100644
--- a/nirjas/output/scan_output.py
+++ b/nirjas/output/scan_output.py
@@ -1,6 +1,6 @@
 #!/usr/bin/env python3
 # -*- coding: utf-8 -*-
-'''
+"""
 Copyright (C) 2020 Siemens AG
 Author: Gaurav Mishra <mishra.gaurav@siemens.com>
 
@@ -19,15 +19,15 @@
 You should have received a copy of the GNU Lesser General Public
 License along with this library; if not, write to the Free Software
 Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
-'''
+"""
 
 from .output import Output
 
 
 class ScanOutput:
-    '''
+    """
     Generate the output for a single file scan.
-    '''
+    """
 
     def __init__(self):
         self.filename = None
@@ -40,9 +40,9 @@ def __init__(self):
         self.multi_line_comment = []
 
     def get_dict(self):
-        '''
+        """
         Get the output as dictionary
-        '''
+        """
         return Output(
             metadata=Output(
                 filename=self.filename,
@@ -50,8 +50,7 @@ def get_dict(self):
                 total_lines=self.total_lines,
                 total_lines_of_comments=self.total_lines_of_comments,
                 blank_lines=self.blank_lines,
-                sloc=self.total_lines
-                - (self.total_lines_of_comments + self.blank_lines),
+                sloc=self.total_lines - (self.total_lines_of_comments + self.blank_lines),
             ).output,
             single_line_comment=[c.get_dict() for c in self.single_line_comment],
             cont_single_line_comment=[
diff --git a/nirjas/output/single_line.py b/nirjas/output/single_line.py
index 01ea4b7..eadf49e 100644
--- a/nirjas/output/single_line.py
+++ b/nirjas/output/single_line.py
@@ -1,6 +1,6 @@
 #!/usr/bin/env python3
 # -*- coding: utf-8 -*-
-'''
+"""
 Copyright (C) 2020 Siemens AG
 Author: Gaurav Mishra <mishra.gaurav@siemens.com>
 
@@ -19,22 +19,22 @@
 You should have received a copy of the GNU Lesser General Public
 License along with this library; if not, write to the Free Software
 Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
-'''
+"""
 
 from .output import Output
 
 
 class SingleLine:
-    '''
+    """
     Store result for single line comments
-    '''
+    """
 
     def __init__(self, line_number, comment):
         self.line_number = line_number
         self.comment = comment
 
     def get_dict(self):
-        '''
+        """
         Get the output as dictionary
-        '''
+        """
         return Output(line_number=self.line_number, comment=self.comment).output


Test patch:
diff --git a/nirjas/languages/tests/__init__.py b/nirjas/languages/tests/__init__.py
index f2c451b..c93212b 100644
--- a/nirjas/languages/tests/__init__.py
+++ b/nirjas/languages/tests/__init__.py
@@ -1,6 +1,6 @@
 #!/usr/bin/env python3
 # -*- coding: utf-8 -*-
-'''
+"""
 SPDX-License-Identifier: LGPL-2.1
 
 This library is free software; you can redistribute it and/or
@@ -18,4 +18,4 @@
 Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
 
 Test scripts for Nirjas
-'''
+"""
diff --git a/nirjas/languages/tests/test_c.py b/nirjas/languages/tests/test_c.py
index c244715..2792f9c 100644
--- a/nirjas/languages/tests/test_c.py
+++ b/nirjas/languages/tests/test_c.py
@@ -1,6 +1,6 @@
 #!/usr/bin/env python3
 # -*- coding: utf-8 -*-
-'''
+"""
 SPDX-License-Identifier: LGPL-2.1
 
 This library is free software; you can redistribute it and/or
@@ -16,7 +16,7 @@
 You should have received a copy of the GNU Lesser General Public
 License along with this library; if not, write to the Free Software
 Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
-'''
+"""
 
 import unittest
 import os
@@ -25,52 +25,53 @@
 
 
 class CTest(unittest.TestCase):
-    '''
+    """
     Test cases for C language.
     :ivar testfile: Location of test file
-    '''
-    testfile = os.path.join(os.path.abspath(os.path.dirname(__file__)), "TestFiles/textcomment.c")
+    """
+
+    testfile = os.path.join(
+        os.path.abspath(os.path.dirname(__file__)), "TestFiles/textcomment.c"
+    )
 
     def test_output(self):
-        '''
+        """
         Check for the scan correctness.
-        '''
-        regex = r'''(?<![pst'"`]:)\/\/\s*(.*)'''
+        """
+        regex = r"""(?<![pst'"`]:)\/\/\s*(.*)"""
         syntax_start = "/*"
-        syntax_end = '*/'
+        syntax_end = "*/"
         comment_single = readSingleLine(self.testfile, regex)
-        comment_multiline = readMultiLineDiff(self.testfile, syntax_start,
-                                                syntax_end)
+        comment_multiline = readMultiLineDiff(self.testfile, syntax_start, syntax_end)
         comment_contSinglelines = contSingleLines(comment_single)
         self.assertTrue(comment_single)
         self.assertTrue(comment_multiline)
         self.assertTrue(comment_contSinglelines)
 
     def test_outputFormat(self):
-        '''
+        """
         Check for the output format correctness.
-        '''
-        regex = r'''(?<![pst]:)\/\/\s*(.*)'''
+        """
+        regex = r"""(?<![pst]:)\/\/\s*(.*)"""
         syntax_start = "/*"
         syntax_end = "*/"
         expected = c.cExtractor(self.testfile).get_dict()
         comment_single = readSingleLine(self.testfile, regex)
-        comment_multiline = readMultiLineDiff(self.testfile, syntax_start,
-                                              syntax_end)
+        comment_multiline = readMultiLineDiff(self.testfile, syntax_start, syntax_end)
         comment_contSinglelines = contSingleLines(comment_single)
         file = self.testfile.split("/")
         output = {
-        "metadata": {
-        "filename": file[-1],
-        "lang": "C",
-        "total_lines": comment_single[1],
-        "total_lines_of_comments": comment_single[3] + comment_multiline[3],
-        "blank_lines": comment_single[2],
-        "sloc": comment_single[1] - (comment_single[3] + comment_multiline[3] + comment_single[2])
-        },
-        "single_line_comment": [],
-        "cont_single_line_comment": [],
-        "multi_line_comment": []
+            "metadata": {
+                "filename": file[-1],
+                "lang": "C",
+                "total_lines": comment_single[1],
+                "total_lines_of_comments": comment_single[3] + comment_multiline[3],
+                "blank_lines": comment_single[2],
+                "sloc": comment_single[1] - (comment_single[3] + comment_multiline[3] + comment_single[2]),
+            },
+            "single_line_comment": [],
+            "cont_single_line_comment": [],
+            "multi_line_comment": [],
         }
 
         if comment_contSinglelines:
@@ -78,28 +79,36 @@ def test_outputFormat(self):
 
         if comment_single:
             for i in comment_single[0]:
-                output['single_line_comment'].append({"line_number":i[0], "comment": i[1]})
+                output["single_line_comment"].append(
+                    {"line_number": i[0], "comment": i[1]}
+                )
 
         if comment_contSinglelines:
             for idx, _ in enumerate(comment_contSinglelines[1]):
-                output['cont_single_line_comment'].append({
-                  "start_line": comment_contSinglelines[1][idx],
-                  "end_line": comment_contSinglelines[2][idx],
-                  "comment": comment_contSinglelines[3][idx]})
+                output["cont_single_line_comment"].append(
+                    {
+                        "start_line": comment_contSinglelines[1][idx],
+                        "end_line": comment_contSinglelines[2][idx],
+                        "comment": comment_contSinglelines[3][idx],
+                    }
+                )
 
         if comment_multiline:
             for idx, _ in enumerate(comment_multiline[0]):
-                output['multi_line_comment'].append({
-                  "start_line": comment_multiline[0][idx],
-                  "end_line": comment_multiline[1][idx],
-                  "comment": comment_multiline[2][idx]})
+                output["multi_line_comment"].append(
+                    {
+                        "start_line": comment_multiline[0][idx],
+                        "end_line": comment_multiline[1][idx],
+                        "comment": comment_multiline[2][idx],
+                    }
+                )
         self.assertEqual(output, expected)
 
     def test_Source(self):
-        '''
+        """
         Test the source code extraction.
         Call the source function and check if new file exists.
-        '''
+        """
         name = "source.txt"
         newfile = c.cSource(self.testfile, name)
 
diff --git a/nirjas/languages/tests/test_c_sharp.py b/nirjas/languages/tests/test_c_sharp.py
index 74ef7b5..1c7adb9 100644
--- a/nirjas/languages/tests/test_c_sharp.py
+++ b/nirjas/languages/tests/test_c_sharp.py
@@ -1,6 +1,6 @@
 #!/usr/bin/env python3
 # -*- coding: utf-8 -*-
-'''
+"""
 SPDX-License-Identifier: LGPL-2.1
 
 This library is free software; you can redistribute it and/or
@@ -16,7 +16,7 @@
 You should have received a copy of the GNU Lesser General Public
 License along with this library; if not, write to the Free Software
 Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
-'''
+"""
 
 import unittest
 import os
@@ -25,22 +25,24 @@
 
 
 class CSharpTest(unittest.TestCase):
-    '''
+    """
     Test cases for C Sharp language.
     :ivar testfile: Location of test file
-    '''
-    testfile = os.path.join(os.path.abspath(os.path.dirname(__file__)), "TestFiles/textcomment.cs")
+    """
+
+    testfile = os.path.join(
+        os.path.abspath(os.path.dirname(__file__)), "TestFiles/textcomment.cs"
+    )
 
     def test_output(self):
-        '''
+        """
         Check for the scan correctness.
-        '''
-        regex = r'''(?<![pst'"`]:)\/\/\s*(.*)'''
+        """
+        regex = r"""(?<![pst'"`]:)\/\/\s*(.*)"""
         syntax_start = "/*"
-        syntax_end = '*/'
+        syntax_end = "*/"
         comment_single = readSingleLine(self.testfile, regex)
-        comment_multiline = readMultiLineDiff(self.testfile, syntax_start,
-                                              syntax_end)
+        comment_multiline = readMultiLineDiff(self.testfile, syntax_start, syntax_end)
         comment_contSingleline = contSingleLines(comment_single)
 
         self.assertTrue(comment_single)
@@ -48,30 +50,29 @@ def test_output(self):
         self.assertTrue(comment_contSingleline)
 
     def test_outputFormat(self):
-        '''
+        """
         Check for the output format correctness.
-        '''
-        regex = r'''(?<![pst'"`]:)\/\/\s*(.*)'''
+        """
+        regex = r"""(?<![pst'"`]:)\/\/\s*(.*)"""
         syntax_start = "/*"
-        syntax_end = '*/'
+        syntax_end = "*/"
         expected = c_sharp.c_sharpExtractor(self.testfile).get_dict()
         comment_single = readSingleLine(self.testfile, regex)
-        comment_multiline = readMultiLineDiff(self.testfile, syntax_start,
-                                              syntax_end)
+        comment_multiline = readMultiLineDiff(self.testfile, syntax_start, syntax_end)
         comment_contSingleline = contSingleLines(comment_single)
         file = self.testfile.split("/")
         output = {
-        "metadata": {
-        "filename": file[-1],
-        "lang": "C#",
-        "total_lines": comment_single[1],
-        "total_lines_of_comments": comment_single[3] + comment_multiline[3],
-        "blank_lines": comment_single[2],
-        "sloc": comment_single[1] - (comment_single[3] + comment_multiline[3] + comment_single[2])
-        },
-        "single_line_comment": [],
-        "cont_single_line_comment": [],
-        "multi_line_comment": []
+            "metadata": {
+                "filename": file[-1],
+                "lang": "C#",
+                "total_lines": comment_single[1],
+                "total_lines_of_comments": comment_single[3] + comment_multiline[3],
+                "blank_lines": comment_single[2],
+                "sloc": comment_single[1] - (comment_single[3] + comment_multiline[3] + comment_single[2]),
+            },
+            "single_line_comment": [],
+            "cont_single_line_comment": [],
+            "multi_line_comment": [],
         }
 
         if comment_contSingleline:
@@ -79,29 +80,37 @@ def test_outputFormat(self):
 
         if comment_single:
             for i in comment_single[0]:
-                output['single_line_comment'].append({"line_number":i[0], "comment": i[1]})
+                output["single_line_comment"].append(
+                    {"line_number": i[0], "comment": i[1]}
+                )
 
         if comment_contSingleline:
             for idx, _ in enumerate(comment_contSingleline[1]):
-                output['cont_single_line_comment'].append({
-                  "start_line": comment_contSingleline[1][idx],
-                  "end_line": comment_contSingleline[2][idx],
-                  "comment": comment_contSingleline[3][idx]})
+                output["cont_single_line_comment"].append(
+                    {
+                        "start_line": comment_contSingleline[1][idx],
+                        "end_line": comment_contSingleline[2][idx],
+                        "comment": comment_contSingleline[3][idx],
+                    }
+                )
 
         if comment_multiline:
             for idx, _ in enumerate(comment_multiline[0]):
-                output['multi_line_comment'].append({
-                  "start_line": comment_multiline[0][idx],
-                  "end_line": comment_multiline[1][idx],
-                  "comment": comment_multiline[2][idx]})
+                output["multi_line_comment"].append(
+                    {
+                        "start_line": comment_multiline[0][idx],
+                        "end_line": comment_multiline[1][idx],
+                        "comment": comment_multiline[2][idx],
+                    }
+                )
 
         self.assertEqual(output, expected)
 
     def test_Source(self):
-        '''
+        """
         Test the source code extraction.
         Call the source function and check if new file exists.
-        '''
+        """
         name = "source.txt"
         newfile = c_sharp.c_sharpSource(self.testfile, name)
 
diff --git a/nirjas/languages/tests/test_cpp.py b/nirjas/languages/tests/test_cpp.py
index a0c938e..5ef021d 100644
--- a/nirjas/languages/tests/test_cpp.py
+++ b/nirjas/languages/tests/test_cpp.py
@@ -1,6 +1,6 @@
 #!/usr/bin/env python3
 # -*- coding: utf-8 -*-
-'''
+"""
 SPDX-License-Identifier: LGPL-2.1
 
 This library is free software; you can redistribute it and/or
@@ -16,7 +16,7 @@
 You should have received a copy of the GNU Lesser General Public
 License along with this library; if not, write to the Free Software
 Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
-'''
+"""
 
 import unittest
 import os
@@ -25,52 +25,53 @@
 
 
 class CPPTest(unittest.TestCase):
-    '''
+    """
     Test cases for C++ language.
     :ivar testfile: Location of test file
-    '''
-    testfile = os.path.join(os.path.abspath(os.path.dirname(__file__)), "TestFiles/textcomment.cpp")
+    """
+
+    testfile = os.path.join(
+        os.path.abspath(os.path.dirname(__file__)), "TestFiles/textcomment.cpp"
+    )
 
     def test_output(self):
-        '''
+        """
         Check for the scan correctness.
-        '''
-        regex = r'''(?<![pst'"`]:)\/\/\s*(.*)'''
+        """
+        regex = r"""(?<![pst'"`]:)\/\/\s*(.*)"""
         syntax_start = "/*"
-        syntax_end = '*/'
+        syntax_end = "*/"
         comment_single = readSingleLine(self.testfile, regex)
-        comment_multiline = readMultiLineDiff(self.testfile, syntax_start,
-                                                  syntax_end)
+        comment_multiline = readMultiLineDiff(self.testfile, syntax_start, syntax_end)
         comment_contSingleline = contSingleLines(comment_single)
         self.assertTrue(comment_single)
         self.assertTrue(comment_multiline)
         self.assertTrue(comment_contSingleline)
 
     def test_outputFormat(self):
-        '''
+        """
         Check for the output format correctness.
-        '''
-        regex = r'''(?<![pst'"`]:)\/\/\s*(.*)'''
+        """
+        regex = r"""(?<![pst'"`]:)\/\/\s*(.*)"""
         syntax_start = "/*"
-        syntax_end = '*/'
+        syntax_end = "*/"
         expected = cpp.cppExtractor(self.testfile).get_dict()
         comment_single = readSingleLine(self.testfile, regex)
-        comment_multiline = readMultiLineDiff(self.testfile, syntax_start,
-                                              syntax_end)
+        comment_multiline = readMultiLineDiff(self.testfile, syntax_start, syntax_end)
         comment_contSingleline = contSingleLines(comment_single)
         file = self.testfile.split("/")
         output = {
-        "metadata": {
-        "filename": file[-1],
-        "lang": "C++",
-        "total_lines": comment_single[1],
-        "total_lines_of_comments": comment_single[3] + comment_multiline[3],
-        "blank_lines": comment_single[2],
-        "sloc": comment_single[1] - (comment_single[3] + comment_multiline[3] + comment_single[2])
-        },
-        "single_line_comment": [],
-        "cont_single_line_comment": [],
-        "multi_line_comment": []
+            "metadata": {
+                "filename": file[-1],
+                "lang": "C++",
+                "total_lines": comment_single[1],
+                "total_lines_of_comments": comment_single[3] + comment_multiline[3],
+                "blank_lines": comment_single[2],
+                "sloc": comment_single[1] - (comment_single[3] + comment_multiline[3] + comment_single[2]),
+            },
+            "single_line_comment": [],
+            "cont_single_line_comment": [],
+            "multi_line_comment": [],
         }
 
         if comment_contSingleline:
@@ -78,29 +79,37 @@ def test_outputFormat(self):
 
         if comment_single:
             for i in comment_single[0]:
-                output['single_line_comment'].append({"line_number":i[0], "comment": i[1]})
+                output["single_line_comment"].append(
+                    {"line_number": i[0], "comment": i[1]}
+                )
 
         if comment_contSingleline:
             for idx, _ in enumerate(comment_contSingleline[1]):
-                output['cont_single_line_comment'].append({
-                  "start_line": comment_contSingleline[1][idx],
-                  "end_line": comment_contSingleline[2][idx],
-                  "comment": comment_contSingleline[3][idx]})
+                output["cont_single_line_comment"].append(
+                    {
+                        "start_line": comment_contSingleline[1][idx],
+                        "end_line": comment_contSingleline[2][idx],
+                        "comment": comment_contSingleline[3][idx],
+                    }
+                )
 
         if comment_multiline:
             for idx, _ in enumerate(comment_multiline[0]):
-                output['multi_line_comment'].append({
-                  "start_line": comment_multiline[0][idx],
-                  "end_line": comment_multiline[1][idx],
-                  "comment": comment_multiline[2][idx]})
+                output["multi_line_comment"].append(
+                    {
+                        "start_line": comment_multiline[0][idx],
+                        "end_line": comment_multiline[1][idx],
+                        "comment": comment_multiline[2][idx],
+                    }
+                )
 
         self.assertEqual(output, expected)
 
     def test_Source(self):
-        '''
+        """
         Test the source code extraction.
         Call the source function and check if new file exists.
-        '''
+        """
         name = "source.txt"
         newfile = cpp.cppSource(self.testfile, name)
 
diff --git a/nirjas/languages/tests/test_css.py b/nirjas/languages/tests/test_css.py
index 0ead41d..ab08775 100644
--- a/nirjas/languages/tests/test_css.py
+++ b/nirjas/languages/tests/test_css.py
@@ -1,6 +1,6 @@
 #!/usr/bin/env python3
 # -*- coding: utf-8 -*-
-'''
+"""
 SPDX-License-Identifier: LGPL-2.1
 
 This library is free software; you can redistribute it and/or
@@ -16,7 +16,7 @@
 You should have received a copy of the GNU Lesser General Public
 License along with this library; if not, write to the Free Software
 Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
-'''
+"""
 
 import unittest
 import os
@@ -25,60 +25,64 @@
 
 
 class CssTest(unittest.TestCase):
-    '''
+    """
     Test cases for CSS language.
     :ivar testfile: Location of test file
-    '''
-    testfile = os.path.join(os.path.abspath(os.path.dirname(__file__)), "TestFiles/textcomment.css")
+    """
+
+    testfile = os.path.join(
+        os.path.abspath(os.path.dirname(__file__)), "TestFiles/textcomment.css"
+    )
 
     def test_output(self):
-        '''
+        """
         Check for the scan correctness.
-        '''
+        """
         syntax_start = "/*"
-        syntax_end = '*/'
-        comment_multiline = readMultiLineDiff(self.testfile, syntax_start,
-                                              syntax_end)
+        syntax_end = "*/"
+        comment_multiline = readMultiLineDiff(self.testfile, syntax_start, syntax_end)
 
         self.assertTrue(comment_multiline)
 
     def test_outputFormat(self):
-        '''
+        """
         Check for the output format correctness.
-        '''
+        """
         syntax_start = "/*"
-        syntax_end = '*/'
+        syntax_end = "*/"
         expected = css.cssExtractor(self.testfile).get_dict()
-        comment_multiline = readMultiLineDiff(self.testfile, syntax_start,
-                                              syntax_end)
+        comment_multiline = readMultiLineDiff(self.testfile, syntax_start, syntax_end)
         file = self.testfile.split("/")
         output = {
-        "metadata": {
-        "filename": file[-1],
-        "lang": "CSS",
-        "total_lines": comment_multiline[4],
-        "total_lines_of_comments": comment_multiline[3],
-        "blank_lines": comment_multiline[5],
-        "sloc": comment_multiline[4] - (comment_multiline[3] + comment_multiline[5])
-        },
-        "single_line_comment": [],
-        "cont_single_line_comment": [],
-        "multi_line_comment": []
+            "metadata": {
+                "filename": file[-1],
+                "lang": "CSS",
+                "total_lines": comment_multiline[4],
+                "total_lines_of_comments": comment_multiline[3],
+                "blank_lines": comment_multiline[5],
+                "sloc": comment_multiline[4] - (comment_multiline[3] + comment_multiline[5]),
+            },
+            "single_line_comment": [],
+            "cont_single_line_comment": [],
+            "multi_line_comment": [],
         }
         if comment_multiline:
             for idx, _ in enumerate(comment_multiline[0]):
-                output['multi_line_comment'].append({
-                  "start_line": comment_multiline[0][idx],
-                  "end_line": comment_multiline[1][idx],
-                  "comment": comment_multiline[2][idx]})
+                output["multi_line_comment"].append(
+                    {
+                        "start_line": comment_multiline[0][idx],
+                        "end_line": comment_multiline[1][idx],
+                        "comment": comment_multiline[2][idx],
+                    }
+                )
 
         self.assertEqual(output, expected)
 
     def test_Source(self):
-        '''
+        """
         Test the source code extraction.
         Call the source function and check if new file exists.
-        '''
+        """
         name = "source.txt"
         newfile = css.cssSource(self.testfile, name)
 
diff --git a/nirjas/languages/tests/test_dart.py b/nirjas/languages/tests/test_dart.py
index 477c575..8a91692 100644
--- a/nirjas/languages/tests/test_dart.py
+++ b/nirjas/languages/tests/test_dart.py
@@ -1,6 +1,6 @@
 #!/usr/bin/env python3
 # -*- coding: utf-8 -*-
-'''
+"""
 Copyright (C) 2020  Aman Dwivedi (aman.dwivedi5@gmail.com)
 
 SPDX-License-Identifier: LGPL-2.1
@@ -18,7 +18,7 @@
 You should have received a copy of the GNU Lesser General Public
 License along with this library; if not, write to the Free Software
 Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
-'''
+"""
 
 import unittest
 import os
@@ -27,25 +27,26 @@
 
 
 class DartTest(unittest.TestCase):
-    '''
+    """
     Test cases for Dart language.
     :ivar testfile: Location of test file
-    '''
-    testfile = os.path.join(os.path.abspath(os.path.dirname(__file__)),
-                            "TestFiles/textcomment.dart")
+    """
+
+    testfile = os.path.join(
+        os.path.abspath(os.path.dirname(__file__)), "TestFiles/textcomment.dart"
+    )
 
     def test_output(self):
-        '''
+        """
         Check for the scan correctness.
-        '''
-        regex1 = r'''(?<!\/)\/\/(?!\/)\s*(.*)'''
-        regex2 = r'''\/\/\/\s*(.*)'''
+        """
+        regex1 = r"""(?<!\/)\/\/(?!\/)\s*(.*)"""
+        regex2 = r"""\/\/\/\s*(.*)"""
         syntax_start = "/*"
-        syntax_end = '*/'
+        syntax_end = "*/"
         comment_single_doubleSlash = readSingleLine(self.testfile, regex1)
         comment_single_tripleSlash = readSingleLine(self.testfile, regex2)
-        comment_multiline = readMultiLineDiff(self.testfile, syntax_start,
-                                                   syntax_end)
+        comment_multiline = readMultiLineDiff(self.testfile, syntax_start, syntax_end)
         comment_contSingleline1 = dart.contSingleLines(comment_single_doubleSlash)
         comment_contSingleline2 = dart.contSingleLines(comment_single_tripleSlash)
         self.assertTrue(comment_single_doubleSlash)
@@ -55,37 +56,34 @@ def test_output(self):
         self.assertTrue(comment_contSingleline2)
 
     def test_outputFormat(self):
-        '''
+        """
         Check for the output format correctness.
-        '''
-        regex1 = r'''(?<!\/)\/\/(?!\/)\s*(.*)'''
-        regex2 = r'''\/\/\/\s*(.*)'''
+        """
+        regex1 = r"""(?<!\/)\/\/(?!\/)\s*(.*)"""
+        regex2 = r"""\/\/\/\s*(.*)"""
         syntax_start = "/*"
-        syntax_end = '*/'
+        syntax_end = "*/"
         expected = dart.dartExtractor(self.testfile).get_dict()
         comment_single_doubleSlash = readSingleLine(self.testfile, regex1)
         comment_single_tripleSlash = readSingleLine(self.testfile, regex2)
-        comment_multiline = readMultiLineDiff(self.testfile, syntax_start,
-                                              syntax_end)
+        comment_multiline = readMultiLineDiff(self.testfile, syntax_start, syntax_end)
         comment_contSingleline1 = dart.contSingleLines(comment_single_doubleSlash)
         comment_contSingleline2 = dart.contSingleLines(comment_single_tripleSlash)
         file = self.testfile.split("/")
         output = {
-        "metadata": {
-        "filename": file[-1],
-        "lang": "Dart",
-        "total_lines": comment_single_doubleSlash[1],
-        "total_lines_of_comments": comment_single_doubleSlash[3] + \
-                                   comment_single_tripleSlash[3] + \
-                                   comment_multiline[3],
-        "blank_lines": comment_single_doubleSlash[2],
-        "sloc": comment_single_doubleSlash[1] - (
-          comment_single_doubleSlash[3] + comment_single_tripleSlash[3] + \
-          comment_multiline[3] + comment_single_doubleSlash[2])
-        },
-        "single_line_comment": [],
-        "cont_single_line_comment": [],
-        "multi_line_comment": []
+            "metadata": {
+                "filename": file[-1],
+                "lang": "Dart",
+                "total_lines": comment_single_doubleSlash[1],
+                "total_lines_of_comments": comment_single_doubleSlash[3] + comment_single_tripleSlash[3] + comment_multiline[3],
+                "blank_lines": comment_single_doubleSlash[2],
+                "sloc": comment_single_doubleSlash[1] - (
+                    comment_single_doubleSlash[3] + comment_single_tripleSlash[3] + comment_multiline[3] + comment_single_doubleSlash[2]
+                ),
+            },
+            "single_line_comment": [],
+            "cont_single_line_comment": [],
+            "multi_line_comment": [],
         }
 
         if comment_contSingleline1:
@@ -96,40 +94,53 @@ def test_outputFormat(self):
 
         if comment_single_doubleSlash:
             for i in comment_single_doubleSlash[0]:
-                output['single_line_comment'].append({"line_number":i[0], "comment": i[1]})
+                output["single_line_comment"].append(
+                    {"line_number": i[0], "comment": i[1]}
+                )
 
         if comment_single_tripleSlash:
             for i in comment_single_tripleSlash[0]:
-                output['single_line_comment'].append({"line_number":i[0], "comment": i[1]})
+                output["single_line_comment"].append(
+                    {"line_number": i[0], "comment": i[1]}
+                )
 
         if comment_contSingleline1:
             for idx, _ in enumerate(comment_contSingleline1[1]):
-                output['cont_single_line_comment'].append({
-                  "start_line": comment_contSingleline1[1][idx],
-                  "end_line": comment_contSingleline1[2][idx],
-                  "comment": comment_contSingleline1[3][idx]})
+                output["cont_single_line_comment"].append(
+                    {
+                        "start_line": comment_contSingleline1[1][idx],
+                        "end_line": comment_contSingleline1[2][idx],
+                        "comment": comment_contSingleline1[3][idx],
+                    }
+                )
 
         if comment_contSingleline2:
             for idx, _ in enumerate(comment_contSingleline2[1]):
-                output['cont_single_line_comment'].append({
-                  "start_line": comment_contSingleline2[1][idx],
-                  "end_line": comment_contSingleline2[2][idx],
-                  "comment": comment_contSingleline2[3][idx]})
+                output["cont_single_line_comment"].append(
+                    {
+                        "start_line": comment_contSingleline2[1][idx],
+                        "end_line": comment_contSingleline2[2][idx],
+                        "comment": comment_contSingleline2[3][idx],
+                    }
+                )
 
         if comment_multiline:
             for idx, _ in enumerate(comment_multiline[0]):
-                output['multi_line_comment'].append({
-                  "start_line": comment_multiline[0][idx],
-                  "end_line": comment_multiline[1][idx],
-                  "comment": comment_multiline[2][idx]})
+                output["multi_line_comment"].append(
+                    {
+                        "start_line": comment_multiline[0][idx],
+                        "end_line": comment_multiline[1][idx],
+                        "comment": comment_multiline[2][idx],
+                    }
+                )
 
         self.assertEqual(output, expected)
 
     def test_Source(self):
-        '''
+        """
         Test the source code extraction.
         Call the source function and check if new file exists.
-        '''
+        """
         name = "source.txt"
         newfile = dart.dartSource(self.testfile, name)
 
diff --git a/nirjas/languages/tests/test_go.py b/nirjas/languages/tests/test_go.py
index 89a854a..9be9dc4 100644
--- a/nirjas/languages/tests/test_go.py
+++ b/nirjas/languages/tests/test_go.py
@@ -1,6 +1,6 @@
 #!/usr/bin/env python3
 # -*- coding: utf-8 -*-
-'''
+"""
 SPDX-License-Identifier: LGPL-2.1
 
 This library is free software; you can redistribute it and/or
@@ -16,7 +16,7 @@
 You should have received a copy of the GNU Lesser General Public
 License along with this library; if not, write to the Free Software
 Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
-'''
+"""
 
 import unittest
 import os
@@ -25,52 +25,53 @@
 
 
 class GoTest(unittest.TestCase):
-    '''
+    """
     Test cases for Go language.
     :ivar testfile: Location of test file
-    '''
-    testfile = os.path.join(os.path.abspath(os.path.dirname(__file__)), "TestFiles/textcomment.cs")
+    """
+
+    testfile = os.path.join(
+        os.path.abspath(os.path.dirname(__file__)), "TestFiles/textcomment.cs"
+    )
 
     def test_output(self):
-        '''
+        """
         Check for the scan correctness.
-        '''
-        regex = r'''(?<![pst'"`]:)\/\/\s*(.*)'''
+        """
+        regex = r"""(?<![pst'"`]:)\/\/\s*(.*)"""
         syntax_start = "/*"
-        syntax_end = '*/'
+        syntax_end = "*/"
         comment_single = readSingleLine(self.testfile, regex)
-        comment_multiline = readMultiLineDiff(self.testfile, syntax_start,
-                                              syntax_end)
+        comment_multiline = readMultiLineDiff(self.testfile, syntax_start, syntax_end)
         comment_contSingleline = contSingleLines(comment_single)
         self.assertTrue(comment_single)
         self.assertTrue(comment_multiline)
         self.assertTrue(comment_contSingleline)
 
     def test_outputFormat(self):
-        '''
+        """
         Check for the output format correctness.
-        '''
-        regex = r'''(?<![pst'"`]:)\/\/\s*(.*)'''
+        """
+        regex = r"""(?<![pst'"`]:)\/\/\s*(.*)"""
         syntax_start = "/*"
-        syntax_end = '*/'
+        syntax_end = "*/"
         expected = go.goExtractor(self.testfile).get_dict()
         comment_single = readSingleLine(self.testfile, regex)
-        comment_multiline = readMultiLineDiff(self.testfile, syntax_start,
-                                              syntax_end)
+        comment_multiline = readMultiLineDiff(self.testfile, syntax_start, syntax_end)
         comment_contSingleline = contSingleLines(comment_single)
         file = self.testfile.split("/")
         output = {
-        "metadata": {
-        "filename": file[-1],
-        "lang": "Go",
-        "total_lines": comment_single[1],
-        "total_lines_of_comments": comment_single[3] + comment_multiline[3],
-        "blank_lines": comment_single[2],
-        "sloc": comment_single[1] - (comment_single[3] + comment_multiline[3] + comment_single[2])
-        },
-        "single_line_comment": [],
-        "cont_single_line_comment": [],
-        "multi_line_comment": []
+            "metadata": {
+                "filename": file[-1],
+                "lang": "Go",
+                "total_lines": comment_single[1],
+                "total_lines_of_comments": comment_single[3] + comment_multiline[3],
+                "blank_lines": comment_single[2],
+                "sloc": comment_single[1] - (comment_single[3] + comment_multiline[3] + comment_single[2]),
+            },
+            "single_line_comment": [],
+            "cont_single_line_comment": [],
+            "multi_line_comment": [],
         }
 
         if comment_contSingleline:
@@ -78,29 +79,37 @@ def test_outputFormat(self):
 
         if comment_single:
             for i in comment_single[0]:
-                output['single_line_comment'].append({"line_number":i[0], "comment": i[1]})
+                output["single_line_comment"].append(
+                    {"line_number": i[0], "comment": i[1]}
+                )
 
         if comment_contSingleline:
             for idx, _ in enumerate(comment_contSingleline[1]):
-                output['cont_single_line_comment'].append({
-                  "start_line": comment_contSingleline[1][idx],
-                  "end_line": comment_contSingleline[2][idx],
-                  "comment": comment_contSingleline[3][idx]})
+                output["cont_single_line_comment"].append(
+                    {
+                        "start_line": comment_contSingleline[1][idx],
+                        "end_line": comment_contSingleline[2][idx],
+                        "comment": comment_contSingleline[3][idx],
+                    }
+                )
 
         if comment_multiline:
             for idx, _ in enumerate(comment_multiline[0]):
-                output['multi_line_comment'].append({
-                  "start_line": comment_multiline[0][idx],
-                  "end_line": comment_multiline[1][idx],
-                  "comment": comment_multiline[2][idx]})
+                output["multi_line_comment"].append(
+                    {
+                        "start_line": comment_multiline[0][idx],
+                        "end_line": comment_multiline[1][idx],
+                        "comment": comment_multiline[2][idx],
+                    }
+                )
 
         self.assertEqual(output, expected)
 
     def test_Source(self):
-        '''
+        """
         Test the source code extraction.
         Call the source function and check if new file exists.
-        '''
+        """
         name = "source.txt"
         newfile = go.goSource(self.testfile, name)
 
diff --git a/nirjas/languages/tests/test_haskell.py b/nirjas/languages/tests/test_haskell.py
index 7286e05..83a8d94 100644
--- a/nirjas/languages/tests/test_haskell.py
+++ b/nirjas/languages/tests/test_haskell.py
@@ -1,6 +1,6 @@
 #!/usr/bin/env python3
 # -*- coding: utf-8 -*-
-'''
+"""
 SPDX-License-Identifier: LGPL-2.1
 
 This library is free software; you can redistribute it and/or
@@ -16,7 +16,7 @@
 You should have received a copy of the GNU Lesser General Public
 License along with this library; if not, write to the Free Software
 Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
-'''
+"""
 
 import unittest
 import os
@@ -25,52 +25,53 @@
 
 
 class HaskellTest(unittest.TestCase):
-    '''
+    """
     Test cases for Haskell language.
     :ivar testfile: Location of test file
-    '''
-    testfile = os.path.join(os.path.abspath(os.path.dirname(__file__)), "TestFiles/textcomment.hs")
+    """
+
+    testfile = os.path.join(
+        os.path.abspath(os.path.dirname(__file__)), "TestFiles/textcomment.hs"
+    )
 
     def test_output(self):
-        '''
+        """
         Check for the scan correctness.
-        '''
-        regex = r'''(?<!["'`])\-\-\s*(.*)'''
+        """
+        regex = r"""(?<!["'`])\-\-\s*(.*)"""
         syntax_start = "/*"
-        syntax_end = '*/'
+        syntax_end = "*/"
         comment_single = readSingleLine(self.testfile, regex)
-        comment_multiline = readMultiLineDiff(self.testfile, syntax_start,
-                                              syntax_end)
+        comment_multiline = readMultiLineDiff(self.testfile, syntax_start, syntax_end)
         comment_contSingleline = contSingleLines(comment_single)
         self.assertTrue(comment_single)
         self.assertTrue(comment_multiline)
         self.assertTrue(comment_contSingleline)
 
     def test_outputFormat(self):
-        '''
+        """
         Check for the output format correctness.
-        '''
-        regex = r'''(?<!["'`])\-\-\s*(.*)'''
+        """
+        regex = r"""(?<!["'`])\-\-\s*(.*)"""
         syntax_start = "{-"
         syntax_end = "-}"
         expected = haskell.haskellExtractor(self.testfile).get_dict()
         comment_single = readSingleLine(self.testfile, regex)
-        comment_multiline = readMultiLineDiff(self.testfile, syntax_start,
-                                              syntax_end)
+        comment_multiline = readMultiLineDiff(self.testfile, syntax_start, syntax_end)
         comment_contSingleline = contSingleLines(comment_single)
         file = self.testfile.split("/")
         output = {
-        "metadata": {
-        "filename": file[-1],
-        "lang": "Haskell",
-        "total_lines": comment_single[1],
-        "total_lines_of_comments": comment_single[3] + comment_multiline[3],
-        "blank_lines": comment_single[2],
-        "sloc": comment_single[1] - (comment_single[3] + comment_multiline[3] + comment_single[2])
-        },
-        "single_line_comment": [],
-        "cont_single_line_comment": [],
-        "multi_line_comment": []
+            "metadata": {
+                "filename": file[-1],
+                "lang": "Haskell",
+                "total_lines": comment_single[1],
+                "total_lines_of_comments": comment_single[3] + comment_multiline[3],
+                "blank_lines": comment_single[2],
+                "sloc": comment_single[1] - (comment_single[3] + comment_multiline[3] + comment_single[2]),
+            },
+            "single_line_comment": [],
+            "cont_single_line_comment": [],
+            "multi_line_comment": [],
         }
 
         if comment_contSingleline:
@@ -78,29 +79,37 @@ def test_outputFormat(self):
 
         if comment_single:
             for i in comment_single[0]:
-                output['single_line_comment'].append({"line_number":i[0], "comment": i[1]})
+                output["single_line_comment"].append(
+                    {"line_number": i[0], "comment": i[1]}
+                )
 
         if comment_contSingleline:
             for idx, _ in enumerate(comment_contSingleline[1]):
-                output['cont_single_line_comment'].append({
-                  "start_line": comment_contSingleline[1][idx],
-                  "end_line": comment_contSingleline[2][idx],
-                  "comment": comment_contSingleline[3][idx]})
+                output["cont_single_line_comment"].append(
+                    {
+                        "start_line": comment_contSingleline[1][idx],
+                        "end_line": comment_contSingleline[2][idx],
+                        "comment": comment_contSingleline[3][idx],
+                    }
+                )
 
         if comment_multiline:
             for idx, _ in enumerate(comment_multiline[0]):
-                output['multi_line_comment'].append({
-                  "start_line": comment_multiline[0][idx],
-                  "end_line": comment_multiline[1][idx],
-                  "comment": comment_multiline[2][idx]})
+                output["multi_line_comment"].append(
+                    {
+                        "start_line": comment_multiline[0][idx],
+                        "end_line": comment_multiline[1][idx],
+                        "comment": comment_multiline[2][idx],
+                    }
+                )
 
         self.assertEqual(output, expected)
 
     def test_Source(self):
-        '''
+        """
         Test the source code extraction.
         Call the source function and check if new file exists.
-        '''
+        """
         name = "source.txt"
         newfile = haskell.haskellSource(self.testfile, name)
 
diff --git a/nirjas/languages/tests/test_html.py b/nirjas/languages/tests/test_html.py
index e5e024c..671b280 100644
--- a/nirjas/languages/tests/test_html.py
+++ b/nirjas/languages/tests/test_html.py
@@ -1,6 +1,6 @@
 #!/usr/bin/env python3
 # -*- coding: utf-8 -*-
-'''
+"""
 SPDX-License-Identifier: LGPL-2.1
 
 This library is free software; you can redistribute it and/or
@@ -16,7 +16,7 @@
 You should have received a copy of the GNU Lesser General Public
 License along with this library; if not, write to the Free Software
 Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
-'''
+"""
 
 import unittest
 import os
@@ -25,78 +25,86 @@
 
 
 class HTMLTest(unittest.TestCase):
-    '''
+    """
     Test cases for HTML language.
     :ivar testfile: Location of test file
-    '''
-    testfile = os.path.join(os.path.abspath(os.path.dirname(__file__)),
-                            "TestFiles/textcomment.html")
+    """
+
+    testfile = os.path.join(
+        os.path.abspath(os.path.dirname(__file__)), "TestFiles/textcomment.html"
+    )
 
     def test_output(self):
-        '''
+        """
         Check for the scan correctness.
-        '''
+        """
         start_exclamation = "<!--"
         end_exclamation = "-->"
         syntax_start = "/*"
-        syntax_end = '*/'
-        comment_single = readMultiLineDiff(self.testfile, start_exclamation,
-                                           end_exclamation)
-        comment_multiline = readMultiLineDiff(self.testfile, syntax_start,
-                                              syntax_end)
+        syntax_end = "*/"
+        comment_single = readMultiLineDiff(
+            self.testfile, start_exclamation, end_exclamation
+        )
+        comment_multiline = readMultiLineDiff(self.testfile, syntax_start, syntax_end)
 
         self.assertTrue(comment_single)
         self.assertTrue(comment_multiline)
 
     def test_outputFormat(self):
-        '''
+        """
         Check for the output format correctness.
-        '''
+        """
         start_exclamation = "<!--"
         end_exclamation = "-->"
         syntax_start = "/*"
-        syntax_end = '*/'
+        syntax_end = "*/"
         expected = html.htmlExtractor(self.testfile).get_dict()
-        comment_single = readMultiLineDiff(self.testfile, start_exclamation,
-                                           end_exclamation)
-        comment_multiline = readMultiLineDiff(self.testfile, syntax_start,
-                                              syntax_end)
+        comment_single = readMultiLineDiff(
+            self.testfile, start_exclamation, end_exclamation
+        )
+        comment_multiline = readMultiLineDiff(self.testfile, syntax_start, syntax_end)
         file = self.testfile.split("/")
         output = {
-        "metadata": {
-        "filename": file[-1],
-        "lang": "HTML",
-        "total_lines": comment_single[4],
-        "total_lines_of_comments": comment_single[3] + comment_multiline[3],
-        "blank_lines": comment_single[5],
-        "sloc": comment_single[4] - (comment_single[3] + comment_multiline[3] + comment_single[5])
-        },
-        "single_line_comment": [],
-        "cont_single_line_comment": [],
-        "multi_line_comment": []
+            "metadata": {
+                "filename": file[-1],
+                "lang": "HTML",
+                "total_lines": comment_single[4],
+                "total_lines_of_comments": comment_single[3] + comment_multiline[3],
+                "blank_lines": comment_single[5],
+                "sloc": comment_single[4] - (comment_single[3] + comment_multiline[3] + comment_single[5]),
+            },
+            "single_line_comment": [],
+            "cont_single_line_comment": [],
+            "multi_line_comment": [],
         }
 
         if comment_single:
             for idx, _ in enumerate(comment_single[0]):
-                output['multi_line_comment'].append({
-                  "start_line": comment_single[0][idx],
-                  "end_line": comment_single[1][idx],
-                  "comment": comment_single[2][idx]})
+                output["multi_line_comment"].append(
+                    {
+                        "start_line": comment_single[0][idx],
+                        "end_line": comment_single[1][idx],
+                        "comment": comment_single[2][idx],
+                    }
+                )
 
         if comment_multiline:
             for idx, _ in enumerate(comment_multiline[0]):
-                output['multi_line_comment'].append({
-                  "start_line": comment_multiline[0][idx],
-                  "end_line": comment_multiline[1][idx],
-                  "comment": comment_multiline[2][idx]})
+                output["multi_line_comment"].append(
+                    {
+                        "start_line": comment_multiline[0][idx],
+                        "end_line": comment_multiline[1][idx],
+                        "comment": comment_multiline[2][idx],
+                    }
+                )
 
         self.assertEqual(output, expected)
 
     def test_Source(self):
-        '''
+        """
         Test the source code extraction.
         Call the source function and check if new file exists.
-        '''
+        """
         name = "source.txt"
         newfile = html.htmlSource(self.testfile, name)
 
diff --git a/nirjas/languages/tests/test_java.py b/nirjas/languages/tests/test_java.py
index 0e2d07f..d12dd53 100644
--- a/nirjas/languages/tests/test_java.py
+++ b/nirjas/languages/tests/test_java.py
@@ -1,6 +1,6 @@
 #!/usr/bin/env python3
 # -*- coding: utf-8 -*-
-'''
+"""
 SPDX-License-Identifier: LGPL-2.1
 
 This library is free software; you can redistribute it and/or
@@ -16,7 +16,7 @@
 You should have received a copy of the GNU Lesser General Public
 License along with this library; if not, write to the Free Software
 Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
-'''
+"""
 
 import unittest
 import os
@@ -25,53 +25,53 @@
 
 
 class JavaTest(unittest.TestCase):
-    '''
+    """
     Test cases for Java language.
     :ivar testfile: Location of test file
-    '''
-    testfile = os.path.join(os.path.abspath(os.path.dirname(__file__)),
-                            "TestFiles/textcomment.java")
+    """
+
+    testfile = os.path.join(
+        os.path.abspath(os.path.dirname(__file__)), "TestFiles/textcomment.java"
+    )
 
     def test_output(self):
-        '''
+        """
         Check for the scan correctness.
-        '''
-        regex = r'''(?<![pst'"`]:)\/\/\s*(.*)'''
+        """
+        regex = r"""(?<![pst'"`]:)\/\/\s*(.*)"""
         syntax_start = "/*"
-        syntax_end = '*/'
+        syntax_end = "*/"
         comment_single = readSingleLine(self.testfile, regex)
-        comment_multiline = readMultiLineDiff(self.testfile, syntax_start,
-                                              syntax_end)
+        comment_multiline = readMultiLineDiff(self.testfile, syntax_start, syntax_end)
         comment_contSingleline = contSingleLines(comment_single)
         self.assertTrue(comment_single)
         self.assertTrue(comment_multiline)
         self.assertTrue(comment_contSingleline)
 
     def test_outputFormat(self):
-        '''
+        """
         Check for the output format correctness.
-        '''
-        regex = r'''(?<![pst'"`]:)\/\/\s*(.*)'''
+        """
+        regex = r"""(?<![pst'"`]:)\/\/\s*(.*)"""
         syntax_start = "/*"
-        syntax_end = '*/'
+        syntax_end = "*/"
         expected = java.javaExtractor(self.testfile).get_dict()
         comment_single = readSingleLine(self.testfile, regex)
-        comment_multiline = readMultiLineDiff(self.testfile, syntax_start,
-                                              syntax_end)
+        comment_multiline = readMultiLineDiff(self.testfile, syntax_start, syntax_end)
         comment_contSingleline = contSingleLines(comment_single)
         file = self.testfile.split("/")
         output = {
-        "metadata": {
-        "filename": file[-1],
-        "lang": "Java",
-        "total_lines": comment_single[1],
-        "total_lines_of_comments": comment_single[3] + comment_multiline[3],
-        "blank_lines": comment_single[2],
-        "sloc": comment_single[1] - (comment_single[3] + comment_multiline[3] + comment_single[2])
-        },
-        "single_line_comment": [],
-        "cont_single_line_comment": [],
-        "multi_line_comment": []
+            "metadata": {
+                "filename": file[-1],
+                "lang": "Java",
+                "total_lines": comment_single[1],
+                "total_lines_of_comments": comment_single[3] + comment_multiline[3],
+                "blank_lines": comment_single[2],
+                "sloc": comment_single[1] - (comment_single[3] + comment_multiline[3] + comment_single[2]),
+            },
+            "single_line_comment": [],
+            "cont_single_line_comment": [],
+            "multi_line_comment": [],
         }
 
         if comment_contSingleline:
@@ -79,29 +79,37 @@ def test_outputFormat(self):
 
         if comment_single:
             for i in comment_single[0]:
-                output['single_line_comment'].append({"line_number": i[0], "comment": i[1]})
+                output["single_line_comment"].append(
+                    {"line_number": i[0], "comment": i[1]}
+                )
 
         if comment_contSingleline:
             for idx, _ in enumerate(comment_contSingleline[1]):
-                output['cont_single_line_comment'].append({
-                  "start_line": comment_contSingleline[1][idx],
-                  "end_line": comment_contSingleline[2][idx],
-                  "comment": comment_contSingleline[3][idx]})
+                output["cont_single_line_comment"].append(
+                    {
+                        "start_line": comment_contSingleline[1][idx],
+                        "end_line": comment_contSingleline[2][idx],
+                        "comment": comment_contSingleline[3][idx],
+                    }
+                )
 
         if comment_multiline:
             for idx, _ in enumerate(comment_multiline[0]):
-                output['multi_line_comment'].append({
-                  "start_line": comment_multiline[0][idx],
-                  "end_line": comment_multiline[1][idx],
-                  "comment": comment_multiline[2][idx]})
+                output["multi_line_comment"].append(
+                    {
+                        "start_line": comment_multiline[0][idx],
+                        "end_line": comment_multiline[1][idx],
+                        "comment": comment_multiline[2][idx],
+                    }
+                )
 
         self.assertEqual(output, expected)
 
     def test_Source(self):
-        '''
+        """
         Test the source code extraction.
         Call the source function and check if new file exists.
-        '''
+        """
         name = "source.txt"
         newfile = java.javaSource(self.testfile, name)
 
diff --git a/nirjas/languages/tests/test_javascript.py b/nirjas/languages/tests/test_javascript.py
index 1358e0b..ade1d57 100644
--- a/nirjas/languages/tests/test_javascript.py
+++ b/nirjas/languages/tests/test_javascript.py
@@ -1,6 +1,6 @@
 #!/usr/bin/env python3
 # -*- coding: utf-8 -*-
-'''
+"""
 SPDX-License-Identifier: LGPL-2.1
 
 This library is free software; you can redistribute it and/or
@@ -16,7 +16,7 @@
 You should have received a copy of the GNU Lesser General Public
 License along with this library; if not, write to the Free Software
 Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
-'''
+"""
 
 import unittest
 import os
@@ -25,53 +25,53 @@
 
 
 class JSTest(unittest.TestCase):
-    '''
+    """
     Test cases for JavaScript language.
     :ivar testfile: Location of test file
-    '''
-    testfile = os.path.join(os.path.abspath(os.path.dirname(__file__)),
-                            "TestFiles/textcomment.js")
+    """
+
+    testfile = os.path.join(
+        os.path.abspath(os.path.dirname(__file__)), "TestFiles/textcomment.js"
+    )
 
     def test_output(self):
-        '''
+        """
         Check for the scan correctness.
-        '''
-        regex = r'''(?<![pst'"`]:)\/\/\s*(.*)'''
+        """
+        regex = r"""(?<![pst'"`]:)\/\/\s*(.*)"""
         syntax_start = "/*"
-        syntax_end = '*/'
+        syntax_end = "*/"
         comment_single = readSingleLine(self.testfile, regex)
-        comment_multiline = readMultiLineDiff(self.testfile, syntax_start,
-                                              syntax_end)
+        comment_multiline = readMultiLineDiff(self.testfile, syntax_start, syntax_end)
         comment_contSingleline = contSingleLines(comment_single)
         self.assertTrue(comment_single)
         self.assertTrue(comment_multiline)
         self.assertTrue(comment_contSingleline)
 
     def test_outputFormat(self):
-        '''
+        """
         Check for the output format correctness.
-        '''
-        regex = r'''(?<![pst'"`]:)\/\/\s*(.*)'''
+        """
+        regex = r"""(?<![pst'"`]:)\/\/\s*(.*)"""
         syntax_start = "/*"
-        syntax_end = '*/'
+        syntax_end = "*/"
         expected = javascript.javascriptExtractor(self.testfile).get_dict()
         comment_single = readSingleLine(self.testfile, regex)
-        comment_multiline = readMultiLineDiff(self.testfile, syntax_start,
-                                              syntax_end)
+        comment_multiline = readMultiLineDiff(self.testfile, syntax_start, syntax_end)
         comment_contSingleline = contSingleLines(comment_single)
         file = self.testfile.split("/")
         output = {
-        "metadata": {
-        "filename": file[-1],
-        "lang": "JavaScript",
-        "total_lines": comment_single[1],
-        "total_lines_of_comments": comment_single[3] + comment_multiline[3],
-        "blank_lines": comment_single[2],
-        "sloc": comment_single[1] - (comment_single[3] + comment_multiline[3] + comment_single[2])
-        },
-        "single_line_comment": [],
-        "cont_single_line_comment": [],
-        "multi_line_comment": []
+            "metadata": {
+                "filename": file[-1],
+                "lang": "JavaScript",
+                "total_lines": comment_single[1],
+                "total_lines_of_comments": comment_single[3] + comment_multiline[3],
+                "blank_lines": comment_single[2],
+                "sloc": comment_single[1] - (comment_single[3] + comment_multiline[3] + comment_single[2]),
+            },
+            "single_line_comment": [],
+            "cont_single_line_comment": [],
+            "multi_line_comment": [],
         }
 
         if comment_contSingleline:
@@ -79,29 +79,37 @@ def test_outputFormat(self):
 
         if comment_single:
             for i in comment_single[0]:
-                output['single_line_comment'].append({"line_number":i[0], "comment": i[1]})
+                output["single_line_comment"].append(
+                    {"line_number": i[0], "comment": i[1]}
+                )
 
         if comment_contSingleline:
             for idx, _ in enumerate(comment_contSingleline[1]):
-                output['cont_single_line_comment'].append({
-                  "start_line": comment_contSingleline[1][idx],
-                  "end_line": comment_contSingleline[2][idx],
-                  "comment": comment_contSingleline[3][idx]})
+                output["cont_single_line_comment"].append(
+                    {
+                        "start_line": comment_contSingleline[1][idx],
+                        "end_line": comment_contSingleline[2][idx],
+                        "comment": comment_contSingleline[3][idx],
+                    }
+                )
 
         if comment_multiline:
             for idx, _ in enumerate(comment_multiline[0]):
-                output['multi_line_comment'].append({
-                  "start_line": comment_multiline[0][idx],
-                  "end_line": comment_multiline[1][idx],
-                  "comment": comment_multiline[2][idx]})
+                output["multi_line_comment"].append(
+                    {
+                        "start_line": comment_multiline[0][idx],
+                        "end_line": comment_multiline[1][idx],
+                        "comment": comment_multiline[2][idx],
+                    }
+                )
 
         self.assertEqual(output, expected)
 
     def test_Source(self):
-        '''
+        """
         Test the source code extraction.
         Call the source function and check if new file exists.
-        '''
+        """
         name = "source.txt"
         newfile = javascript.javascriptSource(self.testfile, name)
 
diff --git a/nirjas/languages/tests/test_kotlin.py b/nirjas/languages/tests/test_kotlin.py
index c28ceb8..5375152 100644
--- a/nirjas/languages/tests/test_kotlin.py
+++ b/nirjas/languages/tests/test_kotlin.py
@@ -1,6 +1,6 @@
 #!/usr/bin/env python3
 # -*- coding: utf-8 -*-
-'''
+"""
 SPDX-License-Identifier: LGPL-2.1
 
 This library is free software; you can redistribute it and/or
@@ -16,7 +16,7 @@
 You should have received a copy of the GNU Lesser General Public
 License along with this library; if not, write to the Free Software
 Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
-'''
+"""
 
 import unittest
 import os
@@ -25,52 +25,53 @@
 
 
 class KotlinTest(unittest.TestCase):
-    '''
+    """
     Test cases for Kotlin language.
     :ivar testfile: Location of test file
-    '''
-    testfile = os.path.join(os.path.abspath(os.path.dirname(__file__)), "TestFiles/textcomment.kts")
+    """
+
+    testfile = os.path.join(
+        os.path.abspath(os.path.dirname(__file__)), "TestFiles/textcomment.kts"
+    )
 
     def test_output(self):
-        '''
+        """
         Check for the scan correctness.
-        '''
-        regex = r'''(?<![pst'"`]:)\/\/\s*(.*)'''
+        """
+        regex = r"""(?<![pst'"`]:)\/\/\s*(.*)"""
         syntax_start = "/*"
-        syntax_end = '*/'
+        syntax_end = "*/"
         comment_single = readSingleLine(self.testfile, regex)
-        comment_multiline = readMultiLineDiff(self.testfile, syntax_start,
-                                              syntax_end)
+        comment_multiline = readMultiLineDiff(self.testfile, syntax_start, syntax_end)
         comment_contSingleline = contSingleLines(comment_single)
         self.assertTrue(comment_single)
         self.assertTrue(comment_multiline)
         self.assertTrue(comment_contSingleline)
 
     def test_outputFormat(self):
-        '''
+        """
         Check for the output format correctness.
-        '''
-        regex = r'''(?<![pst'"`]:)\/\/\s*(.*)'''
+        """
+        regex = r"""(?<![pst'"`]:)\/\/\s*(.*)"""
         syntax_start = "/*"
-        syntax_end = '*/'
+        syntax_end = "*/"
         expected = kotlin.kotlinExtractor(self.testfile).get_dict()
         comment_single = readSingleLine(self.testfile, regex)
-        comment_multiline = readMultiLineDiff(self.testfile, syntax_start,
-                                              syntax_end)
+        comment_multiline = readMultiLineDiff(self.testfile, syntax_start, syntax_end)
         comment_contSingleline = contSingleLines(comment_single)
         file = self.testfile.split("/")
         output = {
-        "metadata": {
-        "filename": file[-1],
-        "lang": "Kotlin",
-        "total_lines": comment_single[1],
-        "total_lines_of_comments": comment_single[3] + comment_multiline[3],
-        "blank_lines": comment_single[2],
-        "sloc": comment_single[1] - (comment_single[3] + comment_multiline[3] + comment_single[2])
-        },
-        "single_line_comment": [],
-        "cont_single_line_comment": [],
-        "multi_line_comment": []
+            "metadata": {
+                "filename": file[-1],
+                "lang": "Kotlin",
+                "total_lines": comment_single[1],
+                "total_lines_of_comments": comment_single[3] + comment_multiline[3],
+                "blank_lines": comment_single[2],
+                "sloc": comment_single[1] - (comment_single[3] + comment_multiline[3] + comment_single[2]),
+            },
+            "single_line_comment": [],
+            "cont_single_line_comment": [],
+            "multi_line_comment": [],
         }
 
         if comment_contSingleline:
@@ -78,29 +79,37 @@ def test_outputFormat(self):
 
         if comment_single:
             for i in comment_single[0]:
-                output['single_line_comment'].append({"line_number":i[0], "comment": i[1]})
+                output["single_line_comment"].append(
+                    {"line_number": i[0], "comment": i[1]}
+                )
 
         if comment_contSingleline:
             for idx, _ in enumerate(comment_contSingleline[1]):
-                output['cont_single_line_comment'].append({
-                  "start_line": comment_contSingleline[1][idx],
-                  "end_line": comment_contSingleline[2][idx],
-                  "comment": comment_contSingleline[3][idx]})
+                output["cont_single_line_comment"].append(
+                    {
+                        "start_line": comment_contSingleline[1][idx],
+                        "end_line": comment_contSingleline[2][idx],
+                        "comment": comment_contSingleline[3][idx],
+                    }
+                )
 
         if comment_multiline:
             for idx, _ in enumerate(comment_multiline[0]):
-                output['multi_line_comment'].append({
-                  "start_line": comment_multiline[0][idx],
-                  "end_line": comment_multiline[1][idx],
-                  "comment": comment_multiline[2][idx]})
+                output["multi_line_comment"].append(
+                    {
+                        "start_line": comment_multiline[0][idx],
+                        "end_line": comment_multiline[1][idx],
+                        "comment": comment_multiline[2][idx],
+                    }
+                )
 
         self.assertEqual(output, expected)
 
     def test_Source(self):
-        '''
+        """
         Test the source code extraction.
         Call the source function and check if new file exists.
-        '''
+        """
         name = "source.txt"
         newfile = kotlin.kotlinSource(self.testfile, name)
 
diff --git a/nirjas/languages/tests/test_matlab.py b/nirjas/languages/tests/test_matlab.py
index fe096e5..4f7fe8a 100644
--- a/nirjas/languages/tests/test_matlab.py
+++ b/nirjas/languages/tests/test_matlab.py
@@ -1,6 +1,6 @@
 #!/usr/bin/env python3
 # -*- coding: utf-8 -*-
-'''
+"""
 SPDX-License-Identifier: LGPL-2.1
 
 This library is free software; you can redistribute it and/or
@@ -16,7 +16,7 @@
 You should have received a copy of the GNU Lesser General Public
 License along with this library; if not, write to the Free Software
 Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
-'''
+"""
 
 import unittest
 import os
@@ -25,52 +25,53 @@
 
 
 class matlabTest(unittest.TestCase):
-    '''
+    """
     Test cases for Matlab language.
     :ivar testfile: Location of test file
-    '''
-    testfile = os.path.join(os.path.abspath(os.path.dirname(__file__)), "TestFiles/textcomment.m")
+    """
+
+    testfile = os.path.join(
+        os.path.abspath(os.path.dirname(__file__)), "TestFiles/textcomment.m"
+    )
 
     def test_output(self):
-        '''
+        """
         Check for the scan correctness.
-        '''
-        regex = r'''(?<!["'`])\%\s*(.*)'''
+        """
+        regex = r"""(?<!["'`])\%\s*(.*)"""
         syntax_start = "%{"
         syntax_end = "%}"
         comment_single = readSingleLine(self.testfile, regex)
-        comment_multiline = readMultiLineDiff(self.testfile, syntax_start,
-                                              syntax_end)
+        comment_multiline = readMultiLineDiff(self.testfile, syntax_start, syntax_end)
         comment_contSingleline = contSingleLines(comment_single)
         self.assertTrue(comment_single)
         self.assertTrue(comment_multiline)
         self.assertTrue(comment_contSingleline)
 
     def test_outputFormat(self):
-        '''
+        """
         Check for the output format correctness.
-        '''
-        regex = r'''(?<!["'`])\%\s*(.*)'''
+        """
+        regex = r"""(?<!["'`])\%\s*(.*)"""
         syntax_start = "%{"
         syntax_end = "%}"
         expected = matlab.matlabExtractor(self.testfile).get_dict()
         comment_single = readSingleLine(self.testfile, regex)
-        comment_multiline = readMultiLineDiff(self.testfile, syntax_start,
-                                              syntax_end)
+        comment_multiline = readMultiLineDiff(self.testfile, syntax_start, syntax_end)
         comment_contSingleline = contSingleLines(comment_single)
         file = self.testfile.split("/")
         output = {
-        "metadata": {
-        "filename": file[-1],
-        "lang": "MATLAB",
-        "total_lines": comment_single[1],
-        "total_lines_of_comments": comment_single[3] + comment_multiline[3],
-        "blank_lines": comment_single[2],
-        "sloc": comment_single[1] - (comment_single[3] + comment_multiline[3] + comment_single[2])
-        },
-        "single_line_comment": [],
-        "cont_single_line_comment": [],
-        "multi_line_comment": []
+            "metadata": {
+                "filename": file[-1],
+                "lang": "MATLAB",
+                "total_lines": comment_single[1],
+                "total_lines_of_comments": comment_single[3] + comment_multiline[3],
+                "blank_lines": comment_single[2],
+                "sloc": comment_single[1] - (comment_single[3] + comment_multiline[3] + comment_single[2]),
+            },
+            "single_line_comment": [],
+            "cont_single_line_comment": [],
+            "multi_line_comment": [],
         }
 
         if comment_contSingleline:
@@ -78,29 +79,37 @@ def test_outputFormat(self):
 
         if comment_single:
             for i in comment_single[0]:
-                output['single_line_comment'].append({"line_number":i[0], "comment": i[1]})
+                output["single_line_comment"].append(
+                    {"line_number": i[0], "comment": i[1]}
+                )
 
         if comment_contSingleline:
             for idx, _ in enumerate(comment_contSingleline[1]):
-                output['cont_single_line_comment'].append({
-                  "start_line": comment_contSingleline[1][idx],
-                  "end_line": comment_contSingleline[2][idx],
-                  "comment": comment_contSingleline[3][idx]})
+                output["cont_single_line_comment"].append(
+                    {
+                        "start_line": comment_contSingleline[1][idx],
+                        "end_line": comment_contSingleline[2][idx],
+                        "comment": comment_contSingleline[3][idx],
+                    }
+                )
 
         if comment_multiline:
             for idx, _ in enumerate(comment_multiline[0]):
-                output['multi_line_comment'].append({
-                  "start_line": comment_multiline[0][idx],
-                  "end_line": comment_multiline[1][idx],
-                  "comment": comment_multiline[2][idx]})
+                output["multi_line_comment"].append(
+                    {
+                        "start_line": comment_multiline[0][idx],
+                        "end_line": comment_multiline[1][idx],
+                        "comment": comment_multiline[2][idx],
+                    }
+                )
 
         self.assertEqual(output, expected)
 
     def test_Source(self):
-        '''
+        """
         Test the source code extraction.
         Call the source function and check if new file exists.
-        '''
+        """
         name = "source.txt"
         newfile = matlab.matlabSource(self.testfile, name)
 
diff --git a/nirjas/languages/tests/test_perl.py b/nirjas/languages/tests/test_perl.py
index 72d6354..ae309ab 100644
--- a/nirjas/languages/tests/test_perl.py
+++ b/nirjas/languages/tests/test_perl.py
@@ -1,6 +1,6 @@
 #!/usr/bin/env python3
 # -*- coding: utf-8 -*-
-'''
+"""
 SPDX-License-Identifier: LGPL-2.1
 
 This library is free software; you can redistribute it and/or
@@ -16,7 +16,7 @@
 You should have received a copy of the GNU Lesser General Public
 License along with this library; if not, write to the Free Software
 Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
-'''
+"""
 
 import unittest
 import os
@@ -25,52 +25,53 @@
 
 
 class perlTest(unittest.TestCase):
-    '''
+    """
     Test cases for Perl language.
     :ivar testfile: Location of test file
-    '''
-    testfile = os.path.join(os.path.abspath(os.path.dirname(__file__)), "TestFiles/textcomment.pl")
+    """
+
+    testfile = os.path.join(
+        os.path.abspath(os.path.dirname(__file__)), "TestFiles/textcomment.pl"
+    )
 
     def test_output(self):
-        '''
+        """
         Check for the scan correctness.
-        '''
-        regex = r'''(?<!["'`])#+\s*(.*)'''
+        """
+        regex = r"""(?<!["'`])#+\s*(.*)"""
         syntax_start = "=begin"
         syntax_end = "=cut"
         comment_single = readSingleLine(self.testfile, regex)
-        comment_multiline = readMultiLineDiff(self.testfile, syntax_start,
-                                              syntax_end)
+        comment_multiline = readMultiLineDiff(self.testfile, syntax_start, syntax_end)
         comment_contSingleline = contSingleLines(comment_single)
         self.assertTrue(comment_single)
         self.assertTrue(comment_multiline)
         self.assertTrue(comment_contSingleline)
 
     def test_outputFormat(self):
-        '''
+        """
         Check for the output format correctness.
-        '''
-        regex = r'''(?<!["'`])#+\s*(.*)'''
+        """
+        regex = r"""(?<!["'`])#+\s*(.*)"""
         syntax_start = "=begin"
         syntax_end = "=cut"
         expected = perl.perlExtractor(self.testfile).get_dict()
         comment_single = readSingleLine(self.testfile, regex)
-        comment_multiline = readMultiLineDiff(self.testfile, syntax_start,
-                                              syntax_end)
+        comment_multiline = readMultiLineDiff(self.testfile, syntax_start, syntax_end)
         comment_contSingleline = contSingleLines(comment_single)
         file = self.testfile.split("/")
         output = {
-        "metadata": {
-        "filename": file[-1],
-        "lang": "Perl",
-        "total_lines": comment_single[1],
-        "total_lines_of_comments": comment_single[3] + comment_multiline[3],
-        "blank_lines": comment_single[2],
-        "sloc": comment_single[1] - (comment_single[3] + comment_multiline[3] + comment_single[2])
-        },
-        "single_line_comment": [],
-        "cont_single_line_comment": [],
-        "multi_line_comment": []
+            "metadata": {
+                "filename": file[-1],
+                "lang": "Perl",
+                "total_lines": comment_single[1],
+                "total_lines_of_comments": comment_single[3] + comment_multiline[3],
+                "blank_lines": comment_single[2],
+                "sloc": comment_single[1] - (comment_single[3] + comment_multiline[3] + comment_single[2]),
+            },
+            "single_line_comment": [],
+            "cont_single_line_comment": [],
+            "multi_line_comment": [],
         }
 
         if comment_contSingleline:
@@ -78,29 +79,37 @@ def test_outputFormat(self):
 
         if comment_single:
             for i in comment_single[0]:
-                output['single_line_comment'].append({"line_number":i[0], "comment": i[1]})
+                output["single_line_comment"].append(
+                    {"line_number": i[0], "comment": i[1]}
+                )
 
         if comment_contSingleline:
             for idx, _ in enumerate(comment_contSingleline[1]):
-                output['cont_single_line_comment'].append({
-                  "start_line": comment_contSingleline[1][idx],
-                  "end_line": comment_contSingleline[2][idx],
-                  "comment": comment_contSingleline[3][idx]})
+                output["cont_single_line_comment"].append(
+                    {
+                        "start_line": comment_contSingleline[1][idx],
+                        "end_line": comment_contSingleline[2][idx],
+                        "comment": comment_contSingleline[3][idx],
+                    }
+                )
 
         if comment_multiline:
             for idx, _ in enumerate(comment_multiline[0]):
-                output['multi_line_comment'].append({
-                  "start_line": comment_multiline[0][idx],
-                  "end_line": comment_multiline[1][idx],
-                  "comment": comment_multiline[2][idx]})
+                output["multi_line_comment"].append(
+                    {
+                        "start_line": comment_multiline[0][idx],
+                        "end_line": comment_multiline[1][idx],
+                        "comment": comment_multiline[2][idx],
+                    }
+                )
 
         self.assertEqual(output, expected)
 
     def test_Source(self):
-        '''
+        """
         Test the source code extraction.
         Call the source function and check if new file exists.
-        '''
+        """
         name = "source.txt"
         newfile = perl.perlSource(self.testfile, name)
 
diff --git a/nirjas/languages/tests/test_php.py b/nirjas/languages/tests/test_php.py
index 7b6b2d7..0f5da5d 100644
--- a/nirjas/languages/tests/test_php.py
+++ b/nirjas/languages/tests/test_php.py
@@ -1,6 +1,6 @@
 #!/usr/bin/env python3
 # -*- coding: utf-8 -*-
-'''
+"""
 SPDX-License-Identifier: LGPL-2.1
 
 This library is free software; you can redistribute it and/or
@@ -16,7 +16,7 @@
 You should have received a copy of the GNU Lesser General Public
 License along with this library; if not, write to the Free Software
 Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
-'''
+"""
 
 import unittest
 import os
@@ -25,52 +25,53 @@
 
 
 class PHPTest(unittest.TestCase):
-    '''
+    """
     Test cases for PHP language.
     :ivar testfile: Location of test file
-    '''
-    testfile = os.path.join(os.path.abspath(os.path.dirname(__file__)), "TestFiles/textcomment.php")
+    """
+
+    testfile = os.path.join(
+        os.path.abspath(os.path.dirname(__file__)), "TestFiles/textcomment.php"
+    )
 
     def test_output(self):
-        '''
+        """
         Check for the scan correctness.
-        '''
-        regex = r'''(?<![pst'"`]:)\/\/\s*(.*)'''
+        """
+        regex = r"""(?<![pst'"`]:)\/\/\s*(.*)"""
         syntax_start = "/*"
-        syntax_end = '*/'
+        syntax_end = "*/"
         comment_single = readSingleLine(self.testfile, regex)
-        comment_multiline = readMultiLineDiff(self.testfile, syntax_start,
-                                              syntax_end)
+        comment_multiline = readMultiLineDiff(self.testfile, syntax_start, syntax_end)
         comment_contSingleline = contSingleLines(comment_single)
         self.assertTrue(comment_single)
         self.assertTrue(comment_multiline)
         self.assertTrue(comment_contSingleline)
 
     def test_outputFormat(self):
-        '''
+        """
         Check for the output format correctness.
-        '''
-        regex = r'''(?<![pst'"`]:)\/\/\s*(.*)'''
+        """
+        regex = r"""(?<![pst'"`]:)\/\/\s*(.*)"""
         syntax_start = "/*"
-        syntax_end = '*/'
+        syntax_end = "*/"
         expected = php.phpExtractor(self.testfile).get_dict()
         comment_single = readSingleLine(self.testfile, regex)
-        comment_multiline = readMultiLineDiff(self.testfile, syntax_start,
-                                              syntax_end)
+        comment_multiline = readMultiLineDiff(self.testfile, syntax_start, syntax_end)
         comment_contSingleline = contSingleLines(comment_single)
         file = self.testfile.split("/")
         output = {
-        "metadata": {
-        "filename": file[-1],
-        "lang": "PHP",
-        "total_lines": comment_single[1],
-        "total_lines_of_comments": comment_single[3] + comment_multiline[3],
-        "blank_lines": comment_single[2],
-        "sloc": comment_single[1] - (comment_single[3] + comment_multiline[3] + comment_single[2])
-        },
-        "single_line_comment": [],
-        "cont_single_line_comment": [],
-        "multi_line_comment": []
+            "metadata": {
+                "filename": file[-1],
+                "lang": "PHP",
+                "total_lines": comment_single[1],
+                "total_lines_of_comments": comment_single[3] + comment_multiline[3],
+                "blank_lines": comment_single[2],
+                "sloc": comment_single[1] - (comment_single[3] + comment_multiline[3] + comment_single[2]),
+            },
+            "single_line_comment": [],
+            "cont_single_line_comment": [],
+            "multi_line_comment": [],
         }
 
         if comment_contSingleline:
@@ -78,29 +79,37 @@ def test_outputFormat(self):
 
         if comment_single:
             for i in comment_single[0]:
-                output['single_line_comment'].append({"line_number": i[0], "comment": i[1]})
+                output["single_line_comment"].append(
+                    {"line_number": i[0], "comment": i[1]}
+                )
 
         if comment_contSingleline:
             for idx, _ in enumerate(comment_contSingleline[1]):
-                output['cont_single_line_comment'].append({
-                  "start_line": comment_contSingleline[1][idx],
-                  "end_line": comment_contSingleline[2][idx],
-                  "comment": comment_contSingleline[3][idx]})
+                output["cont_single_line_comment"].append(
+                    {
+                        "start_line": comment_contSingleline[1][idx],
+                        "end_line": comment_contSingleline[2][idx],
+                        "comment": comment_contSingleline[3][idx],
+                    }
+                )
 
         if comment_multiline:
             for idx, _ in enumerate(comment_multiline[0]):
-                output['multi_line_comment'].append({
-                  "start_line": comment_multiline[0][idx],
-                  "end_line": comment_multiline[1][idx],
-                  "comment": comment_multiline[2][idx]})
+                output["multi_line_comment"].append(
+                    {
+                        "start_line": comment_multiline[0][idx],
+                        "end_line": comment_multiline[1][idx],
+                        "comment": comment_multiline[2][idx],
+                    }
+                )
 
         self.assertEqual(output, expected)
 
     def test_Source(self):
-        '''
+        """
         Test the source code extraction.
         Call the source function and check if new file exists.
-        '''
+        """
         name = "source.txt"
         newfile = php.phpSource(self.testfile, name)
 
diff --git a/nirjas/languages/tests/test_python.py b/nirjas/languages/tests/test_python.py
index 35cb46f..2998afc 100644
--- a/nirjas/languages/tests/test_python.py
+++ b/nirjas/languages/tests/test_python.py
@@ -1,6 +1,6 @@
 #!/usr/bin/env python3
 # -*- coding: utf-8 -*-
-'''
+"""
 SPDX-License-Identifier: LGPL-2.1
 
 This library is free software; you can redistribute it and/or
@@ -16,7 +16,7 @@
 You should have received a copy of the GNU Lesser General Public
 License along with this library; if not, write to the Free Software
 Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
-'''
+"""
 
 import unittest
 import os
@@ -25,17 +25,20 @@
 
 
 class PythonTest(unittest.TestCase):
-    '''
+    """
     Test cases for Python language.
     :ivar testfile: Location of test file
-    '''
-    testfile = os.path.join(os.path.abspath(os.path.dirname(__file__)), "TestFiles/textcomment.py")
+    """
+
+    testfile = os.path.join(
+        os.path.abspath(os.path.dirname(__file__)), "TestFiles/textcomment.py"
+    )
 
     def test_output(self):
-        '''
+        """
         Check for the scan correctness.
-        '''
-        regex = r'''(?<!["'`])#+\s*(.*)'''
+        """
+        regex = r"""(?<!["'`])#+\s*(.*)"""
         syntax_single = "'''"
         syntax_double = '"""'
         comment_multi_single = readMultiLineSame(self.testfile, syntax_single)
@@ -48,10 +51,10 @@ def test_output(self):
         self.assertTrue(comment_contSingleline)
 
     def test_outputFormat(self):
-        '''
+        """
         Check for the output format correctness.
-        '''
-        regex = r'''(?<!["'`])#+\s*(.*)'''
+        """
+        regex = r"""(?<!["'`])#+\s*(.*)"""
         syntax_single = "'''"
         syntax_double = '"""'
         expected = python.pythonExtractor(self.testfile).get_dict()
@@ -61,22 +64,19 @@ def test_outputFormat(self):
         comment_contSingleline = contSingleLines(comment_single)
         file = self.testfile.split("/")
         output = {
-        "metadata": {
-        "filename": file[-1],
-        "lang": "Python",
-        "total_lines": comment_single[1],
-        "total_lines_of_comments": comment_single[3] + \
-                                   comment_multi_single[3] + \
-                                   comment_multi_double[3],
-        "blank_lines": comment_single[2],
-        "sloc": comment_single[1] - (comment_single[3] + \
-                                     comment_multi_single[3] + \
-                                     comment_multi_double[3] + \
-                                     comment_single[2])
-        },
-        "single_line_comment": [],
-        "cont_single_line_comment": [],
-        "multi_line_comment": []
+            "metadata": {
+                "filename": file[-1],
+                "lang": "Python",
+                "total_lines": comment_single[1],
+                "total_lines_of_comments": comment_single[3] + comment_multi_single[3] + comment_multi_double[3],
+                "blank_lines": comment_single[2],
+                "sloc": comment_single[1] - (
+                    comment_single[3] + comment_multi_single[3] + comment_multi_double[3] + comment_single[2]
+                ),
+            },
+            "single_line_comment": [],
+            "cont_single_line_comment": [],
+            "multi_line_comment": [],
         }
 
         if comment_contSingleline:
@@ -84,36 +84,47 @@ def test_outputFormat(self):
 
         if comment_single:
             for i in comment_single[0]:
-                output['single_line_comment'].append({"line_number":i[0], "comment": i[1]})
+                output["single_line_comment"].append(
+                    {"line_number": i[0], "comment": i[1]}
+                )
 
         if comment_contSingleline:
             for idx, _ in enumerate(comment_contSingleline[1]):
-                output['cont_single_line_comment'].append({
-                  "start_line": comment_contSingleline[1][idx],
-                  "end_line": comment_contSingleline[2][idx],
-                  "comment": comment_contSingleline[3][idx]})
+                output["cont_single_line_comment"].append(
+                    {
+                        "start_line": comment_contSingleline[1][idx],
+                        "end_line": comment_contSingleline[2][idx],
+                        "comment": comment_contSingleline[3][idx],
+                    }
+                )
 
         if comment_multi_single:
             for idx, _ in enumerate(comment_multi_single[0]):
-                output['multi_line_comment'].append({
-                  "start_line": comment_multi_single[0][idx],
-                  "end_line": comment_multi_single[1][idx],
-                  "comment": comment_multi_single[2][idx]})
+                output["multi_line_comment"].append(
+                    {
+                        "start_line": comment_multi_single[0][idx],
+                        "end_line": comment_multi_single[1][idx],
+                        "comment": comment_multi_single[2][idx],
+                    }
+                )
 
         if comment_multi_double:
             for idx, _ in enumerate(comment_multi_double[0]):
-                output['multi_line_comment'].append({
-                  "start_line": comment_multi_double[0][idx],
-                  "end_line": comment_multi_double[1][idx],
-                  "comment": comment_multi_double[2][idx]})
+                output["multi_line_comment"].append(
+                    {
+                        "start_line": comment_multi_double[0][idx],
+                        "end_line": comment_multi_double[1][idx],
+                        "comment": comment_multi_double[2][idx],
+                    }
+                )
 
         self.assertEqual(output, expected)
 
     def test_Source(self):
-        '''
+        """
         Test the source code extraction.
         Call the source function and check if new file exists.
-        '''
+        """
         name = "source.txt"
         newfile = python.pythonSource(self.testfile, name)
 
diff --git a/nirjas/languages/tests/test_r.py b/nirjas/languages/tests/test_r.py
index 05a0308..2909da8 100644
--- a/nirjas/languages/tests/test_r.py
+++ b/nirjas/languages/tests/test_r.py
@@ -1,6 +1,6 @@
 #!/usr/bin/env python3
 # -*- coding: utf-8 -*-
-'''
+"""
 SPDX-License-Identifier: LGPL-2.1
 
 This library is free software; you can redistribute it and/or
@@ -16,7 +16,7 @@
 You should have received a copy of the GNU Lesser General Public
 License along with this library; if not, write to the Free Software
 Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
-'''
+"""
 
 import unittest
 import os
@@ -25,51 +25,56 @@
 
 
 class rTest(unittest.TestCase):
-    '''
+    """
     Test cases for R language.
     :ivar testfile: Location of test file
-    '''
-    testfile = os.path.join(os.path.abspath(os.path.dirname(__file__)), "TestFiles/textcomment.R")
+    """
+
+    testfile = os.path.join(
+        os.path.abspath(os.path.dirname(__file__)), "TestFiles/textcomment.R"
+    )
 
     def test_output(self):
-        '''
+        """
         Check for the scan correctness.
-        '''
-        regex = r'''(?<!["'`])#+\s*(.*)'''
+        """
+        regex = r"""(?<!["'`])#+\s*(.*)"""
         comment_single = readSingleLine(self.testfile, regex)
         self.assertTrue(comment_single)
 
     def test_outputFormat(self):
-        '''
+        """
         Check for the output format correctness.
-        '''
-        regex = r'''(?<!["'`])#+\s*(.*)'''
+        """
+        regex = r"""(?<!["'`])#+\s*(.*)"""
         expected = r.rExtractor(self.testfile).get_dict()
         comment_single = readSingleLine(self.testfile, regex)
         file = self.testfile.split("/")
         output = {
-        "metadata": {
-        "filename": file[-1],
-        "lang": "R",
-        "total_lines": comment_single[1],
-        "total_lines_of_comments": comment_single[3],
-        "blank_lines": comment_single[2],
-        "sloc": comment_single[1] - (comment_single[3] + comment_single[2])
-        },
-        "single_line_comment": [],
-        "cont_single_line_comment": [],
-        "multi_line_comment": []
+            "metadata": {
+                "filename": file[-1],
+                "lang": "R",
+                "total_lines": comment_single[1],
+                "total_lines_of_comments": comment_single[3],
+                "blank_lines": comment_single[2],
+                "sloc": comment_single[1] - (comment_single[3] + comment_single[2]),
+            },
+            "single_line_comment": [],
+            "cont_single_line_comment": [],
+            "multi_line_comment": [],
         }
         if comment_single:
             for i in comment_single[0]:
-                output['single_line_comment'].append({"line_number":i[0], "comment": i[1]})
+                output["single_line_comment"].append(
+                    {"line_number": i[0], "comment": i[1]}
+                )
         self.assertEqual(output, expected)
 
     def test_Source(self):
-        '''
+        """
         Test the source code extraction.
         Call the source function and check if new file exists.
-        '''
+        """
         name = "source.txt"
         newfile = r.rSource(self.testfile, name)
 
diff --git a/nirjas/languages/tests/test_ruby.py b/nirjas/languages/tests/test_ruby.py
index 1d59b6d..8753c25 100644
--- a/nirjas/languages/tests/test_ruby.py
+++ b/nirjas/languages/tests/test_ruby.py
@@ -1,6 +1,6 @@
 #!/usr/bin/env python3
 # -*- coding: utf-8 -*-
-'''
+"""
 SPDX-License-Identifier: LGPL-2.1
 
 This library is free software; you can redistribute it and/or
@@ -16,7 +16,7 @@
 You should have received a copy of the GNU Lesser General Public
 License along with this library; if not, write to the Free Software
 Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
-'''
+"""
 
 import unittest
 import os
@@ -25,52 +25,53 @@
 
 
 class RubyTest(unittest.TestCase):
-    '''
+    """
     Test cases for Ruby language.
     :ivar testfile: Location of test file
-    '''
-    testfile = os.path.join(os.path.abspath(os.path.dirname(__file__)), "TestFiles/textcomment.rb")
+    """
+
+    testfile = os.path.join(
+        os.path.abspath(os.path.dirname(__file__)), "TestFiles/textcomment.rb"
+    )
 
     def test_output(self):
-        '''
+        """
         Check for the scan correctness.
-        '''
-        regex = r'''(?<!["'`])#+(?!\{)\s*(.*)'''
+        """
+        regex = r"""(?<!["'`])#+(?!\{)\s*(.*)"""
         syntax_start = "=begin"
         syntax_end = "=end"
         comment_single = readSingleLine(self.testfile, regex)
-        comment_multiline = readMultiLineDiff(self.testfile, syntax_start,
-                                              syntax_end)
+        comment_multiline = readMultiLineDiff(self.testfile, syntax_start, syntax_end)
         comment_contSingleline = contSingleLines(comment_single)
         self.assertTrue(comment_single)
         self.assertTrue(comment_multiline)
         self.assertTrue(comment_contSingleline)
 
     def test_outputFormat(self):
-        '''
+        """
         Check for the output format correctness.
-        '''
-        regex = r'''(?<!["'`])#+(?!\{)\s*(.*)'''
+        """
+        regex = r"""(?<!["'`])#+(?!\{)\s*(.*)"""
         syntax_start = "=begin"
         syntax_end = "=cut"
         expected = ruby.rubyExtractor(self.testfile).get_dict()
         comment_single = readSingleLine(self.testfile, regex)
-        comment_multiline = readMultiLineDiff(self.testfile, syntax_start,
-                                              syntax_end)
+        comment_multiline = readMultiLineDiff(self.testfile, syntax_start, syntax_end)
         comment_contSingleline = contSingleLines(comment_single)
         file = self.testfile.split("/")
         output = {
-        "metadata": {
-        "filename": file[-1],
-        "lang": "Ruby",
-        "total_lines": comment_single[1],
-        "total_lines_of_comments": comment_single[3] + comment_multiline[3],
-        "blank_lines": comment_single[2],
-        "sloc": comment_single[1] - (comment_single[3] + comment_multiline[3] + comment_single[2])
-        },
-        "single_line_comment": [],
-        "cont_single_line_comment": [],
-        "multi_line_comment": []
+            "metadata": {
+                "filename": file[-1],
+                "lang": "Ruby",
+                "total_lines": comment_single[1],
+                "total_lines_of_comments": comment_single[3] + comment_multiline[3],
+                "blank_lines": comment_single[2],
+                "sloc": comment_single[1] - (comment_single[3] + comment_multiline[3] + comment_single[2]),
+            },
+            "single_line_comment": [],
+            "cont_single_line_comment": [],
+            "multi_line_comment": [],
         }
 
         if comment_contSingleline:
@@ -78,29 +79,37 @@ def test_outputFormat(self):
 
         if comment_single:
             for i in comment_single[0]:
-                output['single_line_comment'].append({"line_number":i[0], "comment": i[1]})
+                output["single_line_comment"].append(
+                    {"line_number": i[0], "comment": i[1]}
+                )
 
         if comment_contSingleline:
             for idx, _ in enumerate(comment_contSingleline[1]):
-                output['cont_single_line_comment'].append({
-                  "start_line": comment_contSingleline[1][idx],
-                  "end_line": comment_contSingleline[2][idx],
-                  "comment": comment_contSingleline[3][idx]})
+                output["cont_single_line_comment"].append(
+                    {
+                        "start_line": comment_contSingleline[1][idx],
+                        "end_line": comment_contSingleline[2][idx],
+                        "comment": comment_contSingleline[3][idx],
+                    }
+                )
 
         if comment_multiline:
             for idx, _ in enumerate(comment_multiline[0]):
-                output['multi_line_comment'].append({
-                  "start_line": comment_multiline[0][idx],
-                  "end_line": comment_multiline[1][idx],
-                  "comment": comment_multiline[2][idx]})
+                output["multi_line_comment"].append(
+                    {
+                        "start_line": comment_multiline[0][idx],
+                        "end_line": comment_multiline[1][idx],
+                        "comment": comment_multiline[2][idx],
+                    }
+                )
 
         self.assertEqual(output, expected)
 
     def test_Source(self):
-        '''
+        """
         Test the source code extraction.
         Call the source function and check if new file exists.
-        '''
+        """
         name = "source.txt"
         newfile = ruby.rubySource(self.testfile, name)
 
diff --git a/nirjas/languages/tests/test_rust.py b/nirjas/languages/tests/test_rust.py
index c70463b..5ba13d7 100644
--- a/nirjas/languages/tests/test_rust.py
+++ b/nirjas/languages/tests/test_rust.py
@@ -1,6 +1,6 @@
 #!/usr/bin/env python3
 # -*- coding: utf-8 -*-
-'''
+"""
 SPDX-License-Identifier: LGPL-2.1
 
 This library is free software; you can redistribute it and/or
@@ -16,7 +16,7 @@
 You should have received a copy of the GNU Lesser General Public
 License along with this library; if not, write to the Free Software
 Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
-'''
+"""
 
 import unittest
 import os
@@ -25,52 +25,53 @@
 
 
 class RustTest(unittest.TestCase):
-    '''
+    """
     Test cases for Rust language.
     :ivar testfile: Location of test file
-    '''
-    testfile = os.path.join(os.path.abspath(os.path.dirname(__file__)), "TestFiles/textcomment.rs")
+    """
+
+    testfile = os.path.join(
+        os.path.abspath(os.path.dirname(__file__)), "TestFiles/textcomment.rs"
+    )
 
     def test_output(self):
-        '''
+        """
         Check for the scan correctness.
-        '''
-        regex = r'''(?<![pst'"`]:)\/\/\s*(.*)'''
+        """
+        regex = r"""(?<![pst'"`]:)\/\/\s*(.*)"""
         syntax_start = "/*"
-        syntax_end = '*/'
+        syntax_end = "*/"
         comment_single = readSingleLine(self.testfile, regex)
-        comment_multiline = readMultiLineDiff(self.testfile, syntax_start,
-                                              syntax_end)
+        comment_multiline = readMultiLineDiff(self.testfile, syntax_start, syntax_end)
         comment_contSingleline = contSingleLines(comment_single)
         self.assertTrue(comment_single)
         self.assertTrue(comment_multiline)
         self.assertTrue(comment_contSingleline)
 
     def test_outputFormat(self):
-        '''
+        """
         Check for the output format correctness.
-        '''
-        regex = r'''(?<![pst'"`]:)\/\/\s*(.*)'''
+        """
+        regex = r"""(?<![pst'"`]:)\/\/\s*(.*)"""
         syntax_start = "/*"
-        syntax_end = '*/'
+        syntax_end = "*/"
         expected = rust.rustExtractor(self.testfile).get_dict()
         comment_single = readSingleLine(self.testfile, regex)
-        comment_multiline = readMultiLineDiff(self.testfile, syntax_start,
-                                              syntax_end)
+        comment_multiline = readMultiLineDiff(self.testfile, syntax_start, syntax_end)
         comment_contSingleline = contSingleLines(comment_single)
         file = self.testfile.split("/")
         output = {
-        "metadata": {
-        "filename": file[-1],
-        "lang": "Rust",
-        "total_lines": comment_single[1],
-        "total_lines_of_comments": comment_single[3] + comment_multiline[3],
-        "blank_lines": comment_single[2],
-        "sloc": comment_single[1] - (comment_single[3] + comment_multiline[3] + comment_single[2])
-        },
-        "single_line_comment": [],
-        "cont_single_line_comment": [],
-        "multi_line_comment": []
+            "metadata": {
+                "filename": file[-1],
+                "lang": "Rust",
+                "total_lines": comment_single[1],
+                "total_lines_of_comments": comment_single[3] + comment_multiline[3],
+                "blank_lines": comment_single[2],
+                "sloc": comment_single[1] - (comment_single[3] + comment_multiline[3] + comment_single[2]),
+            },
+            "single_line_comment": [],
+            "cont_single_line_comment": [],
+            "multi_line_comment": [],
         }
 
         if comment_contSingleline:
@@ -78,29 +79,37 @@ def test_outputFormat(self):
 
         if comment_single:
             for i in comment_single[0]:
-                output['single_line_comment'].append({"line_number":i[0], "comment": i[1]})
+                output["single_line_comment"].append(
+                    {"line_number": i[0], "comment": i[1]}
+                )
 
         if comment_contSingleline:
             for idx, _ in enumerate(comment_contSingleline[1]):
-                output['cont_single_line_comment'].append({
-                  "start_line": comment_contSingleline[1][idx],
-                  "end_line": comment_contSingleline[2][idx],
-                  "comment": comment_contSingleline[3][idx]})
+                output["cont_single_line_comment"].append(
+                    {
+                        "start_line": comment_contSingleline[1][idx],
+                        "end_line": comment_contSingleline[2][idx],
+                        "comment": comment_contSingleline[3][idx],
+                    }
+                )
 
         if comment_multiline:
             for idx, _ in enumerate(comment_multiline[0]):
-                output['multi_line_comment'].append({
-                  "start_line": comment_multiline[0][idx],
-                  "end_line": comment_multiline[1][idx],
-                  "comment": comment_multiline[2][idx]})
+                output["multi_line_comment"].append(
+                    {
+                        "start_line": comment_multiline[0][idx],
+                        "end_line": comment_multiline[1][idx],
+                        "comment": comment_multiline[2][idx],
+                    }
+                )
 
         self.assertEqual(output, expected)
 
     def test_Source(self):
-        '''
+        """
         Test the source code extraction.
         Call the source function and check if new file exists.
-        '''
+        """
         name = "source.txt"
         newfile = rust.rustSource(self.testfile, name)
 
diff --git a/nirjas/languages/tests/test_scala.py b/nirjas/languages/tests/test_scala.py
index 3cd1eaf..1b8c762 100644
--- a/nirjas/languages/tests/test_scala.py
+++ b/nirjas/languages/tests/test_scala.py
@@ -1,6 +1,6 @@
 #!/usr/bin/env python3
 # -*- coding: utf-8 -*-
-'''
+"""
 SPDX-License-Identifier: LGPL-2.1
 
 This library is free software; you can redistribute it and/or
@@ -16,7 +16,7 @@
 You should have received a copy of the GNU Lesser General Public
 License along with this library; if not, write to the Free Software
 Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
-'''
+"""
 
 import unittest
 import os
@@ -25,53 +25,53 @@
 
 
 class ScalaTest(unittest.TestCase):
-    '''
+    """
     Test cases for Scala language.
     :ivar testfile: Location of test file
-    '''
-    testfile = os.path.join(os.path.abspath(os.path.dirname(__file__)),
-                            "TestFiles/textcomment.scala")
+    """
+
+    testfile = os.path.join(
+        os.path.abspath(os.path.dirname(__file__)), "TestFiles/textcomment.scala"
+    )
 
     def test_output(self):
-        '''
+        """
         Check for the scan correctness.
-        '''
-        regex = r'''(?<![pst'"`]:)\/\/\s*(.*)'''
+        """
+        regex = r"""(?<![pst'"`]:)\/\/\s*(.*)"""
         syntax_start = "/*"
-        syntax_end = '*/'
+        syntax_end = "*/"
         comment_single = readSingleLine(self.testfile, regex)
-        comment_multiline = readMultiLineDiff(self.testfile, syntax_start,
-                                              syntax_end)
+        comment_multiline = readMultiLineDiff(self.testfile, syntax_start, syntax_end)
         comment_contSingleline = contSingleLines(comment_single)
         self.assertTrue(comment_single)
         self.assertTrue(comment_multiline)
         self.assertTrue(comment_contSingleline)
 
     def test_outputFormat(self):
-        '''
+        """
         Check for the output format correctness.
-        '''
-        regex = r'''(?<![pst'"`]:)\/\/\s*(.*)'''
+        """
+        regex = r"""(?<![pst'"`]:)\/\/\s*(.*)"""
         syntax_start = "/*"
-        syntax_end = '*/'
+        syntax_end = "*/"
         expected = scala.scalaExtractor(self.testfile).get_dict()
         comment_single = readSingleLine(self.testfile, regex)
-        comment_multiline = readMultiLineDiff(self.testfile, syntax_start,
-                                              syntax_end)
+        comment_multiline = readMultiLineDiff(self.testfile, syntax_start, syntax_end)
         comment_contSingleline = contSingleLines(comment_single)
         file = self.testfile.split("/")
         output = {
-        "metadata": {
-        "filename": file[-1],
-        "lang": "Scala",
-        "total_lines": comment_single[1],
-        "total_lines_of_comments": comment_single[3] + comment_multiline[3],
-        "blank_lines": comment_single[2],
-        "sloc": comment_single[1] - (comment_single[3] + comment_multiline[3] + comment_single[2])
-        },
-        "single_line_comment": [],
-        "cont_single_line_comment": [],
-        "multi_line_comment": []
+            "metadata": {
+                "filename": file[-1],
+                "lang": "Scala",
+                "total_lines": comment_single[1],
+                "total_lines_of_comments": comment_single[3] + comment_multiline[3],
+                "blank_lines": comment_single[2],
+                "sloc": comment_single[1] - (comment_single[3] + comment_multiline[3] + comment_single[2]),
+            },
+            "single_line_comment": [],
+            "cont_single_line_comment": [],
+            "multi_line_comment": [],
         }
 
         if comment_contSingleline:
@@ -79,29 +79,37 @@ def test_outputFormat(self):
 
         if comment_single:
             for i in comment_single[0]:
-                output['single_line_comment'].append({"line_number":i[0], "comment": i[1]})
+                output["single_line_comment"].append(
+                    {"line_number": i[0], "comment": i[1]}
+                )
 
         if comment_contSingleline:
             for idx, _ in enumerate(comment_contSingleline[1]):
-                output['cont_single_line_comment'].append({
-                  "start_line": comment_contSingleline[1][idx],
-                  "end_line": comment_contSingleline[2][idx],
-                  "comment": comment_contSingleline[3][idx]})
+                output["cont_single_line_comment"].append(
+                    {
+                        "start_line": comment_contSingleline[1][idx],
+                        "end_line": comment_contSingleline[2][idx],
+                        "comment": comment_contSingleline[3][idx],
+                    }
+                )
 
         if comment_multiline:
             for idx, _ in enumerate(comment_multiline[0]):
-                output['multi_line_comment'].append({
-                  "start_line": comment_multiline[0][idx],
-                  "end_line": comment_multiline[1][idx],
-                  "comment": comment_multiline[2][idx]})
+                output["multi_line_comment"].append(
+                    {
+                        "start_line": comment_multiline[0][idx],
+                        "end_line": comment_multiline[1][idx],
+                        "comment": comment_multiline[2][idx],
+                    }
+                )
 
         self.assertEqual(output, expected)
 
     def test_Source(self):
-        '''
+        """
         Test the source code extraction.
         Call the source function and check if new file exists.
-        '''
+        """
         name = "source.txt"
         newfile = scala.scalaSource(self.testfile, name)
 
diff --git a/nirjas/languages/tests/test_scss.py b/nirjas/languages/tests/test_scss.py
index feb31a0..f5ca8ae 100644
--- a/nirjas/languages/tests/test_scss.py
+++ b/nirjas/languages/tests/test_scss.py
@@ -1,6 +1,6 @@
 #!/usr/bin/env python3
 # -*- coding: utf-8 -*-
-'''
+"""
 Copyright (C) 2020  Aman Dwivedi (aman.dwivedi5@gmail.com)
 
 SPDX-License-Identifier: LGPL-2.1
@@ -18,7 +18,7 @@
 You should have received a copy of the GNU Lesser General Public
 License along with this library; if not, write to the Free Software
 Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
-'''
+"""
 
 import unittest
 import os
@@ -27,25 +27,26 @@
 
 
 class ScssTest(unittest.TestCase):
-    '''
+    """
     Test cases for SCSS language.
     :ivar testfile: Location of test file
-    '''
-    testfile = os.path.join(os.path.abspath(os.path.dirname(__file__)),
-                            "TestFiles/textcomment.scss")
+    """
+
+    testfile = os.path.join(
+        os.path.abspath(os.path.dirname(__file__)), "TestFiles/textcomment.scss"
+    )
 
     def test_output(self):
-        '''
+        """
         Check for the scan correctness.
-        '''
-        regex1 = r'''(?<!\/)\/\/(?!\/)\s*(.*)'''
-        regex2 = r'''(?<!["'`])\/\/\/\s*(.*)'''
+        """
+        regex1 = r"""(?<!\/)\/\/(?!\/)\s*(.*)"""
+        regex2 = r"""(?<!["'`])\/\/\/\s*(.*)"""
         syntax_start = "/*"
-        syntax_end = '*/'
+        syntax_end = "*/"
         comment_single_doubleSlash = readSingleLine(self.testfile, regex1)
         comment_single_tripleSlash = readSingleLine(self.testfile, regex2)
-        comment_multiline = readMultiLineDiff(self.testfile, syntax_start,
-                                              syntax_end)
+        comment_multiline = readMultiLineDiff(self.testfile, syntax_start, syntax_end)
         comment_contSingleline1 = contSingleLines(comment_single_doubleSlash)
         comment_contSingleline2 = contSingleLines(comment_single_tripleSlash)
         self.assertTrue(comment_single_doubleSlash)
@@ -55,37 +56,34 @@ def test_output(self):
         self.assertTrue(comment_contSingleline2)
 
     def test_outputFormat(self):
-        '''
+        """
         Check for the output format correctness.
-        '''
-        regex1 = r'''(?<!\/)\/\/(?!\/)\s*(.*)'''
-        regex2 = r'''(?<!["'`])\/\/\/\s*(.*)'''
+        """
+        regex1 = r"""(?<!\/)\/\/(?!\/)\s*(.*)"""
+        regex2 = r"""(?<!["'`])\/\/\/\s*(.*)"""
         syntax_start = "/*"
-        syntax_end = '*/'
+        syntax_end = "*/"
         expected = scss.scssExtractor(self.testfile).get_dict()
         comment_single_doubleSlash = readSingleLine(self.testfile, regex1)
         comment_single_tripleSlash = readSingleLine(self.testfile, regex2)
-        comment_multiline = readMultiLineDiff(self.testfile, syntax_start,
-                                              syntax_end)
+        comment_multiline = readMultiLineDiff(self.testfile, syntax_start, syntax_end)
         comment_contSingleline1 = contSingleLines(comment_single_doubleSlash)
         comment_contSingleline2 = contSingleLines(comment_single_tripleSlash)
         file = self.testfile.split("/")
         output = {
-        "metadata": {
-        "filename": file[-1],
-        "lang": "Scss",
-        "total_lines": comment_single_doubleSlash[1],
-        "total_lines_of_comments": comment_single_doubleSlash[3] + \
-                                   comment_single_tripleSlash[3] + \
-                                   comment_multiline[3],
-        "blank_lines": comment_single_doubleSlash[2],
-        "sloc": comment_single_doubleSlash[1] - (
-          comment_single_doubleSlash[3] + comment_single_tripleSlash[3] + \
-          comment_multiline[3] + comment_single_doubleSlash[2])
-        },
-        "single_line_comment": [],
-        "cont_single_line_comment": [],
-        "multi_line_comment": []
+            "metadata": {
+                "filename": file[-1],
+                "lang": "Scss",
+                "total_lines": comment_single_doubleSlash[1],
+                "total_lines_of_comments": comment_single_doubleSlash[3] + comment_single_tripleSlash[3] + comment_multiline[3],
+                "blank_lines": comment_single_doubleSlash[2],
+                "sloc": comment_single_doubleSlash[1] - (
+                    comment_single_doubleSlash[3] + comment_single_tripleSlash[3] + comment_multiline[3] + comment_single_doubleSlash[2]
+                ),
+            },
+            "single_line_comment": [],
+            "cont_single_line_comment": [],
+            "multi_line_comment": [],
         }
 
         if comment_contSingleline1:
@@ -96,40 +94,53 @@ def test_outputFormat(self):
 
         if comment_single_doubleSlash:
             for i in comment_single_doubleSlash[0]:
-                output['single_line_comment'].append({"line_number":i[0], "comment": i[1]})
+                output["single_line_comment"].append(
+                    {"line_number": i[0], "comment": i[1]}
+                )
 
         if comment_single_tripleSlash:
             for i in comment_single_tripleSlash[0]:
-                output['single_line_comment'].append({"line_number":i[0], "comment": i[1]})
+                output["single_line_comment"].append(
+                    {"line_number": i[0], "comment": i[1]}
+                )
 
         if comment_contSingleline1:
             for idx, _ in enumerate(comment_contSingleline1[1]):
-                output['cont_single_line_comment'].append({
-                  "start_line": comment_contSingleline1[1][idx],
-                  "end_line": comment_contSingleline1[2][idx],
-                  "comment": comment_contSingleline1[3][idx]})
+                output["cont_single_line_comment"].append(
+                    {
+                        "start_line": comment_contSingleline1[1][idx],
+                        "end_line": comment_contSingleline1[2][idx],
+                        "comment": comment_contSingleline1[3][idx],
+                    }
+                )
 
         if comment_contSingleline2:
             for idx, _ in enumerate(comment_contSingleline2[1]):
-                output['cont_single_line_comment'].append({
-                  "start_line": comment_contSingleline2[1][idx],
-                  "end_line": comment_contSingleline2[2][idx],
-                  "comment": comment_contSingleline2[3][idx]})
+                output["cont_single_line_comment"].append(
+                    {
+                        "start_line": comment_contSingleline2[1][idx],
+                        "end_line": comment_contSingleline2[2][idx],
+                        "comment": comment_contSingleline2[3][idx],
+                    }
+                )
 
         if comment_multiline:
             for idx, _ in enumerate(comment_multiline[0]):
-                output['multi_line_comment'].append({
-                  "start_line": comment_multiline[0][idx],
-                  "end_line": comment_multiline[1][idx],
-                  "comment": comment_multiline[2][idx]})
+                output["multi_line_comment"].append(
+                    {
+                        "start_line": comment_multiline[0][idx],
+                        "end_line": comment_multiline[1][idx],
+                        "comment": comment_multiline[2][idx],
+                    }
+                )
 
         self.assertEqual(output, expected)
 
     def test_Source(self):
-        '''
+        """
         Test the source code extraction.
         Call the source function and check if new file exists.
-        '''
+        """
         name = "source.txt"
         newfile = scss.scssSource(self.testfile, name)
 
diff --git a/nirjas/languages/tests/test_shell.py b/nirjas/languages/tests/test_shell.py
index 865b192..49a7bd5 100644
--- a/nirjas/languages/tests/test_shell.py
+++ b/nirjas/languages/tests/test_shell.py
@@ -1,6 +1,6 @@
 #!/usr/bin/env python3
 # -*- coding: utf-8 -*-
-'''
+"""
 SPDX-License-Identifier: LGPL-2.1
 
 This library is free software; you can redistribute it and/or
@@ -16,7 +16,7 @@
 You should have received a copy of the GNU Lesser General Public
 License along with this library; if not, write to the Free Software
 Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
-'''
+"""
 
 import unittest
 import os
@@ -25,63 +25,71 @@
 
 
 class ShellTest(unittest.TestCase):
-    '''
+    """
     Test cases for Shell language.
     :ivar testfile: Location of test file
-    '''
-    testfile = os.path.join(os.path.abspath(os.path.dirname(__file__)), "TestFiles/textcomment.sh")
+    """
+
+    testfile = os.path.join(
+        os.path.abspath(os.path.dirname(__file__)), "TestFiles/textcomment.sh"
+    )
 
     def test_output(self):
-        '''
+        """
         Check for the scan correctness.
-        '''
-        regex = r'''(?<!["'`])#+\s*(.*)'''
+        """
+        regex = r"""(?<!["'`])#+\s*(.*)"""
         comment_single = readSingleLine(self.testfile, regex)
         self.assertTrue(comment_single)
 
     def test_outputFormat(self):
-        '''
+        """
         Check for the output format correctness.
-        '''
-        regex = r'''(?<!["'`])#+\s*(.*)'''
+        """
+        regex = r"""(?<!["'`])#+\s*(.*)"""
         expected = shell.shellExtractor(self.testfile).get_dict()
         comment_single = readSingleLine(self.testfile, regex)
         comment_contSingleline = contSingleLines(comment_single)
         file = self.testfile.split("/")
         output = {
-        "metadata": {
-        "filename": file[-1],
-        "lang": "Shell",
-        "total_lines": comment_single[1],
-        "total_lines_of_comments": comment_single[3],
-        "blank_lines": comment_single[2],
-        "sloc": comment_single[1] - (comment_single[3] + comment_single[2])
-        },
-        "single_line_comment": [],
-        "cont_single_line_comment": [],
-        "multi_line_comment": []
+            "metadata": {
+                "filename": file[-1],
+                "lang": "Shell",
+                "total_lines": comment_single[1],
+                "total_lines_of_comments": comment_single[3],
+                "blank_lines": comment_single[2],
+                "sloc": comment_single[1] - (comment_single[3] + comment_single[2]),
+            },
+            "single_line_comment": [],
+            "cont_single_line_comment": [],
+            "multi_line_comment": [],
         }
         if comment_contSingleline:
             comment_single = comment_contSingleline[0]
 
         if comment_single:
             for i in comment_single[0]:
-                output['single_line_comment'].append({"line_number":i[0], "comment": i[1]})
+                output["single_line_comment"].append(
+                    {"line_number": i[0], "comment": i[1]}
+                )
 
         if comment_contSingleline:
             for idx, _ in enumerate(comment_contSingleline[1]):
-                output['cont_single_line_comment'].append({
-                  "start_line": comment_contSingleline[1][idx],
-                  "end_line": comment_contSingleline[2][idx],
-                  "comment": comment_contSingleline[3][idx]})
+                output["cont_single_line_comment"].append(
+                    {
+                        "start_line": comment_contSingleline[1][idx],
+                        "end_line": comment_contSingleline[2][idx],
+                        "comment": comment_contSingleline[3][idx],
+                    }
+                )
 
         self.assertEqual(output, expected)
 
     def test_Source(self):
-        '''
+        """
         Test the source code extraction.
         Call the source function and check if new file exists.
-        '''
+        """
         name = "source.txt"
         newfile = shell.shellSource(self.testfile, name)
 
diff --git a/nirjas/languages/tests/test_swift.py b/nirjas/languages/tests/test_swift.py
index 7f961d3..9ace09b 100644
--- a/nirjas/languages/tests/test_swift.py
+++ b/nirjas/languages/tests/test_swift.py
@@ -1,6 +1,6 @@
 #!/usr/bin/env python3
 # -*- coding: utf-8 -*-
-'''
+"""
 SPDX-License-Identifier: LGPL-2.1
 
 This library is free software; you can redistribute it and/or
@@ -16,7 +16,7 @@
 You should have received a copy of the GNU Lesser General Public
 License along with this library; if not, write to the Free Software
 Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
-'''
+"""
 
 import unittest
 import os
@@ -25,53 +25,53 @@
 
 
 class SwiftTest(unittest.TestCase):
-    '''
+    """
     Test cases for Swift language.
     :ivar testfile: Location of test file
-    '''
-    testfile = os.path.join(os.path.abspath(os.path.dirname(__file__)),
-                            "TestFiles/textcomment.swift")
+    """
+
+    testfile = os.path.join(
+        os.path.abspath(os.path.dirname(__file__)), "TestFiles/textcomment.swift"
+    )
 
     def test_output(self):
-        '''
+        """
         Check for the scan correctness.
-        '''
-        regex = r'''(?<![pst'"`]:)\/\/\s*(.*)'''
+        """
+        regex = r"""(?<![pst'"`]:)\/\/\s*(.*)"""
         syntax_start = "/*"
-        syntax_end = '*/'
+        syntax_end = "*/"
         comment_single = readSingleLine(self.testfile, regex)
-        comment_multiline = readMultiLineDiff(self.testfile, syntax_start,
-                                              syntax_end)
+        comment_multiline = readMultiLineDiff(self.testfile, syntax_start, syntax_end)
         comment_contSingleline = contSingleLines(comment_single)
         self.assertTrue(comment_single)
         self.assertTrue(comment_multiline)
         self.assertTrue(comment_contSingleline)
 
     def test_outputFormat(self):
-        '''
+        """
         Check for the output format correctness.
-        '''
-        regex = r'''(?<![pst'"`]:)\/\/\s*(.*)'''
+        """
+        regex = r"""(?<![pst'"`]:)\/\/\s*(.*)"""
         syntax_start = "/*"
         syntax_end = "*/"
         expected = swift.swiftExtractor(self.testfile).get_dict()
         comment_single = readSingleLine(self.testfile, regex)
-        comment_multiline = readMultiLineDiff(self.testfile, syntax_start,
-                                              syntax_end)
+        comment_multiline = readMultiLineDiff(self.testfile, syntax_start, syntax_end)
         comment_contSingleline = contSingleLines(comment_single)
         file = self.testfile.split("/")
         output = {
-        "metadata": {
-        "filename": file[-1],
-        "lang": "Swift",
-        "total_lines": comment_single[1],
-        "total_lines_of_comments": comment_single[3] + comment_multiline[3],
-        "blank_lines": comment_single[2],
-        "sloc": comment_single[1] - (comment_single[3] + comment_multiline[3] + comment_single[2])
-        },
-        "single_line_comment": [],
-        "cont_single_line_comment": [],
-        "multi_line_comment": []
+            "metadata": {
+                "filename": file[-1],
+                "lang": "Swift",
+                "total_lines": comment_single[1],
+                "total_lines_of_comments": comment_single[3] + comment_multiline[3],
+                "blank_lines": comment_single[2],
+                "sloc": comment_single[1] - (comment_single[3] + comment_multiline[3] + comment_single[2]),
+            },
+            "single_line_comment": [],
+            "cont_single_line_comment": [],
+            "multi_line_comment": [],
         }
 
         if comment_contSingleline:
@@ -79,29 +79,37 @@ def test_outputFormat(self):
 
         if comment_single:
             for i in comment_single[0]:
-                output['single_line_comment'].append({"line_number":i[0], "comment": i[1]})
+                output["single_line_comment"].append(
+                    {"line_number": i[0], "comment": i[1]}
+                )
 
         if comment_contSingleline:
             for idx, _ in enumerate(comment_contSingleline[1]):
-                output['cont_single_line_comment'].append({
-                  "start_line": comment_contSingleline[1][idx],
-                  "end_line": comment_contSingleline[2][idx],
-                  "comment": comment_contSingleline[3][idx]})
+                output["cont_single_line_comment"].append(
+                    {
+                        "start_line": comment_contSingleline[1][idx],
+                        "end_line": comment_contSingleline[2][idx],
+                        "comment": comment_contSingleline[3][idx],
+                    }
+                )
 
         if comment_multiline:
             for idx, _ in enumerate(comment_multiline[0]):
-                output['multi_line_comment'].append({
-                  "start_line": comment_multiline[0][idx],
-                  "end_line": comment_multiline[1][idx],
-                  "comment": comment_multiline[2][idx]})
+                output["multi_line_comment"].append(
+                    {
+                        "start_line": comment_multiline[0][idx],
+                        "end_line": comment_multiline[1][idx],
+                        "comment": comment_multiline[2][idx],
+                    }
+                )
 
         self.assertEqual(output, expected)
 
     def test_Source(self):
-        '''
+        """
         Test the source code extraction.
         Call the source function and check if new file exists.
-        '''
+        """
         name = "source.txt"
         newfile = swift.swiftSource(self.testfile, name)
 
diff --git a/nirjas/languages/tests/test_typescript.py b/nirjas/languages/tests/test_typescript.py
index dcaf1b9..6b7444e 100644
--- a/nirjas/languages/tests/test_typescript.py
+++ b/nirjas/languages/tests/test_typescript.py
@@ -1,6 +1,6 @@
 #!/usr/bin/env python3
 # -*- coding: utf-8 -*-
-'''
+"""
 Copyright (C) 2020  Aman Dwivedi (aman.dwivedi5@gmail.com)
 
 SPDX-License-Identifier: LGPL-2.1
@@ -18,7 +18,7 @@
 You should have received a copy of the GNU Lesser General Public
 License along with this library; if not, write to the Free Software
 Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
-'''
+"""
 
 import unittest
 import os
@@ -27,79 +27,86 @@
 
 
 class TSTest(unittest.TestCase):
-    '''
+    """
     Test cases for TypeScript language.
     :ivar testfile: Location of test file
-    '''
-    testfile = os.path.join(os.path.abspath(os.path.dirname(__file__)), "TestFiles/textcomment.ts")
+    """
+
+    testfile = os.path.join(
+        os.path.abspath(os.path.dirname(__file__)), "TestFiles/textcomment.ts"
+    )
 
     def test_output(self):
-        '''
+        """
         Check for the scan correctness.
-        '''
-        regex = r'''(?<![pst'"`]:)\/\/\s*(.*)'''
+        """
+        regex = r"""(?<![pst'"`]:)\/\/\s*(.*)"""
         syntax_start = "/*"
-        syntax_end = '*/'
+        syntax_end = "*/"
         comment_single = readSingleLine(self.testfile, regex)
-        comment_multiline = readMultiLineDiff(self.testfile, syntax_start,
-                                              syntax_end)
+        comment_multiline = readMultiLineDiff(self.testfile, syntax_start, syntax_end)
         comment_contSingleline = contSingleLines(comment_single)
         self.assertTrue(comment_single)
         self.assertTrue(comment_multiline)
         self.assertTrue(comment_contSingleline)
 
     def test_outputFormat(self):
-        '''
+        """
         Check for the output format correctness.
-        '''
-        regex = r'''(?<![pst'"`]:)\/\/\s*(.*)'''
+        """
+        regex = r"""(?<![pst'"`]:)\/\/\s*(.*)"""
         syntax_start = "/*"
-        syntax_end = '*/'
+        syntax_end = "*/"
         expected = typescript.typescriptExtractor(self.testfile).get_dict()
         comment_single = readSingleLine(self.testfile, regex)
-        comment_multiline = readMultiLineDiff(self.testfile, syntax_start,
-                                              syntax_end)
+        comment_multiline = readMultiLineDiff(self.testfile, syntax_start, syntax_end)
         comment_contSingleline = typescript.contSingleLines(comment_single)
         file = self.testfile.split("/")
         output = {
-        "metadata": {
-        "filename": file[-1],
-        "lang": "TypeScript",
-        "total_lines": comment_single[1],
-        "total_lines_of_comments": comment_single[3] + comment_multiline[3],
-        "blank_lines": comment_single[2],
-        "sloc": comment_single[1] - (comment_single[3] + comment_multiline[3] + comment_single[2])
-        },
-        "single_line_comment": [],
-        "cont_single_line_comment": [],
-        "multi_line_comment": []
+            "metadata": {
+                "filename": file[-1],
+                "lang": "TypeScript",
+                "total_lines": comment_single[1],
+                "total_lines_of_comments": comment_single[3] + comment_multiline[3],
+                "blank_lines": comment_single[2],
+                "sloc": comment_single[1] - (comment_single[3] + comment_multiline[3] + comment_single[2]),
+            },
+            "single_line_comment": [],
+            "cont_single_line_comment": [],
+            "multi_line_comment": [],
         }
 
         if comment_contSingleline:
             comment_single = comment_contSingleline[0]
 
         for i in comment_single[0]:
-            output['single_line_comment'].append({"line_number":i[0], "comment": i[1]})
+            output["single_line_comment"].append({"line_number": i[0], "comment": i[1]})
 
         for idx, _ in enumerate(comment_contSingleline[1]):
-            output['cont_single_line_comment'].append({
-              "start_line": comment_contSingleline[1][idx],
-              "end_line": comment_contSingleline[2][idx],
-              "comment": comment_contSingleline[3][idx]})
+            output["cont_single_line_comment"].append(
+                {
+                    "start_line": comment_contSingleline[1][idx],
+                    "end_line": comment_contSingleline[2][idx],
+                    "comment": comment_contSingleline[3][idx],
+                }
+            )
 
         for idx, _ in enumerate(comment_multiline[0]):
-            output['multi_line_comment'].append({
-              "start_line": comment_multiline[0][idx],
-              "end_line": comment_multiline[1][idx],
-              "comment": comment_multiline[2][idx]})
+            output["multi_line_comment"].append(
+                {
+                    "start_line": comment_multiline[0][idx],
+                    "end_line": comment_multiline[1][idx],
+                    "comment": comment_multiline[2][idx],
+                }
+            )
 
         self.assertEqual(output, expected)
 
     def test_Source(self):
-        '''
+        """
         Test the source code extraction.
         Call the source function and check if new file exists.
-        '''
+        """
         name = "source.txt"
         newfile = typescript.typescriptSource(self.testfile, name)