pycaption 2.2.7__tar.gz → 2.2.8__tar.gz

{pycaption-2.2.7/pycaption.egg-info → pycaption-2.2.8}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: pycaption
-Version: 2.2.7
+Version: 2.2.8
 Summary: Closed caption converter
 Author: Joe Norton
 Author-email: joey@nortoncrew.com

{pycaption-2.2.7 → pycaption-2.2.8}/pycaption/scc/__init__.py

@@ -308,15 +308,21 @@ class SCCReader(BaseReader):
 
         self.time_translator.start_at(parts[0][0])
 
-        # loop through each word
-        for word in parts[0][2].split(' '):
+        word_list = parts[0][2].split(' ')
+        pacs_are_doubled = len(word_list) > 1 and word_list[0] == word_list[1]
+        for idx, word in enumerate(word_list):
             # ignore empty results or invalid commands
             word = word.strip()
+            previous_is_pac = idx > 0 and _is_pac_command(word_list[idx-1])
             if len(word) == 4:
-                self._translate_word(word)
+                self._translate_word(
+                    word=word,
+                    previous_is_pac=previous_is_pac,
+                    pacs_are_doubled=pacs_are_doubled
+                )
 
-    def _translate_word(self, word):
-        if self._handle_double_command(word):
+    def _translate_word(self, word, previous_is_pac, pacs_are_doubled):
+        if self._handle_double_command(word, pacs_are_doubled):
             # count frames for timing
             self.time_translator.increment_frames()
             return
@@ -324,7 +330,7 @@ class SCCReader(BaseReader):
         # TODO - check that all the positioning commands are here, or use
         # some other strategy to determine if the word is a command.
         if word in COMMANDS or _is_pac_command(word):
-            self._translate_command(word)
+            self._translate_command(word=word, previous_is_pac=previous_is_pac)
 
         # second, check if word is a special character
         elif word in SPECIAL_CHARS:
@@ -340,42 +346,56 @@ class SCCReader(BaseReader):
         # count frames for timing only after processing a command
         self.time_translator.increment_frames()
 
-    def _handle_double_command(self, word):
+    def _handle_double_command(self, word, pacs_are_doubled):
         # If the caption is to be broadcast, each of the commands are doubled
         # up for redundancy in case the signal is garbled in transmission.
         # The decoder is programmed to ignore a second command when it is the
         # same as the first.
-        # Also like codes, Special Characters are always doubled up,
+        # If we have doubled commands we're skipping also
+        # doubled special characters and doubled extended characters
         # with only one member of each pair being displayed.
-        if word in COMMANDS or _is_pac_command(word) or word in SPECIAL_CHARS or word in EXTENDED_CHARS:
-            if word == self.last_command:
-                self.last_command = ''
-                return True
+        actionable_commands = {
+            key: COMMANDS[key] for key in COMMANDS.keys() if key != "94a1"
+        }
+        doubled_types = word in actionable_commands or _is_pac_command(word)
+        if pacs_are_doubled:
+            doubled_types = doubled_types or word in SPECIAL_CHARS or word in EXTENDED_CHARS
+
+        if doubled_types and word == self.last_command:
+            return True
             # Fix for the <position> <tab offset> <position> <tab offset>
             # repetition
-            elif _is_pac_command(word) and word in self.last_command:
-                self.last_command = ''
+        elif _is_pac_command(word) and word in self.last_command:
+            self.last_command = ''
+            return True
+        elif word in PAC_TAB_OFFSET_COMMANDS:
+            if _is_pac_command(self.last_command):
+                self.last_command += f" {word}"
+                return False
+            else:
                 return True
-            elif word in PAC_TAB_OFFSET_COMMANDS:
-                if _is_pac_command(self.last_command):
-                    self.last_command += f" {word}"
-                    return False
-                else:
-                    return True
 
         self.last_command = word
         return False
 
     def _translate_special_char(self, word):
+        self.buffer.handle_backspace(word)
+        # add to buffer
         self.buffer.add_chars(SPECIAL_CHARS[word])
 
     def _translate_extended_char(self, word):
-        self.buffer.remove_ascii_duplicate(EXTENDED_CHARS[word])
-
+        """
+        Each of the 64 Extended Characters incorporates an automatic BS.
+        When an Extended Character is received, the cursor moves to the
+        left one column position (unless the Extended Character is the first
+        character on a row), erasing any character which may be in that location,
+        then displays the Extended Character.
+        """
+        self.buffer.handle_backspace(word)
         # add to buffer
         self.buffer.add_chars(EXTENDED_CHARS[word])
 
-    def _translate_command(self, word):
+    def _translate_command(self, word, previous_is_pac):
         # if command is pop_up
         if word == '9420':
             self.buffer_dict.set_active('pop')
@@ -444,7 +464,10 @@ class SCCReader(BaseReader):
 
         # If command is not one of the aforementioned, add it to buffer
         else:
-            self.buffer.interpret_command(word)
+            self.buffer.interpret_command(
+                command=word,
+                previous_is_pac=previous_is_pac
+            )
 
     def _translate_characters(self, word):
         # split word into the 2 bytes

{pycaption-2.2.7 → pycaption-2.2.8}/pycaption/scc/constants.py

@@ -1052,3 +1052,9 @@ MID_ROW_CODES = [
     "91a7", "91a8", "9129", "912a", "91ab", "912c", "91ad",
     "97ae", "972f", "91ae", "912f", "94a8"
 ]
+
+BACKGROUND_COLOR_CODES = [
+    "1020", "10a1", "10a2", "1023", "10a4", "1025", "1026",
+    "10a7", "10a8", "1029", "102a", "10ab", "102c", "10ad",
+    "10ae", "102f", "97ad"
+]

{pycaption-2.2.7 → pycaption-2.2.8}/pycaption/scc/specialized_collections.py

@@ -8,8 +8,8 @@ from ..geometry import (
 )
 from .constants import (
     PAC_BYTES_TO_POSITIONING_MAP, COMMANDS, PAC_TAB_OFFSET_COMMANDS,
-    MICROSECONDS_PER_CODEWORD, INCONVERTIBLE_TO_ASCII_EXTENDED_CHARS_ASSOCIATION,
-    MID_ROW_CODES
+    MICROSECONDS_PER_CODEWORD, BACKGROUND_COLOR_CODES,
+    MID_ROW_CODES, EXTENDED_CHARS, SPECIAL_CHARS
 )
 
 PopOnCue = collections.namedtuple("PopOnCue", "buffer, start, end")
@@ -288,6 +288,8 @@ class InstructionNodeCreator:
         else:
             self._collection = collection
 
+        self.last_style = None
+
         self._position_tracer = position_tracker
 
     def is_empty(self):
@@ -335,23 +337,32 @@ class InstructionNodeCreator:
 
         node.add_chars(*chars)
 
-    def interpret_command(self, command):
+    def interpret_command(self, command, previous_is_pac=None):
         """Given a command determines whether to turn italics on or off,
         or to set the positioning
 
         This is mostly used to convert from the legacy-style commands
 
         :type command: str
+        :type mode: pop or roll or paint
         """
         self._update_positioning(command)
 
         text = COMMANDS.get(command, '')
 
-        if command in MID_ROW_CODES:
-            for node in self._collection[::-1]:
-                if node.is_text_node():
-                    node.text += ' '
-                    break
+        if command == "94a1":
+            self.handle_backspace("94a1")
+
+        if command in BACKGROUND_COLOR_CODES:
+            # Since these codes are optional, they must be preceded
+            # with the space character (20h),
+            # which will be deleted when the code is applied.
+            # ex: 2080 97ad 94a1
+            if (
+                    self._collection[-1].is_text_node() and
+                    self._collection[-1].text[-1].isspace()
+            ):
+                self._collection[-1].text = self._collection[-1].text[:-1]
 
         if 'italic' in text:
             if 'end' not in text:
@@ -359,6 +370,7 @@ class InstructionNodeCreator:
                     _InstructionNode.create_italics_style(
                         self._position_tracer.get_current_position())
                 )
+                self.last_style = "italics on"
             else:
                 self._collection.append(
                     _InstructionNode.create_italics_style(
@@ -366,6 +378,19 @@ class InstructionNodeCreator:
                         turn_on=False
                     )
                 )
+                self.last_style = "italics off"
+
+        # mid row code that is not first code on the line
+        # (previous node is not a break node)
+        # fixes OCTO-11022
+        if command in MID_ROW_CODES and not previous_is_pac:
+            if self.last_style == "italics off":
+                self.add_chars(' ')
+            else:
+                for node in self._collection[::-1]:
+                    if node.is_text_node() and node.text:
+                        node.text += ' '
+                        break
 
     def _update_positioning(self, command):
         """Sets the positioning information to use for the next nodes
@@ -419,33 +444,32 @@ class InstructionNodeCreator:
 
         return instance
 
-    def remove_ascii_duplicate(self, accented_character):
+    def handle_backspace(self, word):
         """
-        Characters from the Extended Characters list are usually preceded by
-        their ASCII substitute, in case the decoder is not able to display
-        the special character.
-
-        This is used to remove the substitute character in order to avoid
-        displaying both.
-
-        :type accented_character: str
+        Move cursor back one position and delete that character
         """
-        is_text_node = (
-                self._collection and
-                self._collection[-1].is_text_node() and
-                self._collection[-1].text
-                )
-        if is_text_node:
-            try:
-                ascii_char = [
-                    unicodedata.normalize('NFD', accented_character)
-                    .encode('ascii', 'strict').decode("utf-8")
-                ]
-            except (UnicodeEncodeError, UnicodeDecodeError):
-                ascii_char = INCONVERTIBLE_TO_ASCII_EXTENDED_CHARS_ASSOCIATION.get(accented_character)
-
-            if ascii_char and self._collection[-1].text[-1] in ascii_char:
-                self._collection[-1].text = self._collection[-1].text[:-1]
+        node = self.get_previous_text_node()
+        # in case of no previous text nodes or
+        # if the backspace is required while no character
+        # do nothing
+        if node is None:
+            return
+        last_char = node.text[-1]
+        delete_previous_condition = (
+            (word in SPECIAL_CHARS and last_char not in SPECIAL_CHARS.values()) or
+            (word in EXTENDED_CHARS and last_char not in EXTENDED_CHARS.values()) or
+            word == "94a1"
+        )
+        # in case of special / extended char, perform backspace
+        # only if the previous character in not also special / extended
+        if delete_previous_condition:
+            node.text = node.text[:-1]
+
+    def get_previous_text_node(self):
+        for node in self._collection[::-1]:
+            if node.is_text_node() and node.text:
+                return node
+        return None
 
 
 def _get_layout_from_tuple(position_tuple):

{pycaption-2.2.7 → pycaption-2.2.8/pycaption.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: pycaption
-Version: 2.2.7
+Version: 2.2.8
 Summary: Closed caption converter
 Author: Joe Norton
 Author-email: joey@nortoncrew.com

{pycaption-2.2.7 → pycaption-2.2.8}/setup.py

@@ -24,7 +24,7 @@ transcript_dependencies = [
 
 setup(
     name='pycaption',
-    version='2.2.7',
+    version='2.2.8',
     description='Closed caption converter',
     long_description=open(README_PATH).read(),
     author='Joe Norton',

{pycaption-2.2.7 → pycaption-2.2.8}/tests/fixtures/dfxp.py

@@ -920,10 +920,10 @@ def sample_dfxp_from_scc_output():
    <region tts:displayAlign="before" tts:origin="40% 53%" tts:textAlign="left" xml:id="r5"/>
    <region tts:displayAlign="before" tts:origin="70% 17%" tts:textAlign="left" xml:id="r6"/>
    <region tts:displayAlign="before" tts:origin="20% 35%" tts:textAlign="left" xml:id="r7"/>
-   <region tts:displayAlign="before" tts:origin="20% 83%" tts:textAlign="left" xml:id="r8"/>
+   <region tts:displayAlign="before" tts:origin="25% 83%" tts:textAlign="left" xml:id="r8"/>
    <region tts:displayAlign="before" tts:origin="70% 11%" tts:textAlign="left" xml:id="r9"/>
    <region tts:displayAlign="before" tts:origin="40% 41%" tts:textAlign="left" xml:id="r10"/>
-   <region tts:displayAlign="before" tts:origin="20% 71%" tts:textAlign="left" xml:id="r11"/>
+   <region tts:displayAlign="before" tts:origin="25% 71%" tts:textAlign="left" xml:id="r11"/>
   </layout>
  </head>
  <body>

{pycaption-2.2.7 → pycaption-2.2.8}/tests/fixtures/scc.py

@@ -367,9 +367,11 @@ def sample_scc_duplicate_special_characters():
     return """\
 Scenarist_SCC V1.0
 
-00:23:28;01 9420 91b0 91b0 9131 9131 9132 9132 91b3 91b3 9134 9134 91b5 91b5 91b6 91b6 9137 9137 9138 9138 91b9 91b9 91ba 91ba 913b 913b 91bc 91bc 913d 913d 913e 913e 91bf 91bf 942f
+00:23:28;01 9420 9420 91b0 91b0 9131 9131 9132 9132 91b3 91b3 9134 9134 91b5 91b5 91b6 91b6 9137 9137 9138 9138 91b9 91b9 91ba 91ba 913b 913b 91bc 91bc 913d 913d 913e 913e 91bf 91bf 942f
 
-00:53:28;01 9420 91b0 9131 9132 91b3 9134 91b5 91b6 9137 9138 91b9 91ba 913b 91bc 913d 913e 91bf 942f
+00:33:28;01 9420 91b0 9131 9132 91b3 9134 91b5 91b6 9137 9138 91b9 91ba 913b 91bc 913d 913e 91bf 942f
+
+00:53:28;01 9420 91b0 9131 c1c1 9132 91b3 9134 91b5 91b6 9137 9138 91b9 91ba 913b 91bc c1c1 913d 913e 91bf 942f
 
 """
 

{pycaption-2.2.7 → pycaption-2.2.8}/tests/test_scc.py

@@ -77,17 +77,15 @@ class TestSCCReader(ReaderTestingMixIn):
             ((40.0, UnitEnum.PERCENT), (53.0, UnitEnum.PERCENT)),
             ((70.0, UnitEnum.PERCENT), (17.0, UnitEnum.PERCENT)),
             ((20.0, UnitEnum.PERCENT), (35.0, UnitEnum.PERCENT)),
-            ((20.0, UnitEnum.PERCENT), (83.0, UnitEnum.PERCENT)),
+            ((25.0, UnitEnum.PERCENT), (83.0, UnitEnum.PERCENT)),
             ((70.0, UnitEnum.PERCENT), (11.0, UnitEnum.PERCENT)),
             ((40.0, UnitEnum.PERCENT), (41.0, UnitEnum.PERCENT)),
-            ((20.0, UnitEnum.PERCENT), (71.0, UnitEnum.PERCENT))
+            ((25.0, UnitEnum.PERCENT), (71.0, UnitEnum.PERCENT))
         ]
-
         actual_positioning = [
             caption_.layout_info.origin.serialized()
             for caption_ in captions.get_captions('en-US')
         ]
-
         assert expected_positioning == actual_positioning
 
     def test_tab_offset(self, sample_scc_tab_offset):
@@ -210,7 +208,7 @@ class TestSCCReader(ReaderTestingMixIn):
             'The I-10 Santa Monica Freeway ',
             'westbound is jammed,',
             'due to a three-car accident ',
-            'blocking lanes 1 and 2',
+            'blocking lanes 1 and 2'
         ]
 
         caption_set = SCCReader().read(sample_scc_duplicate_tab_offset)
@@ -225,7 +223,11 @@ class TestSCCReader(ReaderTestingMixIn):
 
     def test_skip_duplicate_special_characters(
             self, sample_scc_duplicate_special_characters):
-        expected_lines = ['®°½¿™¢£♪à èâêîôû', '®°½¿™¢£♪à èâêîôû']
+        expected_lines = [
+            '®°½¿™¢£♪à èâêîôû',   # double commands so we skip one
+            '®°½¿™¢£♪à èâêîôû',   # no double command, nothing skipped equal with above
+            '®°A½¿™¢£♪à èâêAîôû'  # no skips but a couple of normal chars "c1c1" = AA
+        ]
 
         caption_set = SCCReader().read(sample_scc_duplicate_special_characters)
         actual_lines = [
@@ -234,7 +236,6 @@ class TestSCCReader(ReaderTestingMixIn):
             for node in cap_.nodes
             if node.type_ == CaptionNode.TEXT
         ]
-
         assert expected_lines == actual_lines
 
     def test_flashing_cue(self, sample_scc_flashing_cue):
@@ -273,21 +274,21 @@ class TestCoverageOnly:
         actual_texts = [cap_.nodes[0].content for cap_ in captions]
         expected_texts = [
             '>>> HI.',
-            "I'M KEVIN CUNNING AND AT",
-            "INVESTOR'S BANK WE BELIEVE IN",
-            'HELPING THE LOCAL NEIGHBORHOODS',
-            'AND IMPROVING THE LIVES OF ALL',
-            'WE SERVE.',
-            '®°½',
-            'ABû',
-            'ÁÉÓ¡',
-            "WHERE YOU'RE STANDING NOW,",
-            "LOOKING OUT THERE, THAT'S AL",
-            'THE CROWD.',
-            '>> IT WAS GOOD TO BE IN TH',
-            "And restore Iowa's land, water",
-            'And wildlife.',
-            '>> Bike Iowa, your source for',
+             "I'M KEVIN CUNNING AND AT",
+             "INVESTOR'S BANK WE BELIEVE IN",
+             'HELPING THE LOCAL NEIGHBORHOODS',
+             'AND IMPROVING THE LIVES OF ALL',
+             'WE SERVE.',
+             '®°½',
+             'Aû',
+             'ÁÉÓ¡',
+             "WHERE YOU'RE STANDING NOW,",
+             "LOOKING OUT THERE, THAT'S AL",
+             'THE CROWD.',
+             '>> IT WAS GOOD TO BE IN TH',
+             "And restore Iowa's land, water",
+             'And wildlife.',
+             '>> Bike Iowa, your source for'
         ]
         assert expected_texts == actual_texts
 
@@ -383,6 +384,9 @@ class TestInterpretableNodeCreator:
         # 4. to get new opening italic nodes after changing position, if 3
         # happened
         # 5. to get a final italic closing node, if one is needed
+        # 9120 and 91ae are mid row codes and will add a space
+        # 9120 at the start of the following text node
+        # 91ae to the end of the previous text node
         node_creator.interpret_command('9470')  # row 15, col 0
         node_creator.interpret_command('9120')  # italics off
         node_creator.interpret_command('9120')  # italics off
@@ -401,7 +405,7 @@ class TestInterpretableNodeCreator:
         node_creator.add_chars('b')
         node_creator.interpret_command('91ae')  # italics ON again
         node_creator.add_chars('b')
-        node_creator.interpret_command('9120')  # italics OFF
+        node_creator.interpret_command('9120')  # italics OFF adds space
         node_creator.interpret_command('9120')  # italics OFF
 
         node_creator.interpret_command('1570')  # row 6 col 0
@@ -420,32 +424,35 @@ class TestInterpretableNodeCreator:
         result = list(node_creator)
 
         assert result[0].is_text_node()
-        assert result[1].requires_repositioning()
-        assert result[2].is_italics_node()
-        assert result[2].sets_italics_on()
+        assert result[1].is_text_node()
+        assert result[2].requires_repositioning()
 
-        assert result[3].is_text_node()
+        assert result[3].is_italics_node()
+        assert result[3].sets_italics_on()
         assert result[4].is_text_node()
-        assert result[5].is_text_node()
-
-        assert result[6].is_italics_node()
-        assert result[6].sets_italics_off()
+        assert result[5].sets_italics_off()
+        assert result[6].is_text_node()
 
-        assert result[7].requires_repositioning()
-        assert result[8].is_text_node()
+        assert result[7].is_text_node()
+        assert result[8].sets_italics_on()
 
-        assert result[9].requires_repositioning()
-        assert result[10].is_italics_node()
-        assert result[10].sets_italics_on()
+        assert result[9].is_text_node()
+        assert result[10].is_text_node()
 
-        assert result[11].is_text_node()
-        assert result[12].is_explicit_break()
+        assert result[11].sets_italics_off()
+        assert result[12].is_text_node()
         assert result[13].is_text_node()
-        assert result[14].is_explicit_break()
+        assert result[14].requires_repositioning()
         assert result[15].is_text_node()
 
-        assert result[16].is_italics_node()
-        assert result[16].sets_italics_off()
+        assert result[16].requires_repositioning()
+        assert result[17].sets_italics_on()
+        assert result[18].is_text_node()
+        assert result[19].is_explicit_break()
+        assert result[20].is_text_node()
+        assert result[21].is_explicit_break()
+        assert result[22].is_text_node()
+        assert result[23].sets_italics_off()
 
 
 class CaptionDummy: