mkv-episode-matcher 0.1.13__py3-none-any.whl → 0.3.0__py3-none-any.whl

mkv_episode_matcher/libraries/pgs2srt/Libraries/SubZero/post_processing.py

@@ -49,8 +49,6 @@
 
 import re
 
-from tld import get_tld
-
 from Libraries.SubZero.dictionaries.data import data
 from Libraries.SubZero.SubZero import (
     MultipleLineProcessor,
@@ -60,6 +58,7 @@ from Libraries.SubZero.SubZero import (
     SubtitleTextModification,
     WholeLineProcessor,
 )
+from tld import get_tld
 
 
 class CommonFixes(SubtitleTextModification):
@@ -72,105 +71,134 @@ class CommonFixes(SubtitleTextModification):
 
     processors = [
         # normalize hyphens
-        NReProcessor(re.compile(r'(?u)([‑‐﹘﹣])'), "-", name="CM_hyphens"),
-
+        NReProcessor(re.compile(r"(?u)([‑‐﹘﹣])"), "-", name="CM_hyphens"),
         # -- = em dash
-        NReProcessor(re.compile(r'(?u)(\w|\b|\s|^)(-\s?-{1,2})'), r"\1—", name="CM_multidash"),
-
+        NReProcessor(
+            re.compile(r"(?u)(\w|\b|\s|^)(-\s?-{1,2})"), r"\1—", name="CM_multidash"
+        ),
         # line = _/-/\s
-        NReProcessor(re.compile(r'(?u)(^\W*[-_.:<>~"\']+\W*$)'), "", name="CM_non_word_only"),
-
+        NReProcessor(
+            re.compile(r'(?u)(^\W*[-_.:<>~"\']+\W*$)'), "", name="CM_non_word_only"
+        ),
         # remove >>
-        NReProcessor(re.compile(r'(?u)^\s?>>\s*'), "", name="CM_leading_crocodiles"),
-
+        NReProcessor(re.compile(r"(?u)^\s?>>\s*"), "", name="CM_leading_crocodiles"),
         # line = : text
-        NReProcessor(re.compile(r'(?u)(^\W*:\s*(?=\w+))'), "", name="CM_empty_colon_start"),
-
+        NReProcessor(
+            re.compile(r"(?u)(^\W*:\s*(?=\w+))"), "", name="CM_empty_colon_start"
+        ),
         # fix music symbols
-        NReProcessor(re.compile(r'(?u)(^[-\s>~]*[*#¶]+\s+)|(\s*[*#¶]+\s*$)'),
-                     lambda x: "♪ " if x.group(1) else " ♪",
-                     name="CM_music_symbols"),
-
+        NReProcessor(
+            re.compile(r"(?u)(^[-\s>~]*[*#¶]+\s+)|(\s*[*#¶]+\s*$)"),
+            lambda x: "♪ " if x.group(1) else " ♪",
+            name="CM_music_symbols",
+        ),
         # '' = "
-        NReProcessor(re.compile(r'(?u)([\'’ʼ❜‘‛][\'’ʼ❜‘‛]+)'), '"', name="CM_double_apostrophe"),
-
+        NReProcessor(
+            re.compile(r"(?u)([\'’ʼ❜‘‛][\'’ʼ❜‘‛]+)"), '"', name="CM_double_apostrophe"
+        ),
         # double quotes instead of single quotes inside words
-        NReProcessor(re.compile(r'(?u)([A-zÀ-ž])"([A-zÀ-ž])'), r"\1'\2", name="CM_double_as_single"),
-
+        NReProcessor(
+            re.compile(r'(?u)([A-zÀ-ž])"([A-zÀ-ž])'),
+            r"\1'\2",
+            name="CM_double_as_single",
+        ),
         # normalize quotes
-        NReProcessor(re.compile(r'(?u)(\s*["”“‟„])\s*(["”“‟„]["”“‟„\s]*)'),
-                     lambda match: '"' + (" " if match.group(2).endswith(" ") else ""),
-                     name="CM_normalize_quotes"),
-
+        NReProcessor(
+            re.compile(r'(?u)(\s*["”“‟„])\s*(["”“‟„]["”“‟„\s]*)'),
+            lambda match: '"' + (" " if match.group(2).endswith(" ") else ""),
+            name="CM_normalize_quotes",
+        ),
         # normalize single quotes
-        NReProcessor(re.compile(r'(?u)([\'’ʼ❜‘‛])'), "'", name="CM_normalize_squotes"),
-
+        NReProcessor(re.compile(r"(?u)([\'’ʼ❜‘‛])"), "'", name="CM_normalize_squotes"),
         # remove leading ...
-        NReProcessor(re.compile(r'(?u)^\.\.\.[\s]*'), "", name="CM_leading_ellipsis"),
-
+        NReProcessor(re.compile(r"(?u)^\.\.\.[\s]*"), "", name="CM_leading_ellipsis"),
         # remove "downloaded from" tags
-        NReProcessor(re.compile(r'(?ui).+downloaded\s+from.+'), "", name="CM_crap"),
-
+        NReProcessor(re.compile(r"(?ui).+downloaded\s+from.+"), "", name="CM_crap"),
         # no space after ellipsis
-        NReProcessor(re.compile(r'(?u)\.\.\.(?![\s.,!?\'"])(?!$)'), "... ", name="CM_ellipsis_no_space"),
-
+        NReProcessor(
+            re.compile(r'(?u)\.\.\.(?![\s.,!?\'"])(?!$)'),
+            "... ",
+            name="CM_ellipsis_no_space",
+        ),
         # no space before spaced ellipsis
-        NReProcessor(re.compile(r'(?u)(?<=[^\s])(?<!\s)\. \. \.'), " . . .", name="CM_ellipsis_no_space2"),
-
+        NReProcessor(
+            re.compile(r"(?u)(?<=[^\s])(?<!\s)\. \. \."),
+            " . . .",
+            name="CM_ellipsis_no_space2",
+        ),
         # multiple spaces
-        NReProcessor(re.compile(r'(?u)[\s]{2,}'), " ", name="CM_multiple_spaces"),
-
+        NReProcessor(re.compile(r"(?u)[\s]{2,}"), " ", name="CM_multiple_spaces"),
         # more than 3 dots
-        NReProcessor(re.compile(r'(?u)\.{3,}'), "...", name="CM_dots"),
-
+        NReProcessor(re.compile(r"(?u)\.{3,}"), "...", name="CM_dots"),
         # no space after starting dash
-        NReProcessor(re.compile(r'(?u)^-(?![\s-])'), "- ", name="CM_dash_space"),
-
+        NReProcessor(re.compile(r"(?u)^-(?![\s-])"), "- ", name="CM_dash_space"),
         # remove starting spaced dots (not matching ellipses)
-        NReProcessor(re.compile(r'(?u)^(?!\s?(\.\s\.\s\.)|(\s?\.{3}))(?=\.+\s+)[\s.]*'), "",
-                     name="CM_starting_spacedots"),
-
+        NReProcessor(
+            re.compile(r"(?u)^(?!\s?(\.\s\.\s\.)|(\s?\.{3}))(?=\.+\s+)[\s.]*"),
+            "",
+            name="CM_starting_spacedots",
+        ),
         # space missing before doublequote
-        ReProcessor(re.compile(r'(?u)(?<!^)(?<![\s(\["])("[^"]+")'), r' \1', name="CM_space_before_dblquote"),
-
+        ReProcessor(
+            re.compile(r'(?u)(?<!^)(?<![\s(\["])("[^"]+")'),
+            r" \1",
+            name="CM_space_before_dblquote",
+        ),
         # space missing after doublequote
-        ReProcessor(re.compile(r'(?u)("[^"\s][^"]+")([^\s.,!?)\]]+)'), r"\1 \2", name="CM_space_after_dblquote"),
-
+        ReProcessor(
+            re.compile(r'(?u)("[^"\s][^"]+")([^\s.,!?)\]]+)'),
+            r"\1 \2",
+            name="CM_space_after_dblquote",
+        ),
         # space before ending doublequote?
-
         # replace uppercase I with lowercase L in words
-        NReProcessor(re.compile(r'(?u)([a-zà-ž]+)(I+)'),
-                     lambda match: r'%s%s' % (match.group(1), "l" * len(match.group(2))),
-                     name="CM_uppercase_i_in_word"),
-
+        NReProcessor(
+            re.compile(r"(?u)([a-zà-ž]+)(I+)"),
+            lambda match: r"{}{}".format(match.group(1), "l" * len(match.group(2))),
+            name="CM_uppercase_i_in_word",
+        ),
         # fix spaces in numbers (allows for punctuation: ,.:' (comma/dot only fixed if after space, those may be
         # countdowns otherwise); don't break up ellipses
         NReProcessor(
-            re.compile(r'(?u)(\b[0-9]+[0-9:\']*(?<!\.\.)\s+(?!\.\.)[0-9,.:\'\s]*(?=[0-9]+)[0-9,.:\'])'),
-            lambda match: match.group(1).replace(" ", "") if match.group(1).count(" ") == 1 else match.group(1),
-            name="CM_spaces_in_numbers"),
-
+            re.compile(
+                r"(?u)(\b[0-9]+[0-9:\']*(?<!\.\.)\s+(?!\.\.)[0-9,.:\'\s]*(?=[0-9]+)[0-9,.:\'])"
+            ),
+            lambda match: match.group(1).replace(" ", "")
+            if match.group(1).count(" ") == 1
+            else match.group(1),
+            name="CM_spaces_in_numbers",
+        ),
         # uppercase after dot
         # NReProcessor(re.compile(r'(?u)((?<!(?=\s*[A-ZÀ-Ž-_0-9.]\s*))(?:[^.\s])+\.\s+)([a-zà-ž])'),
         #              lambda match: r'%s%s' % (match.group(1), match.group(2).upper()), name="CM_uppercase_after_dot"),
-
         # remove double interpunction
-        NReProcessor(re.compile(r'(?u)(\s*[,!?])\s*([,.!?][,.!?\s]*)'),
-                     lambda match: match.group(1).strip() + (" " if match.group(2).endswith(" ") else ""),
-                     name="CM_double_interpunct"),
-
+        NReProcessor(
+            re.compile(r"(?u)(\s*[,!?])\s*([,.!?][,.!?\s]*)"),
+            lambda match: match.group(1).strip()
+            + (" " if match.group(2).endswith(" ") else ""),
+            name="CM_double_interpunct",
+        ),
         # remove spaces before punctuation; don't break spaced ellipses
-        NReProcessor(re.compile(r'(?u)(?:(?<=^)|(?<=\w)) +([!?.,](?![!?.,]| \.))'), r"\1", name="CM_punctuation_space"),
-
+        NReProcessor(
+            re.compile(r"(?u)(?:(?<=^)|(?<=\w)) +([!?.,](?![!?.,]| \.))"),
+            r"\1",
+            name="CM_punctuation_space",
+        ),
         # add space after punctuation
-        NReProcessor(re.compile(r'(?u)(([^\s]*)([!?.,:])([A-zÀ-ž]{2,}))'),
-                     lambda match: "%s%s %s" % (match.group(2), match.group(3), match.group(4)) if not get_tld(match.group(1), fail_silently=True, fix_protocol=True) else match.group(1),
-                     name="CM_punctuation_space2"),
-
+        NReProcessor(
+            re.compile(r"(?u)(([^\s]*)([!?.,:])([A-zÀ-ž]{2,}))"),
+            lambda match: f"{match.group(2)}{match.group(3)} {match.group(4)}"
+            if not get_tld(match.group(1), fail_silently=True, fix_protocol=True)
+            else match.group(1),
+            name="CM_punctuation_space2",
+        ),
         # fix lowercase I in english
-        NReProcessor(re.compile(r'(?u)(\b)i(\b)'), r"\1I\2", name="CM_EN_lowercase_i",
-                     # supported=lambda p: p.language == ENGLISH),
-                     ),
+        NReProcessor(
+            re.compile(r"(?u)(\b)i(\b)"),
+            r"\1I\2",
+            name="CM_EN_lowercase_i",
+            # supported=lambda p: p.language == ENGLISH),
+        ),
     ]
 
 
@@ -200,16 +228,33 @@ class FixOCR(SubtitleTextModification):
         return [
             # remove broken HI tag colons (ANNOUNCER'., ". instead of :) after at least 3 uppercase chars
             # don't modify stuff inside quotes
-            NReProcessor(re.compile(r'(?u)(^[^"\'’ʼ❜‘‛”“‟„]*(?<=[A-ZÀ-Ž]{3})[A-ZÀ-Ž-_\s0-9]+)'
-                                    r'(["\'’ʼ❜‘‛”“‟„]*[.,‚،⹁、;]+)(\s*)(?!["\'’ʼ❜‘‛”“‟„])'),
-                         r"\1:\3", name="OCR_fix_HI_colons"),
+            NReProcessor(
+                re.compile(
+                    r'(?u)(^[^"\'’ʼ❜‘‛”“‟„]*(?<=[A-ZÀ-Ž]{3})[A-ZÀ-Ž-_\s0-9]+)'
+                    r'(["\'’ʼ❜‘‛”“‟„]*[.,‚،⹁、;]+)(\s*)(?!["\'’ʼ❜‘‛”“‟„])'
+                ),
+                r"\1:\3",
+                name="OCR_fix_HI_colons",
+            ),
             # fix F'bla
-            NReProcessor(re.compile(r'(?u)(\bF)(\')([A-zÀ-ž]*\b)'), r"\1\3", name="OCR_fix_F"),
+            NReProcessor(
+                re.compile(r"(?u)(\bF)(\')([A-zÀ-ž]*\b)"), r"\1\3", name="OCR_fix_F"
+            ),
             WholeLineProcessor(self.data_dict["WholeLines"], name="OCR_replace_line"),
-            MultipleWordReProcessor(self.data_dict["WholeWords"], name="OCR_replace_word"),
-            MultipleWordReProcessor(self.data_dict["BeginLines"], name="OCR_replace_beginline"),
-            MultipleWordReProcessor(self.data_dict["EndLines"], name="OCR_replace_endline"),
-            MultipleWordReProcessor(self.data_dict["PartialLines"], name="OCR_replace_partialline"),
-            MultipleLineProcessor(self.data_dict["PartialWordsAlways"], name="OCR_replace_partialwordsalways")
+            MultipleWordReProcessor(
+                self.data_dict["WholeWords"], name="OCR_replace_word"
+            ),
+            MultipleWordReProcessor(
+                self.data_dict["BeginLines"], name="OCR_replace_beginline"
+            ),
+            MultipleWordReProcessor(
+                self.data_dict["EndLines"], name="OCR_replace_endline"
+            ),
+            MultipleWordReProcessor(
+                self.data_dict["PartialLines"], name="OCR_replace_partialline"
+            ),
+            MultipleLineProcessor(
+                self.data_dict["PartialWordsAlways"],
+                name="OCR_replace_partialwordsalways",
+            ),
         ]
-

mkv_episode_matcher/libraries/pgs2srt/imagemaker.py

@@ -3,7 +3,6 @@ from PIL import Image
 
 
 def read_rle_bytes(ods_bytes):
-
     pixels = []
     line_builder = []
 
@@ -41,12 +40,13 @@ def read_rle_bytes(ods_bytes):
         i += incr
 
     if line_builder:
-        print(f'Probably an error; hanging pixels: {line_builder}')
+        print(f"Probably an error; hanging pixels: {line_builder}")
 
     return pixels
 
+
 def ycbcr2rgb(ar):
-    xform = np.array([[1, 0, 1.402], [1, -0.34414, -.71414], [1, 1.772, 0]])
+    xform = np.array([[1, 0, 1.402], [1, -0.34414, -0.71414], [1, 1.772, 0]])
     rgb = ar.astype(float)
     # Subtracting by 128 the R and G channels
     rgb[:, [1, 2]] -= 128
@@ -58,6 +58,7 @@ def ycbcr2rgb(ar):
     np.putmask(rgb, rgb < 0, 0)
     return np.uint8(rgb)
 
+
 def px_rgb_a(ods, pds, swap):
     px = read_rle_bytes(ods.img_data)
     px = np.array([[255] * (ods.width - len(l)) + l for l in px], dtype=np.uint8)
@@ -78,10 +79,11 @@ def px_rgb_a(ods, pds, swap):
 
     return px, rgb, a
 
+
 def make_image(ods, pds, swap=False):
     px, rgb, a = px_rgb_a(ods, pds, swap)
-    alpha = Image.fromarray(a, mode='L')
-    img = Image.fromarray(px, mode='P')
+    alpha = Image.fromarray(a, mode="L")
+    img = Image.fromarray(px, mode="P")
     img.putalpha(alpha)
     img.putpalette(rgb)
     return img

mkv_episode_matcher/libraries/pgs2srt/pgs2srt.py

@@ -6,21 +6,36 @@ from datetime import datetime, timedelta
 
 import pytesseract
 from imagemaker import make_image
+from Libraries.SubZero.post_processing import CommonFixes, FixOCR
 from pgsreader import PGSReader
 from PIL import Image, ImageOps
 
-from Libraries.SubZero.post_processing import CommonFixes, FixOCR
-
-parser = argparse.ArgumentParser(description='Convert PGS subtitles to SubRip format.')
-
-parser.add_argument('input', type=str, help="The input file (a .sup file).")
-parser.add_argument('--output', type=str, help="The output file (a .srt file).")
-parser.add_argument('--oem', type=int, help="The OCR Engine Mode to use (Default: 1).", default=1, choices=range(4))
-parser.add_argument('--language', type=str, help="The language to use (Default: eng).", default='eng')
-parser.add_argument('--fix_common', help='Fixes common whitespace/punctuation issues.',
-                    dest='fix_common', action='store_true')
-parser.add_argument('--fix_common_ocr', help='Fixes common OCR issues for supported languages.',
-                    dest='fix_ocr', action='store_true')
+parser = argparse.ArgumentParser(description="Convert PGS subtitles to SubRip format.")
+
+parser.add_argument("input", type=str, help="The input file (a .sup file).")
+parser.add_argument("--output", type=str, help="The output file (a .srt file).")
+parser.add_argument(
+    "--oem",
+    type=int,
+    help="The OCR Engine Mode to use (Default: 1).",
+    default=1,
+    choices=range(4),
+)
+parser.add_argument(
+    "--language", type=str, help="The language to use (Default: eng).", default="eng"
+)
+parser.add_argument(
+    "--fix_common",
+    help="Fixes common whitespace/punctuation issues.",
+    dest="fix_common",
+    action="store_true",
+)
+parser.add_argument(
+    "--fix_common_ocr",
+    help="Fixes common OCR issues for supported languages.",
+    dest="fix_ocr",
+    action="store_true",
+)
 
 args = parser.parse_args()
 
@@ -46,7 +61,11 @@ tesseract_config = f"-c tessedit_char_blacklist=[] --psm 6 --oem {args.oem}"
 # If an output file for the subrip output is provided, use that.
 # Otherwise remove the ".sup" extension from the input and append
 # ".srt".
-output_file = args.output if args.output is not None else (args.input.replace('.sup', '') + '.srt')
+output_file = (
+    args.output
+    if args.output is not None
+    else (args.input.replace(".sup", "") + ".srt")
+)
 
 # SubRip output
 output = ""
@@ -66,7 +85,7 @@ for ds in pgs.iter_displaysets():
 
             if pds and ods:
                 # Create and show the bitmap image and convert it to RGBA
-                src = make_image(ods, pds).convert('RGBA')
+                src = make_image(ods, pds).convert("RGBA")
 
                 # Create grayscale image with black background
                 img = Image.new("L", src.size, "BLACK")
@@ -76,13 +95,15 @@ for ds in pgs.iter_displaysets():
                 img = ImageOps.invert(img)
 
                 # Parse the image with tesesract
-                text = pytesseract.image_to_string(img, lang=tesseract_lang, config=tesseract_config).strip()
+                text = pytesseract.image_to_string(
+                    img, lang=tesseract_lang, config=tesseract_config
+                ).strip()
 
                 # Replace "|" with "I"
                 # Works better than blacklisting "|" in Tesseract,
                 # which results in I becoming "!" "i" and "1"
-                text = re.sub(r'[|/\\]', 'I', text)
-                text = re.sub(r'[_]', 'L', text)
+                text = re.sub(r"[|/\\]", "I", text)
+                text = re.sub(r"[_]", "L", text)
 
                 if args.fix_common:
                     text = fix_common.process(text)
@@ -100,11 +121,19 @@ for ds in pgs.iter_displaysets():
                 end = datetime.fromtimestamp(pcs.presentation_timestamp / 1000)
                 end = end + timedelta(hours=-1)
 
-                if isinstance(start, datetime) and isinstance(end, datetime) and len(text):
+                if (
+                    isinstance(start, datetime)
+                    and isinstance(end, datetime)
+                    and len(text)
+                ):
                     si = si + 1
                     sub_output = str(si) + "\n"
-                    sub_output += start.strftime("%H:%M:%S,%f")[0:12] + \
-                        " --> " + end.strftime("%H:%M:%S,%f")[0:12] + "\n"
+                    sub_output += (
+                        start.strftime("%H:%M:%S,%f")[0:12]
+                        + " --> "
+                        + end.strftime("%H:%M:%S,%f")[0:12]
+                        + "\n"
+                    )
                     sub_output += text + "\n\n"
 
                     output += sub_output

mkv_episode_matcher/libraries/pgs2srt/pgsreader.py

@@ -4,27 +4,26 @@ from collections import namedtuple
 from os.path import split as pathsplit
 
 # Constants for Segments
-PDS = int('0x14', 16)
-ODS = int('0x15', 16)
-PCS = int('0x16', 16)
-WDS = int('0x17', 16)
-END = int('0x80', 16)
+PDS = int("0x14", 16)
+ODS = int("0x15", 16)
+PCS = int("0x16", 16)
+WDS = int("0x17", 16)
+END = int("0x80", 16)
 
 # Named tuple access for static PDS palettes
-Palette = namedtuple('Palette', "Y Cr Cb Alpha")
+Palette = namedtuple("Palette", "Y Cr Cb Alpha")
+
 
 class InvalidSegmentError(Exception):
-    '''Raised when a segment does not match PGS specification'''
+    """Raised when a segment does not match PGS specification"""
 
 
 class PGSReader:
-
     def __init__(self, filepath):
         self.filedir, self.file = pathsplit(filepath)
-        with open(filepath, 'rb') as f:
+        with open(filepath, "rb") as f:
             self.bytes = f.read()
 
-
     def make_segment(self, bytes_):
         cls = SEGMENT_TYPE[bytes_[10]]
         return cls(bytes_)
@@ -40,35 +39,29 @@ class PGSReader:
         ds = []
         for s in self.iter_segments():
             ds.append(s)
-            if s.type == 'END':
+            if s.type == "END":
                 yield DisplaySet(ds)
                 ds = []
 
     @property
     def segments(self):
-        if not hasattr(self, '_segments'):
+        if not hasattr(self, "_segments"):
             self._segments = list(self.iter_segments())
         return self._segments
 
     @property
     def displaysets(self):
-        if not hasattr(self, '_displaysets'):
+        if not hasattr(self, "_displaysets"):
             self._displaysets = list(self.iter_displaysets())
         return self._displaysets
 
-class BaseSegment:
 
-    SEGMENT = {
-        PDS: 'PDS',
-        ODS: 'ODS',
-        PCS: 'PCS',
-        WDS: 'WDS',
-        END: 'END'
-    }
+class BaseSegment:
+    SEGMENT = {PDS: "PDS", ODS: "ODS", PCS: "PCS", WDS: "WDS", END: "END"}
 
     def __init__(self, bytes_):
         self.bytes = bytes_
-        if bytes_[:2] != b'PG':
+        if bytes_[:2] != b"PG":
             raise InvalidSegmentError
         self.pts = int(bytes_[2:6].hex(), base=16) / 90
         self.dts = int(bytes_[6:10].hex(), base=16) / 90
@@ -80,18 +73,20 @@ class BaseSegment:
         return self.size
 
     @property
-    def presentation_timestamp(self): return self.pts
+    def presentation_timestamp(self):
+        return self.pts
 
     @property
-    def decoding_timestamp(self): return self.dts
+    def decoding_timestamp(self):
+        return self.dts
 
     @property
-    def segment_type(self): return self.type
+    def segment_type(self):
+        return self.type
 
-class PresentationCompositionSegment(BaseSegment):
 
+class PresentationCompositionSegment(BaseSegment):
     class CompositionObject:
-
         def __init__(self, bytes_):
             self.bytes = bytes_
             self.object_id = int(bytes_[0:2].hex(), base=16)
@@ -106,9 +101,9 @@ class PresentationCompositionSegment(BaseSegment):
                 self.crop_height = int(bytes_[14:16].hex(), base=16)
 
     STATE = {
-        int('0x00', base=16): 'Normal',
-        int('0x40', base=16): 'Acquisition Point',
-        int('0x80', base=16): 'Epoch Start'
+        int("0x00", base=16): "Normal",
+        int("0x40", base=16): "Acquisition Point",
+        int("0x80", base=16): "Epoch Start",
     }
 
     def __init__(self, bytes_):
@@ -123,18 +118,22 @@ class PresentationCompositionSegment(BaseSegment):
         self._num_comps = self.data[10]
 
     @property
-    def composition_number(self): return self._num
+    def composition_number(self):
+        return self._num
 
     @property
-    def composition_state(self): return self._state
+    def composition_state(self):
+        return self._state
 
     @property
     def composition_objects(self):
-        if not hasattr(self, '_composition_objects'):
+        if not hasattr(self, "_composition_objects"):
             self._composition_objects = self.get_composition_objects()
             if len(self._composition_objects) != self._num_comps:
-                print('Warning: Number of composition objects asserted '
-                      'does not match the amount found.')
+                print(
+                    "Warning: Number of composition objects asserted "
+                    "does not match the amount found."
+                )
         return self._composition_objects
 
     def get_composition_objects(self):
@@ -146,8 +145,8 @@ class PresentationCompositionSegment(BaseSegment):
             bytes_ = bytes_[length:]
         return comps
 
-class WindowDefinitionSegment(BaseSegment):
 
+class WindowDefinitionSegment(BaseSegment):
     def __init__(self, bytes_):
         BaseSegment.__init__(self, bytes_)
         self.num_windows = self.data[0]
@@ -157,8 +156,8 @@ class WindowDefinitionSegment(BaseSegment):
         self.width = int(self.data[6:8].hex(), base=16)
         self.height = int(self.data[8:10].hex(), base=16)
 
-class PaletteDefinitionSegment(BaseSegment):
 
+class PaletteDefinitionSegment(BaseSegment):
     def __init__(self, bytes_):
         BaseSegment.__init__(self, bytes_)
         self.palette_id = self.data[0]
@@ -168,14 +167,14 @@ class PaletteDefinitionSegment(BaseSegment):
         # Iterate entries. Explode the 5 bytes into namedtuple Palette. Must be exploded
         for entry in range(len(self.data[2:]) // 5):
             i = 2 + entry * 5
-            self.palette[self.data[i]] = Palette(*self.data[i + 1:i + 5])
+            self.palette[self.data[i]] = Palette(*self.data[i + 1 : i + 5])
 
-class ObjectDefinitionSegment(BaseSegment):
 
+class ObjectDefinitionSegment(BaseSegment):
     SEQUENCE = {
-        int('0x40', base=16): 'Last',
-        int('0x80', base=16): 'First',
-        int('0xc0', base=16): 'First and last'
+        int("0x40", base=16): "Last",
+        int("0x80", base=16): "First",
+        int("0xc0", base=16): "First and last",
     }
 
     def __init__(self, bytes_):
@@ -188,13 +187,15 @@ class ObjectDefinitionSegment(BaseSegment):
         self.height = int(self.data[9:11].hex(), base=16)
         self.img_data = self.data[11:]
         if len(self.img_data) != self.data_len - 4:
-            print('Warning: Image data length asserted does not match the '
-                  'length found.')
+            print(
+                "Warning: Image data length asserted does not match the length found."
+            )
 
-class EndSegment(BaseSegment):
 
+class EndSegment(BaseSegment):
     @property
-    def is_end(self): return True
+    def is_end(self):
+        return True
 
 
 SEGMENT_TYPE = {
@@ -202,20 +203,23 @@ SEGMENT_TYPE = {
     ODS: ObjectDefinitionSegment,
     PCS: PresentationCompositionSegment,
     WDS: WindowDefinitionSegment,
-    END: EndSegment
+    END: EndSegment,
 }
 
-class DisplaySet:
 
+class DisplaySet:
     def __init__(self, segments):
         self.segments = segments
         self.segment_types = [s.type for s in segments]
-        self.has_image = 'ODS' in self.segment_types
+        self.has_image = "ODS" in self.segment_types
+
 
 def segment_by_type_getter(type_):
     def f(self):
         return [s for s in self.segments if s.type == type_]
+
     return f
 
+
 for type_ in BaseSegment.SEGMENT.values():
     setattr(DisplaySet, type_.lower(), property(segment_by_type_getter(type_)))