diff-match: python3/code fixes for backport code

rhodecode/lib/diff_match_patch.py

@@ -1,6 +1,3 b''
-
-
-
 """Diff Match and Patch
 
 Copyright 2006 Google Inc.
@@ -25,7 +22,7 b' Computes the difference between two text'
 Applies the patch onto another text, allowing for errors.
 """
 
-__author__ = '[e-mail] (Neil Fraser)'
+__author__ = "[e-mail] (Neil Fraser)"
 
 import math
 import re
@@ -98,7 +95,7 b' class diff_match_patch:'
     if deadline is None:
       # Unlike in most languages, Python counts time in seconds.
       if self.Diff_Timeout <= 0:
-        deadline = sys.maxint
+                deadline = sys.maxsize
       else:
         deadline = time.time() + self.Diff_Timeout
 
@@ -121,7 +118,7 b' class diff_match_patch:'
     # Trim off common suffix (speedup).
     commonlength = self.diff_commonSuffix(text1, text2)
     if commonlength == 0:
-      commonsuffix = ''
+            commonsuffix = ""
     else:
       commonsuffix = text1[-commonlength:]
       text1 = text1[:-commonlength]
@@ -168,8 +165,11 b' class diff_match_patch:'
     i = longtext.find(shorttext)
     if i != -1:
       # Shorter text is inside the longer text (speedup).
-      diffs = [(self.DIFF_INSERT, longtext[:i]), (self.DIFF_EQUAL, shorttext),
-               (self.DIFF_INSERT, longtext[i + len(shorttext):])]
+            diffs = [
+                (self.DIFF_INSERT, longtext[:i]),
+                (self.DIFF_EQUAL, shorttext),
+                (self.DIFF_INSERT, longtext[i + len(shorttext) :]),
+            ]
       # Swap insertions for deletions if diff is reversed.
       if len(text1) > len(text2):
         diffs[0] = (self.DIFF_DELETE, diffs[0][1])
@@ -223,12 +223,12 b' class diff_match_patch:'
 
     # Rediff any replacement blocks, this time character-by-character.
     # Add a dummy entry at the end.
-    diffs.append((self.DIFF_EQUAL, ''))
+        diffs.append((self.DIFF_EQUAL, ""))
     pointer = 0
     count_delete = 0
     count_insert = 0
-    text_delete = ''
-    text_insert = ''
+        text_delete = ""
+        text_insert = ""
     while pointer < len(diffs):
       if diffs[pointer][0] == self.DIFF_INSERT:
         count_insert += 1
@@ -245,8 +245,8 b' class diff_match_patch:'
           pointer = pointer - count_delete - count_insert + len(a)
         count_insert = 0
         count_delete = 0
-        text_delete = ''
-        text_insert = ''
+                text_delete = ""
+                text_insert = ""
 
       pointer += 1
 
@@ -280,7 +280,7 b' class diff_match_patch:'
     delta = text1_length - text2_length
     # If the total number of characters is odd, then the front path will
     # collide with the reverse path.
-    front = (delta % 2 != 0)
+        front = delta % 2 != 0
     # Offsets for start and end of k loop.
     # Prevents mapping of space beyond the grid.
     k1start = 0
@@ -295,14 +295,14 b' class diff_match_patch:'
       # Walk the front path one step.
       for k1 in range(-d + k1start, d + 1 - k1end, 2):
         k1_offset = v_offset + k1
-        if k1 == -d or (k1 != d and
-            v1[k1_offset - 1] < v1[k1_offset + 1]):
+                if k1 == -d or (k1 != d and v1[k1_offset - 1] < v1[k1_offset + 1]):
           x1 = v1[k1_offset + 1]
         else:
           x1 = v1[k1_offset - 1] + 1
         y1 = x1 - k1
-        while (x1 < text1_length and y1 < text2_length and
-               text1[x1] == text2[y1]):
+                while (
+                    x1 < text1_length and y1 < text2_length and text1[x1] == text2[y1]
+                ):
           x1 += 1
           y1 += 1
         v1[k1_offset] = x1
@@ -324,14 +324,16 b' class diff_match_patch:'
       # Walk the reverse path one step.
       for k2 in range(-d + k2start, d + 1 - k2end, 2):
         k2_offset = v_offset + k2
-        if k2 == -d or (k2 != d and
-            v2[k2_offset - 1] < v2[k2_offset + 1]):
+                if k2 == -d or (k2 != d and v2[k2_offset - 1] < v2[k2_offset + 1]):
           x2 = v2[k2_offset + 1]
         else:
           x2 = v2[k2_offset - 1] + 1
         y2 = x2 - k2
-        while (x2 < text1_length and y2 < text2_length and
-               text1[-x2 - 1] == text2[-y2 - 1]):
+                while (
+                    x2 < text1_length
+                    and y2 < text2_length
+                    and text1[-x2 - 1] == text2[-y2 - 1]
+                ):
           x2 += 1
           y2 += 1
         v2[k2_offset] = x2
@@ -399,7 +401,7 b' class diff_match_patch:'
 
     # "\x00" is a valid character, but various debuggers don't like it.
     # So we'll insert a junk entry to avoid generating a null character.
-    lineArray.append('')
+        lineArray.append("")
 
     def diff_linesToCharsMunge(text):
       """Split a text into an array of strings.  Reduce the texts to a string
@@ -419,18 +421,18 b' class diff_match_patch:'
       lineStart = 0
       lineEnd = -1
       while lineEnd < len(text) - 1:
-        lineEnd = text.find('\n', lineStart)
+                lineEnd = text.find("\n", lineStart)
         if lineEnd == -1:
           lineEnd = len(text) - 1
         line = text[lineStart:lineEnd + 1]
         lineStart = lineEnd + 1
 
         if line in lineHash:
-          chars.append(unichr(lineHash[line]))
+                    chars.append(chr(lineHash[line]))
         else:
           lineArray.append(line)
           lineHash[line] = len(lineArray) - 1
-          chars.append(unichr(len(lineArray) - 1))
+                    chars.append(chr(len(lineArray) - 1))
       return "".join(chars)
 
     chars1 = diff_linesToCharsMunge(text1)
@@ -499,8 +501,10 b' class diff_match_patch:'
     pointermid = pointermax
     pointerend = 0
     while pointermin < pointermid:
-      if (text1[-pointermid:len(text1) - pointerend] ==
-          text2[-pointermid:len(text2) - pointerend]):
+            if (
+                text1[-pointermid : len(text1) - pointerend]
+                == text2[-pointermid : len(text2) - pointerend]
+            ):
         pointermin = pointermid
         pointerend = pointermin
       else:
@@ -590,14 +594,16 b' class diff_match_patch:'
         common middle.  Or None if there was no match.
       """
       seed = longtext[i:i + len(longtext) // 4]
-      best_common = ''
+            best_common = ""
       j = shorttext.find(seed)
       while j != -1:
         prefixLength = self.diff_commonPrefix(longtext[i:], shorttext[j:])
         suffixLength = self.diff_commonSuffix(longtext[:i], shorttext[:j])
         if len(best_common) < suffixLength + prefixLength:
-          best_common = (shorttext[j - suffixLength:j] +
-              shorttext[j:j + prefixLength])
+                    best_common = (
+                        shorttext[j - suffixLength : j]
+                        + shorttext[j : j + prefixLength]
+                    )
           best_longtext_a = longtext[:i - suffixLength]
           best_longtext_b = longtext[i + prefixLength:]
           best_shorttext_a = shorttext[:j - suffixLength]
@@ -605,8 +611,13 b' class diff_match_patch:'
         j = shorttext.find(seed, j + 1)
 
       if len(best_common) * 2 >= len(longtext):
-        return (best_longtext_a, best_longtext_b,
-                best_shorttext_a, best_shorttext_b, best_common)
+                return (
+                    best_longtext_a,
+                    best_longtext_b,
+                    best_shorttext_a,
+                    best_shorttext_b,
+                    best_common,
+                )
       else:
         return None
 
@@ -662,14 +673,22 b' class diff_match_patch:'
           length_deletions2 += len(diffs[pointer][1])
         # Eliminate an equality that is smaller or equal to the edits on both
         # sides of it.
-        if (lastequality and (len(lastequality) <=
-            max(length_insertions1, length_deletions1)) and
-            (len(lastequality) <= max(length_insertions2, length_deletions2))):
+                if (
+                    lastequality
+                    and (
+                        len(lastequality) <= max(length_insertions1, length_deletions1)
+                    )
+                    and (
+                        len(lastequality) <= max(length_insertions2, length_deletions2)
+                    )
+                ):
           # Duplicate record.
           diffs.insert(equalities[-1], (self.DIFF_DELETE, lastequality))
           # Change second copy to insert.
-          diffs[equalities[-1] + 1] = (self.DIFF_INSERT,
-              diffs[equalities[-1] + 1][1])
+                    diffs[equalities[-1] + 1] = (
+                        self.DIFF_INSERT,
+                        diffs[equalities[-1] + 1][1],
+                    )
           # Throw away the equality we just deleted.
           equalities.pop()
           # Throw away the previous equality (it needs to be reevaluated).
@@ -699,32 +718,50 b' class diff_match_patch:'
     # Only extract an overlap if it is as big as the edit ahead or behind it.
     pointer = 1
     while pointer < len(diffs):
-      if (diffs[pointer - 1][0] == self.DIFF_DELETE and
-          diffs[pointer][0] == self.DIFF_INSERT):
+            if (
+                diffs[pointer - 1][0] == self.DIFF_DELETE
+                and diffs[pointer][0] == self.DIFF_INSERT
+            ):
         deletion = diffs[pointer - 1][1]
         insertion = diffs[pointer][1]
         overlap_length1 = self.diff_commonOverlap(deletion, insertion)
         overlap_length2 = self.diff_commonOverlap(insertion, deletion)
         if overlap_length1 >= overlap_length2:
-          if (overlap_length1 >= len(deletion) / 2.0 or
-              overlap_length1 >= len(insertion) / 2.0):
+                    if (
+                        overlap_length1 >= len(deletion) / 2.0
+                        or overlap_length1 >= len(insertion) / 2.0
+                    ):
             # Overlap found.  Insert an equality and trim the surrounding edits.
-            diffs.insert(pointer, (self.DIFF_EQUAL,
-                                   insertion[:overlap_length1]))
-            diffs[pointer - 1] = (self.DIFF_DELETE,
-                                  deletion[:len(deletion) - overlap_length1])
-            diffs[pointer + 1] = (self.DIFF_INSERT,
-                                  insertion[overlap_length1:])
+                        diffs.insert(
+                            pointer, (self.DIFF_EQUAL, insertion[:overlap_length1])
+                        )
+                        diffs[pointer - 1] = (
+                            self.DIFF_DELETE,
+                            deletion[: len(deletion) - overlap_length1],
+                        )
+                        diffs[pointer + 1] = (
+                            self.DIFF_INSERT,
+                            insertion[overlap_length1:],
+                        )
             pointer += 1
         else:
-          if (overlap_length2 >= len(deletion) / 2.0 or
-              overlap_length2 >= len(insertion) / 2.0):
+                    if (
+                        overlap_length2 >= len(deletion) / 2.0
+                        or overlap_length2 >= len(insertion) / 2.0
+                    ):
             # Reverse overlap found.
             # Insert an equality and swap and trim the surrounding edits.
-            diffs.insert(pointer, (self.DIFF_EQUAL, deletion[:overlap_length2]))
-            diffs[pointer - 1] = (self.DIFF_INSERT,
-                                  insertion[:len(insertion) - overlap_length2])
-            diffs[pointer + 1] = (self.DIFF_DELETE, deletion[overlap_length2:])
+                        diffs.insert(
+                            pointer, (self.DIFF_EQUAL, deletion[:overlap_length2])
+                        )
+                        diffs[pointer - 1] = (
+                            self.DIFF_INSERT,
+                            insertion[: len(insertion) - overlap_length2],
+                        )
+                        diffs[pointer + 1] = (
+                            self.DIFF_DELETE,
+                            deletion[overlap_length2:],
+                        )
             pointer += 1
         pointer += 1
       pointer += 1
@@ -791,8 +828,10 b' class diff_match_patch:'
     pointer = 1
     # Intentionally ignore the first and last element (don't need checking).
     while pointer < len(diffs) - 1:
-      if (diffs[pointer - 1][0] == self.DIFF_EQUAL and
-          diffs[pointer + 1][0] == self.DIFF_EQUAL):
+            if (
+                diffs[pointer - 1][0] == self.DIFF_EQUAL
+                and diffs[pointer + 1][0] == self.DIFF_EQUAL
+            ):
         # This is a single edit surrounded by equalities.
         equality1 = diffs[pointer - 1][1]
         edit = diffs[pointer][1]
@@ -810,14 +849,16 b' class diff_match_patch:'
         bestEquality1 = equality1
         bestEdit = edit
         bestEquality2 = equality2
-        bestScore = (diff_cleanupSemanticScore(equality1, edit) +
-            diff_cleanupSemanticScore(edit, equality2))
+                bestScore = diff_cleanupSemanticScore(
+                    equality1, edit
+                ) + diff_cleanupSemanticScore(edit, equality2)
         while edit and equality2 and edit[0] == equality2[0]:
           equality1 += edit[0]
           edit = edit[1:] + equality2[0]
           equality2 = equality2[1:]
-          score = (diff_cleanupSemanticScore(equality1, edit) +
-              diff_cleanupSemanticScore(edit, equality2))
+                    score = diff_cleanupSemanticScore(
+                        equality1, edit
+                    ) + diff_cleanupSemanticScore(edit, equality2)
           # The >= encourages trailing rather than leading whitespace on edits.
           if score >= bestScore:
             bestScore = score
@@ -841,8 +882,8 b' class diff_match_patch:'
       pointer += 1
 
   # Define some regex patterns for matching boundaries.
-  BLANKLINEEND = re.compile(r"\n\r?\n$");
-  BLANKLINESTART = re.compile(r"^\r?\n\r?\n");
+    BLANKLINEEND = re.compile(r"\n\r?\n$")
+    BLANKLINESTART = re.compile(r"^\r?\n\r?\n")
 
   def diff_cleanupEfficiency(self, diffs):
     """Reduce the number of edits by eliminating operationally trivial
@@ -861,8 +902,9 b' class diff_match_patch:'
     post_del = False  # Is there a deletion operation after the last equality.
     while pointer < len(diffs):
       if diffs[pointer][0] == self.DIFF_EQUAL:  # Equality found.
-        if (len(diffs[pointer][1]) < self.Diff_EditCost and
-            (post_ins or post_del)):
+                if len(diffs[pointer][1]) < self.Diff_EditCost and (
+                    post_ins or post_del
+                ):
           # Candidate found.
           equalities.append(pointer)
           pre_ins = post_ins
@@ -887,14 +929,20 b' class diff_match_patch:'
         # <ins>A</del>X<ins>C</ins><del>D</del>
         # <ins>A</ins><del>B</del>X<del>C</del>
 
-        if lastequality and ((pre_ins and pre_del and post_ins and post_del) or
-                             ((len(lastequality) < self.Diff_EditCost / 2) and
-                              (pre_ins + pre_del + post_ins + post_del) == 3)):
+                if lastequality and (
+                    (pre_ins and pre_del and post_ins and post_del)
+                    or (
+                        (len(lastequality) < self.Diff_EditCost / 2)
+                        and (pre_ins + pre_del + post_ins + post_del) == 3
+                    )
+                ):
           # Duplicate record.
           diffs.insert(equalities[-1], (self.DIFF_DELETE, lastequality))
           # Change second copy to insert.
-          diffs[equalities[-1] + 1] = (self.DIFF_INSERT,
-              diffs[equalities[-1] + 1][1])
+                    diffs[equalities[-1] + 1] = (
+                        self.DIFF_INSERT,
+                        diffs[equalities[-1] + 1][1],
+                    )
           equalities.pop()  # Throw away the equality we just deleted.
           lastequality = None
           if pre_ins and pre_del:
@@ -922,12 +970,12 b' class diff_match_patch:'
     Args:
       diffs: Array of diff tuples.
     """
-    diffs.append((self.DIFF_EQUAL, ''))  # Add a dummy entry at the end.
+        diffs.append((self.DIFF_EQUAL, ""))  # Add a dummy entry at the end.
     pointer = 0
     count_delete = 0
     count_insert = 0
-    text_delete = ''
-    text_insert = ''
+        text_delete = ""
+        text_insert = ""
     while pointer < len(diffs):
       if diffs[pointer][0] == self.DIFF_INSERT:
         count_insert += 1
@@ -946,31 +994,40 b' class diff_match_patch:'
             if commonlength != 0:
               x = pointer - count_delete - count_insert - 1
               if x >= 0 and diffs[x][0] == self.DIFF_EQUAL:
-                diffs[x] = (diffs[x][0], diffs[x][1] +
-                            text_insert[:commonlength])
+                                diffs[x] = (
+                                    diffs[x][0],
+                                    diffs[x][1] + text_insert[:commonlength],
+                                )
               else:
-                diffs.insert(0, (self.DIFF_EQUAL, text_insert[:commonlength]))
+                                diffs.insert(
+                                    0, (self.DIFF_EQUAL, text_insert[:commonlength])
+                                )
                 pointer += 1
               text_insert = text_insert[commonlength:]
               text_delete = text_delete[commonlength:]
             # Factor out any common suffixies.
             commonlength = self.diff_commonSuffix(text_insert, text_delete)
             if commonlength != 0:
-              diffs[pointer] = (diffs[pointer][0], text_insert[-commonlength:] +
-                  diffs[pointer][1])
+                            diffs[pointer] = (
+                                diffs[pointer][0],
+                                text_insert[-commonlength:] + diffs[pointer][1],
+                            )
               text_insert = text_insert[:-commonlength]
               text_delete = text_delete[:-commonlength]
           # Delete the offending records and add the merged ones.
           if count_delete == 0:
             diffs[pointer - count_insert : pointer] = [
-                (self.DIFF_INSERT, text_insert)]
+                            (self.DIFF_INSERT, text_insert)
+                        ]
           elif count_insert == 0:
             diffs[pointer - count_delete : pointer] = [
-                (self.DIFF_DELETE, text_delete)]
+                            (self.DIFF_DELETE, text_delete)
+                        ]
           else:
             diffs[pointer - count_delete - count_insert : pointer] = [
                 (self.DIFF_DELETE, text_delete),
-                (self.DIFF_INSERT, text_insert)]
+                            (self.DIFF_INSERT, text_insert),
+                        ]
           pointer = pointer - count_delete - count_insert + 1
           if count_delete != 0:
             pointer += 1
@@ -978,18 +1035,20 b' class diff_match_patch:'
             pointer += 1
         elif pointer != 0 and diffs[pointer - 1][0] == self.DIFF_EQUAL:
           # Merge this equality with the previous one.
-          diffs[pointer - 1] = (diffs[pointer - 1][0],
-                                diffs[pointer - 1][1] + diffs[pointer][1])
+                    diffs[pointer - 1] = (
+                        diffs[pointer - 1][0],
+                        diffs[pointer - 1][1] + diffs[pointer][1],
+                    )
           del diffs[pointer]
         else:
           pointer += 1
 
         count_insert = 0
         count_delete = 0
-        text_delete = ''
-        text_insert = ''
+                text_delete = ""
+                text_insert = ""
 
-    if diffs[-1][1] == '':
+        if diffs[-1][1] == "":
       diffs.pop()  # Remove the dummy entry at the end.
 
     # Second pass: look for single edits surrounded on both sides by equalities
@@ -999,25 +1058,35 b' class diff_match_patch:'
     pointer = 1
     # Intentionally ignore the first and last element (don't need checking).
     while pointer < len(diffs) - 1:
-      if (diffs[pointer - 1][0] == self.DIFF_EQUAL and
-          diffs[pointer + 1][0] == self.DIFF_EQUAL):
+            if (
+                diffs[pointer - 1][0] == self.DIFF_EQUAL
+                and diffs[pointer + 1][0] == self.DIFF_EQUAL
+            ):
         # This is a single edit surrounded by equalities.
         if diffs[pointer][1].endswith(diffs[pointer - 1][1]):
           # Shift the edit over the previous equality.
-          diffs[pointer] = (diffs[pointer][0],
-              diffs[pointer - 1][1] +
-              diffs[pointer][1][:-len(diffs[pointer - 1][1])])
-          diffs[pointer + 1] = (diffs[pointer + 1][0],
-                                diffs[pointer - 1][1] + diffs[pointer + 1][1])
+                    diffs[pointer] = (
+                        diffs[pointer][0],
+                        diffs[pointer - 1][1]
+                        + diffs[pointer][1][: -len(diffs[pointer - 1][1])],
+                    )
+                    diffs[pointer + 1] = (
+                        diffs[pointer + 1][0],
+                        diffs[pointer - 1][1] + diffs[pointer + 1][1],
+                    )
           del diffs[pointer - 1]
           changes = True
         elif diffs[pointer][1].startswith(diffs[pointer + 1][1]):
           # Shift the edit over the next equality.
-          diffs[pointer - 1] = (diffs[pointer - 1][0],
-                                diffs[pointer - 1][1] + diffs[pointer + 1][1])
-          diffs[pointer] = (diffs[pointer][0],
-              diffs[pointer][1][len(diffs[pointer + 1][1]):] +
-              diffs[pointer + 1][1])
+                    diffs[pointer - 1] = (
+                        diffs[pointer - 1][0],
+                        diffs[pointer - 1][1] + diffs[pointer + 1][1],
+                    )
+                    diffs[pointer] = (
+                        diffs[pointer][0],
+                        diffs[pointer][1][len(diffs[pointer + 1][1]) :]
+                        + diffs[pointer + 1][1],
+                    )
           del diffs[pointer + 1]
           changes = True
       pointer += 1
@@ -1068,13 +1137,17 b' class diff_match_patch:'
       HTML representation.
     """
     html = []
-    for (op, data) in diffs:
-      text = (data.replace("&", "&amp;").replace("<", "&lt;")
-                 .replace(">", "&gt;").replace("\n", "&para;<br>"))
+        for op, data in diffs:
+            text = (
+                data.replace("&", "&amp;")
+                .replace("<", "&lt;")
+                .replace(">", "&gt;")
+                .replace("\n", "&para;<br>")
+            )
       if op == self.DIFF_INSERT:
-        html.append("<ins style=\"background:#e6ffe6;\">%s</ins>" % text)
+                html.append('<ins style="background:#e6ffe6;">%s</ins>' % text)
       elif op == self.DIFF_DELETE:
-        html.append("<del style=\"background:#ffe6e6;\">%s</del>" % text)
+                html.append('<del style="background:#ffe6e6;">%s</del>' % text)
       elif op == self.DIFF_EQUAL:
         html.append("<span>%s</span>" % text)
     return "".join(html)
@@ -1089,7 +1162,7 b' class diff_match_patch:'
       Source text.
     """
     text = []
-    for (op, data) in diffs:
+        for op, data in diffs:
       if op != self.DIFF_INSERT:
         text.append(data)
     return "".join(text)
@@ -1104,7 +1177,7 b' class diff_match_patch:'
       Destination text.
     """
     text = []
-    for (op, data) in diffs:
+        for op, data in diffs:
       if op != self.DIFF_DELETE:
         text.append(data)
     return "".join(text)
@@ -1122,7 +1195,7 b' class diff_match_patch:'
     levenshtein = 0
     insertions = 0
     deletions = 0
-    for (op, data) in diffs:
+        for op, data in diffs:
       if op == self.DIFF_INSERT:
         insertions += len(data)
       elif op == self.DIFF_DELETE:
@@ -1148,7 +1221,7 b' class diff_match_patch:'
       Delta text.
     """
     text = []
-    for (op, data) in diffs:
+        for op, data in diffs:
       if op == self.DIFF_INSERT:
         # High ascii will raise UnicodeDecodeError.  Use Unicode instead.
         data = data.encode("utf-8")
@@ -1173,7 +1246,7 b' class diff_match_patch:'
     Raises:
       ValueError: If invalid input.
     """
-    if type(delta) == unicode:
+        if type(delta) == str:
       # Deltas should be composed of a subset of ascii chars, Unicode not
       # required.  If this encode raises UnicodeEncodeError, delta is invalid.
       delta = delta.encode("ascii")
@@ -1188,7 +1261,7 b' class diff_match_patch:'
       # operation of this token (delete, insert, equality).
       param = token[1:]
       if token[0] == "+":
-        param = urllib.parse.unquote(param).decode("utf-8")
+                param = urllib.parse.unquote(param)
         diffs.append((self.DIFF_INSERT, param))
       elif token[0] == "-" or token[0] == "=":
         try:
@@ -1205,12 +1278,14 b' class diff_match_patch:'
           diffs.append((self.DIFF_DELETE, text))
       else:
         # Anything else is an error.
-        raise ValueError("Invalid diff operation in diff_fromDelta: " +
-            token[0])
+                raise ValueError(
+                    "Invalid diff operation in diff_fromDelta: " + token[0]
+                )
     if pointer != len(text1):
       raise ValueError(
-          "Delta length (%d) does not equal source text length (%d)." %
-         (pointer, len(text1)))
+                "Delta length (%d) does not equal source text length (%d)."
+                % (pointer, len(text1))
+            )
     return diffs
 
   #  MATCH FUNCTIONS
@@ -1329,8 +1404,11 b' class diff_match_patch:'
         if d == 0:  # First pass: exact match.
           rd[j] = ((rd[j + 1] << 1) | 1) & charMatch
         else:  # Subsequent passes: fuzzy match.
-          rd[j] = (((rd[j + 1] << 1) | 1) & charMatch) | (
-              ((last_rd[j + 1] | last_rd[j]) << 1) | 1) | last_rd[j + 1]
+                    rd[j] = (
+                        (((rd[j + 1] << 1) | 1) & charMatch)
+                        | (((last_rd[j + 1] | last_rd[j]) << 1) | 1)
+                        | last_rd[j + 1]
+                    )
         if rd[j] & matchmask:
           score = match_bitapScore(d, j - 1)
           # This match will almost certainly be better than any existing match.
@@ -1384,12 +1462,14 b' class diff_match_patch:'
 
     # Look for the first and last matches of pattern in text.  If two different
     # matches are found, increase the pattern length.
-    while (text.find(pattern) != text.rfind(pattern) and (self.Match_MaxBits ==
-        0 or len(pattern) < self.Match_MaxBits - self.Patch_Margin -
-        self.Patch_Margin)):
+        while text.find(pattern) != text.rfind(pattern) and (
+            self.Match_MaxBits == 0
+            or len(pattern) < self.Match_MaxBits - self.Patch_Margin - self.Patch_Margin
+        ):
       padding += self.Patch_Margin
-      pattern = text[max(0, patch.start2 - padding) :
-                     patch.start2 + patch.length1 + padding]
+            pattern = text[
+                max(0, patch.start2 - padding) : patch.start2 + patch.length1 + padding
+            ]
     # Add one chunk for good luck.
     padding += self.Patch_Margin
 
@@ -1398,8 +1478,9 b' class diff_match_patch:'
     if prefix:
       patch.diffs[:0] = [(self.DIFF_EQUAL, prefix)]
     # Add the suffix.
-    suffix = text[patch.start2 + patch.length1 :
-                  patch.start2 + patch.length1 + padding]
+        suffix = text[
+            patch.start2 + patch.length1 : patch.start2 + patch.length1 + padding
+        ]
     if suffix:
       patch.diffs.append((self.DIFF_EQUAL, suffix))
 
@@ -1455,8 +1536,7 b' class diff_match_patch:'
       # Method 3: text1, diffs
       text1 = a
       diffs = b
-    elif (isinstance(a, str) and isinstance(b, str) and
-          isinstance(c, list)):
+        elif isinstance(a, str) and isinstance(b, str) and isinstance(c, list):
       # Method 4: text1, text2, diffs
       # text2 is not used.
       text1 = a
@@ -1482,24 +1562,31 b' class diff_match_patch:'
         # Insertion
         patch.diffs.append(diffs[x])
         patch.length2 += len(diff_text)
-        postpatch_text = (postpatch_text[:char_count2] + diff_text +
-                          postpatch_text[char_count2:])
+                postpatch_text = (
+                    postpatch_text[:char_count2]
+                    + diff_text
+                    + postpatch_text[char_count2:]
+                )
       elif diff_type == self.DIFF_DELETE:
         # Deletion.
         patch.length1 += len(diff_text)
         patch.diffs.append(diffs[x])
-        postpatch_text = (postpatch_text[:char_count2] +
-                          postpatch_text[char_count2 + len(diff_text):])
-      elif (diff_type == self.DIFF_EQUAL and
-            len(diff_text) <= 2 * self.Patch_Margin and
-            len(patch.diffs) != 0 and len(diffs) != x + 1):
+                postpatch_text = (
+                    postpatch_text[:char_count2]
+                    + postpatch_text[char_count2 + len(diff_text) :]
+                )
+            elif (
+                diff_type == self.DIFF_EQUAL
+                and len(diff_text) <= 2 * self.Patch_Margin
+                and len(patch.diffs) != 0
+                and len(diffs) != x + 1
+            ):
         # Small equality inside a patch.
         patch.diffs.append(diffs[x])
         patch.length1 += len(diff_text)
         patch.length2 += len(diff_text)
 
-      if (diff_type == self.DIFF_EQUAL and
-          len(diff_text) >= 2 * self.Patch_Margin):
+            if diff_type == self.DIFF_EQUAL and len(diff_text) >= 2 * self.Patch_Margin:
         # Time for a new patch.
         if len(patch.diffs) != 0:
           self.patch_addContext(patch, prepatch_text)
@@ -1579,11 +1666,15 b' class diff_match_patch:'
       if len(text1) > self.Match_MaxBits:
         # patch_splitMax will only provide an oversized pattern in the case of
         # a monster delete.
-        start_loc = self.match_main(text, text1[:self.Match_MaxBits],
-                                    expected_loc)
+                start_loc = self.match_main(
+                    text, text1[: self.Match_MaxBits], expected_loc
+                )
         if start_loc != -1:
-          end_loc = self.match_main(text, text1[-self.Match_MaxBits:],
-              expected_loc + len(text1) - self.Match_MaxBits)
+                    end_loc = self.match_main(
+                        text,
+                        text1[-self.Match_MaxBits :],
+                        expected_loc + len(text1) - self.Match_MaxBits,
+                    )
           if end_loc == -1 or start_loc >= end_loc:
             # Can't find valid trailing context.  Drop this patch.
             start_loc = -1
@@ -1604,29 +1695,42 b' class diff_match_patch:'
           text2 = text[start_loc : end_loc + self.Match_MaxBits]
         if text1 == text2:
           # Perfect match, just shove the replacement text in.
-          text = (text[:start_loc] + self.diff_text2(patch.diffs) +
-                      text[start_loc + len(text1):])
+                    text = (
+                        text[:start_loc]
+                        + self.diff_text2(patch.diffs)
+                        + text[start_loc + len(text1) :]
+                    )
         else:
           # Imperfect match.
           # Run a diff to get a framework of equivalent indices.
           diffs = self.diff_main(text1, text2, False)
-          if (len(text1) > self.Match_MaxBits and
-              self.diff_levenshtein(diffs) / float(len(text1)) >
-              self.Patch_DeleteThreshold):
+                    if (
+                        len(text1) > self.Match_MaxBits
+                        and self.diff_levenshtein(diffs) / float(len(text1))
+                        > self.Patch_DeleteThreshold
+                    ):
             # The end points match, but the content is unacceptably bad.
             results[-1] = False
           else:
             self.diff_cleanupSemanticLossless(diffs)
             index1 = 0
-            for (op, data) in patch.diffs:
+                        for op, data in patch.diffs:
               if op != self.DIFF_EQUAL:
                 index2 = self.diff_xIndex(diffs, index1)
               if op == self.DIFF_INSERT:  # Insertion
-                text = text[:start_loc + index2] + data + text[start_loc +
-                                                               index2:]
+                                text = (
+                                    text[: start_loc + index2]
+                                    + data
+                                    + text[start_loc + index2 :]
+                                )
               elif op == self.DIFF_DELETE:  # Deletion
-                text = text[:start_loc + index2] + text[start_loc +
-                    self.diff_xIndex(diffs, index1 + len(data)):]
+                                text = (
+                                    text[: start_loc + index2]
+                                    + text[
+                                        start_loc
+                                        + self.diff_xIndex(diffs, index1 + len(data)) :
+                                    ]
+                                )
               if op != self.DIFF_DELETE:
                 index1 += len(data)
     # Strip the padding off.
@@ -1713,7 +1817,7 b' class diff_match_patch:'
       x -= 1
       start1 = bigpatch.start1
       start2 = bigpatch.start2
-      precontext = ''
+            precontext = ""
       while len(bigpatch.diffs) != 0:
         # Create one of several smaller patches.
         patch = patch_obj()
@@ -1724,8 +1828,10 b' class diff_match_patch:'
           patch.length1 = patch.length2 = len(precontext)
           patch.diffs.append((self.DIFF_EQUAL, precontext))
 
-        while (len(bigpatch.diffs) != 0 and
-               patch.length1 < patch_size - self.Patch_Margin):
+                while (
+                    len(bigpatch.diffs) != 0
+                    and patch.length1 < patch_size - self.Patch_Margin
+                ):
           (diff_type, diff_text) = bigpatch.diffs[0]
           if diff_type == self.DIFF_INSERT:
             # Insertions are harmless.
@@ -1733,9 +1839,12 b' class diff_match_patch:'
             start2 += len(diff_text)
             patch.diffs.append(bigpatch.diffs.pop(0))
             empty = False
-          elif (diff_type == self.DIFF_DELETE and len(patch.diffs) == 1 and
-              patch.diffs[0][0] == self.DIFF_EQUAL and
-              len(diff_text) > 2 * patch_size):
+                    elif (
+                        diff_type == self.DIFF_DELETE
+                        and len(patch.diffs) == 1
+                        and patch.diffs[0][0] == self.DIFF_EQUAL
+                        and len(diff_text) > 2 * patch_size
+                    ):
             # This is a large deletion.  Let it pass in one chunk.
             patch.length1 += len(diff_text)
             start1 += len(diff_text)
@@ -1744,8 +1853,9 b' class diff_match_patch:'
             del bigpatch.diffs[0]
           else:
             # Deletion or equality.  Only take as much as we can stomach.
-            diff_text = diff_text[:patch_size - patch.length1 -
-                                  self.Patch_Margin]
+                        diff_text = diff_text[
+                            : patch_size - patch.length1 - self.Patch_Margin
+                        ]
             patch.length1 += len(diff_text)
             start1 += len(diff_text)
             if diff_type == self.DIFF_EQUAL:
@@ -1758,8 +1868,10 b' class diff_match_patch:'
             if diff_text == bigpatch.diffs[0][1]:
               del bigpatch.diffs[0]
             else:
-              bigpatch.diffs[0] = (bigpatch.diffs[0][0],
-                                   bigpatch.diffs[0][1][len(diff_text):])
+                            bigpatch.diffs[0] = (
+                                bigpatch.diffs[0][0],
+                                bigpatch.diffs[0][1][len(diff_text) :],
+                            )
 
         # Compute the head context for the next patch.
         precontext = self.diff_text2(patch.diffs)
@@ -1770,8 +1882,10 b' class diff_match_patch:'
           patch.length1 += len(postcontext)
           patch.length2 += len(postcontext)
           if len(patch.diffs) != 0 and patch.diffs[-1][0] == self.DIFF_EQUAL:
-            patch.diffs[-1] = (self.DIFF_EQUAL, patch.diffs[-1][1] +
-                               postcontext)
+                        patch.diffs[-1] = (
+                            self.DIFF_EQUAL,
+                            patch.diffs[-1][1] + postcontext,
+                        )
           else:
             patch.diffs.append((self.DIFF_EQUAL, postcontext))
 
@@ -1813,7 +1927,7 b' class diff_match_patch:'
     patches = []
     if not textline:
       return patches
-    text = textline.split('\n')
+        text = textline.split("\n")
     while len(text) != 0:
       m = re.match("^@@ -(\d+),?(\d*) \+(\d+),?(\d*) @@$", text[0])
       if not m:
@@ -1821,20 +1935,20 b' class diff_match_patch:'
       patch = patch_obj()
       patches.append(patch)
       patch.start1 = int(m.group(1))
-      if m.group(2) == '':
+            if m.group(2) == "":
         patch.start1 -= 1
         patch.length1 = 1
-      elif m.group(2) == '0':
+            elif m.group(2) == "0":
         patch.length1 = 0
       else:
         patch.start1 -= 1
         patch.length1 = int(m.group(2))
 
       patch.start2 = int(m.group(3))
-      if m.group(4) == '':
+            if m.group(4) == "":
         patch.start2 -= 1
         patch.length2 = 1
-      elif m.group(4) == '0':
+            elif m.group(4) == "0":
         patch.length2 = 0
       else:
         patch.start2 -= 1
@@ -1846,22 +1960,22 b' class diff_match_patch:'
         if text[0]:
           sign = text[0][0]
         else:
-          sign = ''
+                    sign = ""
         line = urllib.parse.unquote(text[0][1:])
         line = line.decode("utf-8")
-        if sign == '+':
+                if sign == "+":
           # Insertion.
           patch.diffs.append((self.DIFF_INSERT, line))
-        elif sign == '-':
+                elif sign == "-":
           # Deletion.
           patch.diffs.append((self.DIFF_DELETE, line))
-        elif sign == ' ':
+                elif sign == " ":
           # Minor equality.
           patch.diffs.append((self.DIFF_EQUAL, line))
-        elif sign == '@':
+                elif sign == "@":
           # Start of next patch.
           break
-        elif sign == '':
+                elif sign == "":
           # Blank line?  Whatever.
           pass
         else:
@@ -1872,12 +1986,10 b' class diff_match_patch:'
 
 
 class patch_obj:
-  """Class representing one patch operation.
-  """
+    """Class representing one patch operation."""
 
   def __init__(self):
-    """Initializes with an empty list of diffs.
-    """
+        """Initializes with an empty list of diffs."""
     self.diffs = []
     self.start1 = None
     self.start2 = None
@@ -1906,7 +2018,7 b' class patch_obj:'
       coords2 = str(self.start2 + 1) + "," + str(self.length2)
     text = ["@@ -", coords1, " +", coords2, " @@\n"]
     # Escape the body of the patch with %xx notation.
-    for (op, data) in self.diffs:
+        for op, data in self.diffs:
       if op == diff_match_patch.DIFF_INSERT:
         text.append("+")
       elif op == diff_match_patch.DIFF_DELETE:
@@ -1916,4 +2028,4 b' class patch_obj:'
       # High ascii will raise UnicodeDecodeError.  Use Unicode instead.
       data = data.encode("utf-8")
       text.append(urllib.parse.quote(data, "!~*'();/?:@&=+$,# ") + "\n")
-    return "".join(text)
  No newline at end of file
+        return "".join(text)