karaoke-lyrics-processor 0.4.1__py3-none-any.whl → 0.6.0__py3-none-any.whl

karaoke_lyrics_processor/__init__.py

@@ -1,2 +1 @@
 from .karaoke_lyrics_processor import KaraokeLyricsProcessor
-

karaoke_lyrics_processor/cli.py

@@ -1,7 +1,12 @@
 #!/usr/bin/env python
 import argparse
 import logging
-import pkg_resources
+
+try:
+    from importlib.metadata import version
+except ImportError:
+    # Fallback for Python < 3.8
+    from importlib_metadata import version
 from karaoke_lyrics_processor import KaraokeLyricsProcessor
 
 
@@ -17,7 +22,7 @@ def main():
         formatter_class=lambda prog: argparse.RawTextHelpFormatter(prog, max_help_position=50),
     )
 
-    package_version = pkg_resources.get_distribution("karaoke-lyrics-processor").version
+    package_version = version("karaoke-lyrics-processor")
     parser.add_argument("-v", "--version", action="version", version=f"%(prog)s {package_version}")
     parser.add_argument("-d", "--debug", action="store_true", help="Enable debug mode, setting log level to DEBUG.")
     parser.add_argument("-o", "--output", type=str, help="Optional: Specify the output filename for the processed lyrics.")

karaoke_lyrics_processor/karaoke_lyrics_processor.py

@@ -5,6 +5,7 @@ import docx2txt
 from striprtf.striprtf import rtf_to_text
 import os
 import codecs
+import textract  # Add textract import
 
 
 class KaraokeLyricsProcessor:
@@ -60,15 +61,20 @@ class KaraokeLyricsProcessor:
     def read_txt_file(self):
         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)}")
+        self.logger.debug(f"Read {len(lines)} lines from {self.input_filename}")
         return self.clean_text(content).splitlines()
 
     def read_doc_file(self):
-        text = docx2txt.process(self.input_filename)
+        try:
+            text = docx2txt.process(self.input_filename)
+        except Exception as e:
+            self.logger.debug(f"docx2txt failed to read file, trying textract: {str(e)}")
+            try:
+                # Use textract as fallback for .doc files
+                text = textract.process(self.input_filename).decode("utf-8")
+            except Exception as e2:
+                raise ValueError(f"Failed to read doc file with both docx2txt and textract: {str(e2)}")
         return self.clean_text(text).splitlines()
 
     def read_rtf_file(self):
@@ -78,16 +84,29 @@ class KaraokeLyricsProcessor:
         return self.clean_text(plain_text).splitlines()
 
     def clean_text(self, text):
-        self.logger.debug(f"Cleaning text: {repr(text)}")
-        # Remove any non-printable characters except newlines and U+2005 (four-per-em space)
+        # Remove any non-printable characters except newlines and U+2005
+        original_len = len(text)
         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)}")
+        if len(cleaned) != original_len:
+            self.logger.debug(f"Removed {original_len - len(cleaned)} non-printable characters")
+
         # Replace multiple newlines with a single newline
+        newlines_before = cleaned.count("\n")
         cleaned = re.sub(r"\n{2,}", "\n", cleaned)
-        self.logger.debug(f"Text after replacing multiple newlines: {repr(cleaned)}")
+        newlines_after = cleaned.count("\n")
+        if newlines_before != newlines_after:
+            self.logger.debug(f"Consolidated {newlines_before - newlines_after} extra newlines")
+
         # Remove leading/trailing whitespace from each line
-        cleaned = "\n".join(line.strip() for line in cleaned.splitlines())
-        self.logger.debug(f"Final cleaned text: {repr(cleaned)}")
+        lines_before = cleaned.splitlines()
+        cleaned = "\n".join(line.strip() for line in lines_before)
+        lines_after = cleaned.splitlines()
+
+        # Count lines that changed due to stripping
+        changed_lines = sum(1 for before, after in zip(lines_before, lines_after) if before != after)
+        if changed_lines > 0:
+            self.logger.debug(f"Stripped whitespace from {changed_lines} lines")
+
         return cleaned
 
     def find_best_split_point(self, line):
@@ -147,47 +166,39 @@ 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: {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"
+        space_pattern = r"[^\S\n]|\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
         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):
         """
         Remove unnecessary spaces before punctuation marks.
         """
-        self.logger.debug(f"Cleaning punctuation spacing in: {text}")
+        self.logger.debug(f"Cleaning punctuation spacing")
         # Remove space before comma, period, exclamation mark, question mark, colon, and semicolon
         cleaned_text = re.sub(r"\s+([,\.!?:;])", r"\1", text)
-        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}")
+        self.logger.debug(f"Fixing commas inside quotes")
         # 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):
@@ -228,6 +239,9 @@ class KaraokeLyricsProcessor:
                 line = line[end_paren + 1 :].strip()
             else:
                 split_point = self.find_best_split_point(line)
+                # Ensure we make progress - if split_point is 0 or too small, force a reasonable split
+                if split_point <= 0:
+                    split_point = min(self.max_line_length, len(line))
                 processed_lines.append(line[:split_point].strip())
                 line = line[split_point:].strip()
 
@@ -265,6 +279,9 @@ class KaraokeLyricsProcessor:
         split_lines = []
         while len(line) > self.max_line_length:
             split_point = self.find_best_split_point(line)
+            # Ensure we make progress - if split_point is 0 or too small, force a reasonable split
+            if split_point <= 0:
+                split_point = min(self.max_line_length, len(line))
             split_lines.append(line[:split_point].strip())
             line = line[split_point:].strip()
 
@@ -289,6 +306,8 @@ class KaraokeLyricsProcessor:
 
             all_processed = True
             new_lyrics = []
+            previous_line_count = len(lyrics_lines)
+
             for line in lyrics_lines:
                 line = line.strip()
                 processed = self.process_line(line)
@@ -298,6 +317,11 @@ class KaraokeLyricsProcessor:
 
             lyrics_lines = new_lyrics
 
+            # Safety check: if no progress is being made, break out of the loop
+            if len(lyrics_lines) == previous_line_count and not all_processed:
+                self.logger.warning("No progress made in processing, forcing completion to avoid infinite loop")
+                break
+
             iteration_count += 1
 
         processed_lyrics_text = "\n".join(lyrics_lines)
@@ -307,7 +331,7 @@ class KaraokeLyricsProcessor:
         processed_lyrics_text = self.clean_punctuation_spacing(processed_lyrics_text)
 
         self.processed_lyrics_text = processed_lyrics_text
-        
+
         # Try to copy to clipboard, but don't fail if it's not available
         try:
             pyperclip.copy(processed_lyrics_text)

{karaoke_lyrics_processor-0.4.1.dist-info → karaoke_lyrics_processor-0.6.0.dist-info}/LICENSE

@@ -1,6 +1,6 @@
 MIT License
 
-Copyright (c) 2023 karaokenerds
+Copyright (c) 2023 Nomad Karaoke LLC
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal

karaoke_lyrics_processor-0.6.0.dist-info/METADATA

@@ -0,0 +1,217 @@
+Metadata-Version: 2.3
+Name: karaoke-lyrics-processor
+Version: 0.6.0
+Summary: Process song lyrics to prepare them for karaoke video production, e.g. by splitting long lines
+License: MIT
+Author: Andrew Beveridge
+Author-email: andrew@beveridge.uk
+Requires-Python: >=3.10,<4.0
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Requires-Dist: docx2txt (>=0.8)
+Requires-Dist: pyperclip (>=1.8)
+Requires-Dist: python-docx (>=1)
+Requires-Dist: striprtf (>=0.0.27)
+Requires-Dist: textract-py3 (>=2.1.0)
+Project-URL: Documentation, https://github.com/nomadkaraoke/karaoke-lyrics-processor/blob/main/README.md
+Project-URL: Homepage, https://github.com/nomadkaraoke/karaoke-lyrics-processor
+Project-URL: Repository, https://github.com/nomadkaraoke/karaoke-lyrics-processor
+Description-Content-Type: text/markdown
+
+# Karaoke Lyrics Processor 🎶 ✍️
+
+![PyPI - Version](https://img.shields.io/pypi/v/karaoke-lyrics-processor)
+![Test Coverage](https://codecov.io/gh/nomadkaraoke/karaoke-lyrics-processor/branch/main/graph/badge.svg)
+![Python Version](https://img.shields.io/badge/python-3.9+-blue)
+![Tests](https://github.com/nomadkaraoke/karaoke-lyrics-processor/workflows/Test%20and%20Publish/badge.svg)
+
+Karaoke Lyrics Processor is a tool to prepare song lyrics for karaoke video production. 
+
+It processes lyrics by intelligently splitting long lines, handling parentheses, cleaning punctuation, and ensuring that each line fits within a specified maximum length. This tool is especially useful for creating karaoke tracks where timing and line length are crucial for readability.
+
+## ✨ Features
+
+### Core Processing
+- **Smart Line Splitting**: Automatically splits long lines using intelligent algorithms that prioritize commas, "and" conjunctions, and natural word boundaries
+- **Parentheses Handling**: Properly processes lines containing parentheses, maintaining lyrical flow and handling nested parentheses
+- **Punctuation Cleanup**: Removes unnecessary spaces before punctuation marks and fixes comma placement
+- **Unicode Support**: Handles international characters and special Unicode spaces correctly
+- **Safety Mechanisms**: Built-in infinite loop prevention and iteration limits for robust processing
+
+### File Format Support
+- **Multiple Input Formats**: Supports TXT, DOCX, DOC, and RTF files
+- **Encoding Handling**: Properly handles UTF-8 and various text encodings
+- **Fallback Processing**: Uses multiple libraries (docx2txt, textract) for maximum compatibility
+
+### User Experience
+- **Clipboard Integration**: Automatically copies processed lyrics to clipboard for easy pasting
+- **Flexible Output**: Customizable output filenames and automatic naming conventions
+- **Debug Mode**: Comprehensive logging for troubleshooting and fine-tuning
+- **Command Line Interface**: Full-featured CLI with helpful options and error handling
+
+### Quality & Reliability
+- **98% Test Coverage**: Comprehensive test suite with 88 tests covering all functionality
+- **Edge Case Handling**: Robust handling of empty files, very long words, malformed input, and unusual formatting
+- **Performance Tested**: Memory efficient processing with performance safeguards
+- **Error Recovery**: Graceful error handling with informative messages
+
+## 🚀 Installation
+
+To install the Karaoke Lyrics Processor, ensure you have Python 3.9 or newer in your environment. 
+
+This package is available on PyPI and can be installed using pip:
+
+```bash
+pip install karaoke-lyrics-processor
+```
+
+## 📋 Usage
+
+### Command Line Interface
+
+Process a lyrics file with default settings:
+```bash
+karaoke-lyrics-processor path/to/your/lyrics.txt
+```
+
+**Output**: Creates `path/to/your/lyrics (Lyrics Processed).txt` with processed lyrics.
+
+### Advanced Usage Examples
+
+```bash
+# Custom output file
+karaoke-lyrics-processor -o my_processed_lyrics.txt song.txt
+
+# Custom line length (default is 36 characters)
+karaoke-lyrics-processor -l 50 song.txt
+
+# Debug mode for detailed logging
+karaoke-lyrics-processor -d song.txt
+
+# Combine all options
+karaoke-lyrics-processor -d -o output.txt -l 40 input.docx
+```
+
+### Supported Input Formats
+
+- **`.txt`** - Plain text files (UTF-8 recommended)
+- **`.docx`** - Microsoft Word documents
+- **`.doc`** - Legacy Microsoft Word documents  
+- **`.rtf`** - Rich Text Format files
+
+### Command Line Options
+
+```bash
+usage: karaoke-lyrics-processor [-h] [-v] [-d] [-o OUTPUT] [-l LINE_LENGTH] filename
+
+Process song lyrics to prepare them for karaoke video production
+
+positional arguments:
+  filename                                   Path to the lyrics file to process
+
+options:
+  -h, --help                                 Show help message and exit
+  -v, --version                              Show program's version number and exit
+  -d, --debug                                Enable debug mode with detailed logging
+  -o OUTPUT, --output OUTPUT                 Specify the output filename
+  -l LINE_LENGTH, --line_length LINE_LENGTH  Maximum line length (default: 36)
+```
+
+## 🔧 Processing Features
+
+### Intelligent Line Splitting
+The processor uses sophisticated algorithms to find optimal split points:
+
+1. **Comma Priority**: Splits at commas near the middle of long lines
+2. **Conjunction Splitting**: Uses "and" as split points when appropriate  
+3. **Word Boundaries**: Respects word boundaries and avoids breaking words
+4. **Parentheses Awareness**: Handles parenthetical content intelligently
+5. **Fallback Mechanisms**: Forces splits when no natural break points exist
+
+### Text Cleaning
+- Removes non-printable characters while preserving essential formatting
+- Normalizes various Unicode space characters to regular spaces
+- Consolidates multiple consecutive newlines
+- Strips unnecessary whitespace from line beginnings and ends
+
+### Error Handling
+- Graceful handling of unsupported file formats
+- Recovery from encoding issues
+- Protection against infinite processing loops
+- Clear error messages for troubleshooting
+
+## 🧪 Development & Testing
+
+This package maintains high quality standards with comprehensive testing:
+
+- **98% Test Coverage** across all modules
+- **88 Total Tests** including unit, integration, and CLI tests
+- **Edge Case Testing** for robustness
+- **Performance Testing** to prevent regressions
+- **Continuous Integration** with automated testing
+
+### Running Tests
+
+```bash
+# Install development dependencies
+pip install pytest pytest-cov
+
+# Run the full test suite
+pytest --cov=karaoke_lyrics_processor --cov-report=html
+
+# Run with verbose output
+pytest -v
+
+# Generate coverage report
+pytest --cov-report=term-missing
+```
+
+## 🤝 Contributing
+
+Contributions are very much welcome! This project follows best practices for maintainability:
+
+1. **Fork** the repository
+2. **Create** a feature branch (`git checkout -b feature/amazing-feature`)
+3. **Write tests** for your changes
+4. **Ensure** tests pass and maintain >90% coverage
+5. **Commit** your changes (`git commit -m 'Add amazing feature'`)
+6. **Push** to the branch (`git push origin feature/amazing-feature`)
+7. **Open** a Pull Request
+
+### Development Setup
+
+```bash
+# Clone the repository
+git clone https://github.com/nomadkaraoke/karaoke-lyrics-processor.git
+cd karaoke-lyrics-processor
+
+# Install development dependencies
+pip install -e ".[dev]"
+
+# Run tests
+python run_tests.py
+```
+
+- This project is 100% open-source and free for anyone to use and modify as they wish
+- All contributions are tested automatically via CI/CD
+- Code quality is maintained through comprehensive testing and reviews
+
+## 📄 License
+
+This project is licensed under the MIT [License](LICENSE).
+
+## 💌 Contact
+
+For questions, feature requests, or bug reports:
+- **Issues**: [GitHub Issues](https://github.com/nomadkaraoke/karaoke-lyrics-processor/issues)
+- **Email**: [Andrew Beveridge](mailto:andrew@beveridge.uk) (@beveradb)
+- **Discussions**: [GitHub Discussions](https://github.com/nomadkaraoke/karaoke-lyrics-processor/discussions)
+
+---
+
+*Built with ❤️ for the karaoke community*
+

karaoke_lyrics_processor-0.6.0.dist-info/RECORD

@@ -0,0 +1,8 @@
+karaoke_lyrics_processor/__init__.py,sha256=hvvtfq-00myAQ8fh8lSpfmZ2CEUM8sRwpSJ71zHkTeg,61
+karaoke_lyrics_processor/cli.py,sha256=lcqKBwnLnZIw51P79NNTs95nsyv6XDS1ho2NDjyOrmU,2614
+karaoke_lyrics_processor/karaoke_lyrics_processor.py,sha256=Y0BJPXYH82XRecahp63nqCRa1XJG0pEx1PXp-0bT1go,14693
+karaoke_lyrics_processor-0.6.0.dist-info/LICENSE,sha256=TW0vsdMUcgKaaExYAGNzumF-6GNsAGEwxG2vrjxc71E,1074
+karaoke_lyrics_processor-0.6.0.dist-info/METADATA,sha256=-HkXqkO5XmEYbxGNr0Cr7N_s74caPPFSOZ4ilSmDQqE,8236
+karaoke_lyrics_processor-0.6.0.dist-info/WHEEL,sha256=b4K_helf-jlQoXBBETfwnf4B04YC67LOev0jo4fX5m8,88
+karaoke_lyrics_processor-0.6.0.dist-info/entry_points.txt,sha256=hjFp6CUxl1p-1WJYfB6TbNcI_DHEnVzX3BXAs4y_0O8,78
+karaoke_lyrics_processor-0.6.0.dist-info/RECORD,,

{karaoke_lyrics_processor-0.4.1.dist-info → karaoke_lyrics_processor-0.6.0.dist-info}/WHEEL

@@ -1,4 +1,4 @@
 Wheel-Version: 1.0
-Generator: poetry-core 1.9.1
+Generator: poetry-core 2.1.3
 Root-Is-Purelib: true
 Tag: py3-none-any

karaoke_lyrics_processor-0.4.1.dist-info/METADATA

@@ -1,93 +0,0 @@
-Metadata-Version: 2.1
-Name: karaoke-lyrics-processor
-Version: 0.4.1
-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
-Author: Andrew Beveridge
-Author-email: andrew@beveridge.uk
-Requires-Python: >=3.9,<3.13
-Classifier: License :: OSI Approved :: MIT License
-Classifier: Programming Language :: Python :: 3
-Classifier: Programming Language :: Python :: 3.9
-Classifier: Programming Language :: Python :: 3.10
-Classifier: Programming Language :: Python :: 3.11
-Classifier: Programming Language :: Python :: 3.12
-Requires-Dist: docx2txt (>=0.8)
-Requires-Dist: pyperclip (>=1.8)
-Requires-Dist: python-docx (>=1)
-Requires-Dist: striprtf (>=0.0.27)
-Project-URL: Documentation, https://github.com/karaokenerds/karaoke-lyrics-processor/blob/main/README.md
-Project-URL: Repository, https://github.com/karaokenerds/karaoke-lyrics-processor
-Description-Content-Type: text/markdown
-
-# Karaoke Lyrics Processor 🎶 ✍️
-
-![PyPI - Version](https://img.shields.io/pypi/v/karaoke-lyrics-processor)
-
-Karaoke Lyrics Processor is a tool to prepare song lyrics for karaoke video production. 
-
-It processes lyrics by splitting long lines, handling parentheses, and ensuring that each line fits within a specified maximum length. 
-This tool is especially useful for creating karaoke tracks where timing and line length are crucial for readability.
-
-## Features
-
-- **Line Splitting**: Automatically splits long lines of lyrics to ensure they fit within a specified maximum length, making them more readable and suitable for karaoke display.
-- **Intelligent Splitting**: Finds the best split points in lines, considering punctuation and logical breaks in the lyrics.
-- **Parentheses Handling**: Processes lines containing parentheses appropriately, ensuring that the lyrical flow is maintained.
-- **Clipboard Support**: Copies the processed lyrics to the clipboard for easy pasting into video production software or other applications.
-- **Debug Mode**: Offers a debug mode for detailed logging, helping with troubleshooting and fine-tuning the processing.
-
-## Installation
-
-To install the Karaoke Lyrics Processor, ensure you have Python 3.9 or newer in your environment. 
-
-This package is available on PyPI and can be installed using pip. Run the following command in your terminal:
-
-```bash
-pip install karaoke-lyrics-processor
-```
-
-## Usage (CLI)
-
-To process a file containing song lyrics, use the following command:
-
-```bash
-karaoke-lyrics-processor <path_to_lyrics_file>
-```
-
-By default, this will create a new file in your current directory with `(Lyrics Processed)` in the filename containing the processed lyrics.
-
-### Command line options
-
-```bash
-usage: karaoke-lyrics-processor [-h] [-v] [-d] [-o OUTPUT] [-l LINE_LENGTH] filename
-
-Process song lyrics to prepare them for karaoke video production, e.g. by splitting long lines
-
-positional arguments:
-  filename                                   The path to the file containing the song lyrics to process.
-
-options:
-  -h, --help                                 show this help message and exit
-  -v, --version                              show program's version number and exit
-  -d, --debug                                Enable debug mode, setting log level to DEBUG.
-  -o OUTPUT, --output OUTPUT                 Optional: Specify the output filename for the processed lyrics.
-  -l LINE_LENGTH, --line_length LINE_LENGTH  Optional: Specify the maximum line length for the processed lyrics. Default is 36.
-```
-
-## Contributing 🤝
-
-Contributions are very much welcome! Please fork the repository and submit a pull request with your changes, and I'll try to review, merge and publish promptly!
-
-- This project is 100% open-source and free for anyone to use and modify as they wish. 
-- If the maintenance workload for this repo somehow becomes too much for me I'll ask for volunteers to share maintainership of the repo, though I don't think that is very likely
-
-## License 📄
-
-This project is licensed under the MIT [License](LICENSE).
-
-## Contact 💌
-
-For questions or feedback, please raise an issue or reach out to @beveradb ([Andrew Beveridge](mailto:andrew@beveridge.uk)) directly.
-

karaoke_lyrics_processor-0.4.1.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=Ew91yh7f0kbBy_nnWGntBClRQ1uxE9brhtWExcRl7t0,13716
-karaoke_lyrics_processor-0.4.1.dist-info/LICENSE,sha256=BiPihPDxhxIPEx6yAxVfAljD5Bhm_XG2teCbPEj_m0Y,1069
-karaoke_lyrics_processor-0.4.1.dist-info/METADATA,sha256=4Ut0L964ec92IuLlQiZilngjnjMr4dUm2FAIFk5uCLg,4264
-karaoke_lyrics_processor-0.4.1.dist-info/WHEEL,sha256=Nq82e9rUAnEjt98J6MlVmMCZb-t9cYE2Ir1kpBmnWfs,88
-karaoke_lyrics_processor-0.4.1.dist-info/entry_points.txt,sha256=hjFp6CUxl1p-1WJYfB6TbNcI_DHEnVzX3BXAs4y_0O8,78
-karaoke_lyrics_processor-0.4.1.dist-info/RECORD,,