karaoke-lyrics-processor 0.3.0__py3-none-any.whl → 0.4.0__py3-none-any.whl

karaoke_lyrics_processor/karaoke_lyrics_processor.py

@@ -5,6 +5,7 @@ import unicodedata
 import docx2txt
 from striprtf.striprtf import rtf_to_text
 import os
+import codecs
 
 
 class KaraokeLyricsProcessor:
@@ -46,6 +47,8 @@ class KaraokeLyricsProcessor:
     def read_input_file(self):
         file_extension = os.path.splitext(self.input_filename)[1].lower()
 
+        self.logger.debug(f"Reading input file: {self.input_filename}")
+
         if file_extension == ".txt":
             return self.read_txt_file()
         elif file_extension in [".docx", ".doc"]:
@@ -56,8 +59,14 @@ class KaraokeLyricsProcessor:
             raise ValueError(f"Unsupported file format: {file_extension}")
 
     def read_txt_file(self):
-        with open(self.input_filename, "r", encoding="utf-8") as infile:
-            return self.clean_text(infile.read()).splitlines()
+        with codecs.open(self.input_filename, "r", encoding="utf-8") as infile:
+            content = infile.read()
+        self.logger.debug(f"Raw content read from file: {repr(content)}")
+        lines = content.splitlines()
+        self.logger.debug(f"Number of lines read: {len(lines)}")
+        for i, line in enumerate(lines):
+            self.logger.debug(f"Line {i}: {repr(line)}")
+        return self.clean_text(content).splitlines()
 
     def read_doc_file(self):
         text = docx2txt.process(self.input_filename)
@@ -70,13 +79,17 @@ class KaraokeLyricsProcessor:
         return self.clean_text(plain_text).splitlines()
 
     def clean_text(self, text):
-        # Remove any non-printable characters except newlines
-        text = "".join(char for char in text if char.isprintable() or char == "\n")
+        self.logger.debug(f"Cleaning text: {repr(text)}")
+        # Remove any non-printable characters except newlines and U+2005 (four-per-em space)
+        cleaned = "".join(char for char in text if char.isprintable() or char in ["\n", "\u2005"])
+        self.logger.debug(f"Text after removing non-printable characters: {repr(cleaned)}")
         # Replace multiple newlines with a single newline
-        text = re.sub(r"\n{2,}", "\n", text)
+        cleaned = re.sub(r"\n{2,}", "\n", cleaned)
+        self.logger.debug(f"Text after replacing multiple newlines: {repr(cleaned)}")
         # Remove leading/trailing whitespace from each line
-        text = "\n".join(line.strip() for line in text.splitlines())
-        return text
+        cleaned = "\n".join(line.strip() for line in cleaned.splitlines())
+        self.logger.debug(f"Final cleaned text: {repr(cleaned)}")
+        return cleaned
 
     def find_best_split_point(self, line):
         """
@@ -135,15 +148,28 @@ class KaraokeLyricsProcessor:
         Replace non-printable space-like characters, tabs, and other whitespace with regular spaces,
         excluding newline characters.
         """
-        self.logger.debug(f"Replacing non-printable spaces in: {text}")
+        self.logger.debug(f"Replacing non-printable spaces in: {repr(text)}")
+
+        # Log each character and its Unicode code point
+        # for i, char in enumerate(text):
+        #     self.logger.debug(f"Character at position {i}: {repr(char)} (Unicode: U+{ord(char):04X})")
+
         # Define a pattern for space-like characters, including tabs and other whitespace, but excluding newlines
         space_pattern = r"[^\S\n\r]|\u00A0|\u1680|\u2000-\u200A|\u202F|\u205F|\u3000"
+
         # Replace matched characters with a regular space
         cleaned_text = re.sub(space_pattern, " ", text)
+
+        # Log the result of the replacement
+        self.logger.debug(f"Text after replacing non-printable spaces: {repr(cleaned_text)}")
+
         # Remove leading/trailing spaces and collapse multiple spaces into one, preserving newlines
-        cleaned_text = re.sub(r" +", " ", cleaned_text).strip()
-        self.logger.debug(f"Text after replacing non-printable spaces: {cleaned_text}")
-        return cleaned_text
+        final_text = re.sub(r" +", " ", cleaned_text).strip()
+
+        # Log the final result
+        self.logger.debug(f"Final text after cleaning: {repr(final_text)}")
+
+        return final_text
 
     def clean_punctuation_spacing(self, text):
         """
@@ -155,36 +181,52 @@ class KaraokeLyricsProcessor:
         self.logger.debug(f"Text after cleaning punctuation spacing: {cleaned_text}")
         return cleaned_text
 
+    def fix_commas_inside_quotes(self, text):
+        """
+        Move commas inside quotes to after the closing quote.
+        """
+        self.logger.debug(f"Fixing commas inside quotes in: {text}")
+        # Use regex to find patterns where a comma is inside quotes and move it outside
+        fixed_text = re.sub(r'(".*?)(,)(\s*")', r"\1\3\2", text)
+        self.logger.debug(f"Text after fixing commas inside quotes: {fixed_text}")
+        return fixed_text
+
     def process_line(self, line):
         """
         Process a single line to ensure it's within the maximum length,
         handle parentheses, and replace non-printable spaces.
         """
-        # Replace non-printable spaces at the beginning
         line = self.replace_non_printable_spaces(line)
-        # Clean up punctuation spacing
         line = self.clean_punctuation_spacing(line)
+        line = self.fix_commas_inside_quotes(line)
 
         processed_lines = []
         iteration_count = 0
         max_iterations = 100  # Failsafe limit
 
-        while len(line) > self.max_line_length:
-            if iteration_count > max_iterations:
-                self.logger.error(f"Maximum iterations exceeded in process_line for line: {line}")
-                break
-
+        while len(line) > self.max_line_length and iteration_count < max_iterations:
             # Check if the line contains parentheses
             if "(" in line and ")" in line:
                 start_paren = line.find("(")
-                end_paren = line.find(")") + 1
+                end_paren = self.find_matching_paren(line, start_paren)
                 if end_paren < len(line) and line[end_paren] == ",":
                     end_paren += 1
 
+                # Process text before parentheses if it exists
                 if start_paren > 0:
-                    processed_lines.append(line[:start_paren].strip())
-                processed_lines.append(line[start_paren:end_paren].strip())
-                line = line[end_paren:].strip()
+                    before_paren = line[:start_paren].strip()
+                    processed_lines.extend(self.split_line(before_paren))
+
+                # Process text within parentheses
+                paren_content = line[start_paren : end_paren + 1].strip()
+                if len(paren_content) > self.max_line_length:
+                    # Split the content within parentheses if it's too long
+                    split_paren_content = self.split_line(paren_content)
+                    processed_lines.extend(split_paren_content)
+                else:
+                    processed_lines.append(paren_content)
+
+                line = line[end_paren + 1 :].strip()
             else:
                 split_point = self.find_best_split_point(line)
                 processed_lines.append(line[:split_point].strip())
@@ -192,11 +234,46 @@ class KaraokeLyricsProcessor:
 
             iteration_count += 1
 
-        if line:  # Add the remaining part if not empty
-            processed_lines.append(line)
+        if line:  # Add any remaining part
+            processed_lines.extend(self.split_line(line))
+
+        if iteration_count >= max_iterations:
+            self.logger.error(f"Maximum iterations exceeded in process_line for line: {line}")
 
         return processed_lines
 
+    def find_matching_paren(self, line, start_index):
+        """
+        Find the index of the matching closing parenthesis for the opening parenthesis at start_index.
+        """
+        stack = 0
+        for i in range(start_index, len(line)):
+            if line[i] == "(":
+                stack += 1
+            elif line[i] == ")":
+                stack -= 1
+                if stack == 0:
+                    return i
+        return -1  # No matching parenthesis found
+
+    def split_line(self, line):
+        """
+        Split a line into multiple lines if it exceeds the maximum length.
+        """
+        if len(line) <= self.max_line_length:
+            return [line]
+
+        split_lines = []
+        while len(line) > self.max_line_length:
+            split_point = self.find_best_split_point(line)
+            split_lines.append(line[:split_point].strip())
+            line = line[split_point:].strip()
+
+        if line:
+            split_lines.append(line)
+
+        return split_lines
+
     def process(self):
         self.logger.info(f"Processing input lyrics from {self.input_filename}")
 

{karaoke_lyrics_processor-0.3.0.dist-info → karaoke_lyrics_processor-0.4.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: karaoke-lyrics-processor
-Version: 0.3.0
+Version: 0.4.0
 Summary: Process song lyrics to prepare them for karaoke video production, e.g. by splitting long lines
 Home-page: https://github.com/karaokenerds/karaoke-lyrics-processor
 License: MIT

karaoke_lyrics_processor-0.4.0.dist-info/RECORD

@@ -0,0 +1,8 @@
+karaoke_lyrics_processor/__init__.py,sha256=rLRkJQi61qkRiNXdlTleE3ahJ1oBKcghYVkz64x7IIg,62
+karaoke_lyrics_processor/cli.py,sha256=bdtseRI2jcChb1bMr92pc5mpSWpHXh4TSzA2tknbyjU,2522
+karaoke_lyrics_processor/karaoke_lyrics_processor.py,sha256=3x5Ev9xzJ_FHarHDiYHtxftpXH0PaWZGJl9GjYeeIg0,13510
+karaoke_lyrics_processor-0.4.0.dist-info/LICENSE,sha256=BiPihPDxhxIPEx6yAxVfAljD5Bhm_XG2teCbPEj_m0Y,1069
+karaoke_lyrics_processor-0.4.0.dist-info/METADATA,sha256=_tWFNbjNUj4WoA79ZqVCsRwH2J5KlMqXQ8j8ZthzoGI,4264
+karaoke_lyrics_processor-0.4.0.dist-info/WHEEL,sha256=Nq82e9rUAnEjt98J6MlVmMCZb-t9cYE2Ir1kpBmnWfs,88
+karaoke_lyrics_processor-0.4.0.dist-info/entry_points.txt,sha256=hjFp6CUxl1p-1WJYfB6TbNcI_DHEnVzX3BXAs4y_0O8,78
+karaoke_lyrics_processor-0.4.0.dist-info/RECORD,,

karaoke_lyrics_processor-0.3.0.dist-info/RECORD

@@ -1,8 +0,0 @@
-karaoke_lyrics_processor/__init__.py,sha256=rLRkJQi61qkRiNXdlTleE3ahJ1oBKcghYVkz64x7IIg,62
-karaoke_lyrics_processor/cli.py,sha256=bdtseRI2jcChb1bMr92pc5mpSWpHXh4TSzA2tknbyjU,2522
-karaoke_lyrics_processor/karaoke_lyrics_processor.py,sha256=LmsciDtBS1-apCbvya2RBmYCSH4S-svrIDpOb8Ut0Gw,10387
-karaoke_lyrics_processor-0.3.0.dist-info/LICENSE,sha256=BiPihPDxhxIPEx6yAxVfAljD5Bhm_XG2teCbPEj_m0Y,1069
-karaoke_lyrics_processor-0.3.0.dist-info/METADATA,sha256=JuGcHlIyUvoesSQbFxN1iu-JP-B4mmGQIIrgIVv72pE,4264
-karaoke_lyrics_processor-0.3.0.dist-info/WHEEL,sha256=Nq82e9rUAnEjt98J6MlVmMCZb-t9cYE2Ir1kpBmnWfs,88
-karaoke_lyrics_processor-0.3.0.dist-info/entry_points.txt,sha256=hjFp6CUxl1p-1WJYfB6TbNcI_DHEnVzX3BXAs4y_0O8,78
-karaoke_lyrics_processor-0.3.0.dist-info/RECORD,,