polytext 0.2.8b6__tar.gz → 0.2.8b8__tar.gz

{polytext-0.2.8b6 → polytext-0.2.8b8}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: polytext
-Version: 0.2.8b6
+Version: 0.2.8b8
 Summary: Python utilities to simplify document files management
 Home-page: https://github.com/docsity/polytext
 Author: Matteo Senardi

{polytext-0.2.8b6 → polytext-0.2.8b8}/polytext/converter/audio_to_text.py

@@ -63,6 +63,8 @@ AUDIO_DEFAULT_MAX_OUTPUT_TOKENS = 4096
 AUDIO_MAX_ADAPTIVE_SPLIT_DEPTH = 1
 AUDIO_ADAPTIVE_SPLIT_OVERLAP_MS = 2000
 AUDIO_LONG_DURATION_THRESHOLD_MS = 80 * 60 * 1000
+AUDIO_LOW_TEXT_THRESHOLD_WORDS_PER_MINUTE = 20
+AUDIO_LOW_TEXT_MIN_DURATION_MS = 60_000
 AUDIO_TAIL_REPETITION_LINES = int(os.getenv("AUDIO_TAIL_REPETITION_LINES", "200"))
 AUDIO_TAIL_REPETITION_THRESHOLD = float(os.getenv("AUDIO_TAIL_REPETITION_THRESHOLD", "0.35"))
 AUDIO_FALLBACK_SOURCE_PATTERN = os.getenv("AUDIO_FALLBACK_SOURCE_PATTERN", "flash-lite")
@@ -174,7 +176,7 @@ def find_suspicious_fallback_language_indices(
 ) -> list[int]:
     """Find internal fallback chunks whose language conflicts with two agreeing neighbours."""
     suspicious_indices = []
-    logger.info("Starting fallback language validation for %s transcript chunks", len(transcripts))
+    logger.debug("Starting fallback language validation for %s transcript chunks", len(transcripts))
 
     def has_fallback(result: dict | None) -> bool:
         if not result:
@@ -284,6 +286,37 @@ def normalize_no_human_speech_marker(text: str) -> tuple[str, bool]:
     return cleaned_text, False
 
 
+def summarize_audio_chunk_quality(chunks: list[dict], transcripts: list[str]) -> dict:
+    """Report empty and unusually short transcripts without discarding any text.
+
+    Indices are one-based. Short audio chunks are excluded from the low-text
+    count because a brief spoken phrase can be a complete transcription.
+    """
+    empty_indices = []
+    low_text_indices = []
+    for index, (chunk, transcript) in enumerate(zip(chunks, transcripts), start=1):
+        word_count = len(transcript.split())
+        if word_count == 0:
+            empty_indices.append(index)
+        else:
+            duration_ms = chunk.get("duration_ms", 0)
+            if (
+                duration_ms >= AUDIO_LOW_TEXT_MIN_DURATION_MS
+                and word_count * 60_000 < AUDIO_LOW_TEXT_THRESHOLD_WORDS_PER_MINUTE * duration_ms
+            ):
+                low_text_indices.append(index)
+
+    return {
+        "total_chunks": len(chunks),
+        "empty_chunks": len(empty_indices),
+        "low_text_chunks": len(low_text_indices),
+        "empty_chunk_indices": empty_indices,
+        "low_text_chunk_indices": low_text_indices,
+        "low_text_threshold_words_per_minute": AUDIO_LOW_TEXT_THRESHOLD_WORDS_PER_MINUTE,
+        "low_text_min_duration_ms": AUDIO_LOW_TEXT_MIN_DURATION_MS,
+    }
+
+
 def add_line_break_after_each_sentence(text: str) -> str:
     if not text:
         return text
@@ -369,7 +402,7 @@ def compress_and_convert_audio(input_path: str, bitrate_quality: int = 9) -> str
             os.unlink(temp_audio_path)
         raise
 
-    logger.info(f"Successfully normalized audio: {temp_audio_path}")
+    logger.debug("Audio normalization completed")
     return temp_audio_path
 
 
@@ -688,7 +721,7 @@ class AudioToTextConverter:
             config: types.GenerateContentConfig,
     ):
         file_size = os.path.getsize(audio_file)
-        logger.info(f"Audio file size: {file_size / (1024 * 1024):.2f} MB")
+        logger.debug("Audio file size: %.2f MB", file_size / (1024 * 1024))
         marker_nonce = uuid.uuid4().hex[:12]
         marker_start = f"<<<UNTRUSTED_AUDIO_START_{marker_nonce}>>>"
         marker_end = f"<<<UNTRUSTED_AUDIO_END_{marker_nonce}>>>"
@@ -703,9 +736,9 @@ class AudioToTextConverter:
                     model=self.transcription_model,
                     contents=[my_file]
                 )
-                logger.info(f"File size in tokens: {response}")
+                logger.debug("Audio file token count response received")
 
-                logger.info(f"Uploaded file: {my_file.name} - Starting transcription...")
+                logger.debug("Audio upload completed; starting transcription")
 
                 return client.models.generate_content(
                     model=self.transcription_model,
@@ -717,7 +750,7 @@ class AudioToTextConverter:
                 if temp_upload_path and os.path.exists(temp_upload_path):
                     os.remove(temp_upload_path)
 
-        logger.info("Audio file size does not exceed 20MB")
+        logger.debug("Audio can be sent inline")
         with open(audio_file, "rb") as f:
             audio_data = f.read()
 
@@ -820,8 +853,8 @@ class AudioToTextConverter:
             completion_tokens = getattr(usage_metadata, "candidates_token_count", 0) or 0
             prompt_tokens = getattr(usage_metadata, "prompt_token_count", 0) or 0
 
-            logger.info(f"Completion tokens: {completion_tokens}")
-            logger.info(f"Prompt tokens: {prompt_tokens}")
+            logger.debug("Audio completion tokens: %s", completion_tokens)
+            logger.debug("Audio prompt tokens: %s", prompt_tokens)
 
             if finish_reason and "RECITATION" in finish_reason:
                 raise EmptyDocument(
@@ -972,7 +1005,7 @@ class AudioToTextConverter:
 
     def process_chunk(self, chunk: dict, index: int) -> tuple[int, dict]:
         """Process a single audio chunk and return its transcript"""
-        logger.info(f"Transcribing chunk {index + 1}...")
+        logger.debug("Transcribing audio chunk %s", index + 1)
         transcript_dict = self.transcribe_audio(chunk["file_path"])
         return index, transcript_dict
 
@@ -1030,18 +1063,20 @@ class AudioToTextConverter:
                 - prompt_tokens (int): Total number of prompt tokens used
                 - completion_model (str): Name of the transcription model used
                 - completion_model_provider (str): Provider of the transcription model
+                - audio_chunk_quality (dict): Counts of empty and low-text chunks,
+                  with one-based indices and the applied words-per-minute threshold
 
         Raises:
             ValueError: If the audio file format is not recognized
             RuntimeError: If there's an error during audio processing or transcription
         """
         processed_audio_path = None
-        logger.info(f"Processing audio file {audio_path}...")
+        logger.debug("Processing audio file")
         file_size = os.path.getsize(audio_path)
-        logger.info(f"Audio file size: {file_size / (1024 * 1024):.2f} MB")
+        logger.debug("Audio file size: %.2f MB", file_size / (1024 * 1024))
 
         mime_type, _ = mimetypes.guess_type(audio_path)
-        logger.info(f"Original MIME type: {mime_type}")
+        logger.debug("Original audio MIME type: %s", mime_type)
 
         # Check if conversion and/or compression is needed
         needs_conversion = mime_type not in SUPPORTED_MIME_TYPES
@@ -1049,29 +1084,29 @@ class AudioToTextConverter:
 
         # If you need at least one of the two, apply compress_and_convert_audio
         if needs_conversion:  # or needs_compression:
-            logger.info("Audio file needs conversion, processing file...")
+            logger.debug("Audio requires conversion")
             processed_audio_path = compress_and_convert_audio(audio_path)
             used_file = processed_audio_path
-            logger.info(f"Audio file processed (conversion): {used_file}")
+            logger.debug("Audio conversion completed")
         else:
             used_file = audio_path
-            logger.info("Audio file is already in supported format")
+            logger.debug("Audio is already in a supported format")
             # If you need at least one of the two, apply compress_and_convert_audio
             if needs_conversion:  # or needs_compression:
-                logger.info("Audio file needs conversion, processing file...")
+                logger.debug("Audio requires conversion")
                 processed_audio_path = compress_and_convert_audio(input_path=audio_path,
                                                                   bitrate_quality=self.bitrate_quality)
                 used_file = processed_audio_path
-                logger.info(f"Audio file processed (conversion): {used_file}")
+                logger.debug("Audio conversion completed")
             else:
                 used_file = audio_path
-                logger.info("Audio file is already in supported format")
+                logger.debug("Audio is already in a supported format")
 
         # Create chunker and extract chunks
-        logger.info("Creating AudioChunker instance...")
+        logger.debug("Creating audio chunker")
         chunker = AudioChunker(used_file, max_llm_tokens=self.max_llm_tokens)
         self.set_long_audio_protections(chunker.duration_ms)
-        logger.info(
+        logger.debug(
             "Long-audio transcription protections enabled: %s (duration: %sms, threshold: %sms)",
             self.long_audio_protections_enabled,
             chunker.duration_ms,
@@ -1079,8 +1114,6 @@ class AudioToTextConverter:
         )
         chunks = chunker.extract_chunks()
 
-        logger.info(f"chunks: {chunks}")
-
         logger.info(f"Split audio into {len(chunks)} chunks")
         if len(chunks) > 1 and self.markdown_output:
             logger.info("Audio chunking is needed, returning minimal markdown output")
@@ -1121,7 +1154,8 @@ class AudioToTextConverter:
             "completion_tokens": completion_tokens + full_text_merged_dict["completion_tokens"],
             "prompt_tokens": prompt_tokens + full_text_merged_dict["prompt_tokens"],
             "completion_model": self.transcription_model,
-            "completion_model_provider": self.transcription_model_provider
+            "completion_model_provider": self.transcription_model_provider,
+            "audio_chunk_quality": summarize_audio_chunk_quality(chunks, transcript_chunks),
         }
         if len(chunk_results) == 1 and chunk_results[0]:
             for key in (

{polytext-0.2.8b6 → polytext-0.2.8b8}/polytext/converter/document_ocr_to_text.py

@@ -97,7 +97,7 @@ def compress_and_convert_image(input_path: str, target_size=1):
                 loglevel='error'
             ).run(quiet=True, overwrite_output=True)
 
-        logger.info(f"Successfully processed image: {temp_image_path}")
+        logger.debug("Successfully processed image")
         return temp_image_path
 
     except Exception as e:
@@ -363,17 +363,17 @@ class DocumentOCRToTextConverter:
         start_time = time.time()
 
         if self.markdown_output:
-            logger.info("Using prompt for markdown format")
+            logger.debug("Using prompt for markdown format")
         else:
-            logger.info("Using prompt for plain text format")
+            logger.debug("Using prompt for plain text format")
         prompt_template = self._build_prompt_template()
 
         try:
             if self.llm_api_key:
-                logger.info("Using provided Google API key")
+                logger.debug("Using provided Google API key")
                 client = genai.Client(api_key=self.llm_api_key)
             else:
-                logger.info("Using Google API key from ENV")
+                logger.debug("Using Google API key from environment")
                 client = genai.Client()
 
             config = types.GenerateContentConfig(
@@ -407,26 +407,26 @@ class DocumentOCRToTextConverter:
             )
 
             mime_type, _ = mimetypes.guess_type(file_for_ocr)
-            logger.info(f"OCR mime type: {mime_type}")
+            logger.debug("OCR MIME type: %s", mime_type)
             file_size = os.path.getsize(file_for_ocr)
-            logger.info(f"Initial image file size: {file_size}")
+            logger.debug("Initial OCR image size: %s bytes", file_size)
             if file_size > self.target_size * 1024 * 1024 or mime_type not in SUPPORTED_MIME_TYPES:
-                logger.info(f"Image file size exceeds {self.target_size}MB or unsupported mime type, compressing and converting image")
+                logger.debug("OCR image requires compression or conversion")
                 temp_file_for_ocr = compress_and_convert_image(input_path=file_for_ocr, target_size=self.target_size)
                 should_delete_temp_file = True
                 file_size = os.path.getsize(temp_file_for_ocr)
             else:
-                logger.info(f"Image file size does not exceed {self.target_size}MB and mime type is supported, no compression or conversion needed")
+                logger.debug("OCR image requires no compression or conversion")
                 temp_file_for_ocr = file_for_ocr
 
-            logger.info(f"Final image file size: {file_size / (1024 * 1024):.2f} MB")
+            logger.debug("Final OCR image size: %.2f MB", file_size / (1024 * 1024))
 
             if file_size > 20 * 1024 * 1024:
-                logger.info("Total image file size exceeds 20MB, uploading file before transcription")
+                logger.debug("Uploading large OCR image")
 
                 myfile = client.files.upload(file=temp_file_for_ocr)
 
-                logger.info(f"Uploaded image file - Starting OCR...")
+                logger.debug("OCR image upload completed")
 
                 contents = [myfile]
                 response = client.models.generate_content(
@@ -438,7 +438,7 @@ class DocumentOCRToTextConverter:
                 client.files.delete(name=myfile.name)
 
             else:
-                logger.info("Image file size does not exceed 20MB")
+                logger.debug("OCR image can be sent inline")
                 with open(temp_file_for_ocr, "rb") as f:
                     image_data = f.read()
 
@@ -472,8 +472,8 @@ class DocumentOCRToTextConverter:
                 threshold=OCR_TAIL_REPETITION_THRESHOLD,
             )
 
-            logger.info(f"Completion tokens: {response.usage_metadata.candidates_token_count}")
-            logger.info(f"Prompt tokens: {response.usage_metadata.prompt_token_count}")
+            logger.debug("OCR completion tokens: %s", response.usage_metadata.candidates_token_count)
+            logger.debug("OCR prompt tokens: %s", response.usage_metadata.prompt_token_count)
 
             if finish_reason and "RECITATION" in finish_reason:
                 raise EmptyDocument(

{polytext-0.2.8b6 → polytext-0.2.8b8}/polytext/converter/document_ocr_to_text_azure_oai.py

@@ -53,13 +53,13 @@ def compress_and_convert_image(input_path: str, target_size=1) -> str:
         os.close(fd)
 
         original_size = os.path.getsize(input_path)
-        logger.info(f"Original image size: {original_size / 1024 / 1024:.2f}MB")
+        logger.debug("Original image size: %.2fMB", original_size / 1024 / 1024)
 
         if original_size > target_size_bytes:
             compression_ratio = (target_size_bytes / original_size) ** 0.5
             compression_ratio = max(0.01, min(compression_ratio, 1.0))
 
-            logger.info(f"Compressing image with scale ratio ~{compression_ratio:.3f}")
+            logger.debug("Compressing image with scale ratio ~%.3f", compression_ratio)
             (
                 ffmpeg.input(input_path)
                 .output(
@@ -72,7 +72,7 @@ def compress_and_convert_image(input_path: str, target_size=1) -> str:
                 .run(quiet=True, overwrite_output=True)
             )
         else:
-            logger.info("Converting image to PNG without compression")
+            logger.debug("Converting image to PNG without compression")
             (
                 ffmpeg.input(input_path)
                 .output(
@@ -84,7 +84,7 @@ def compress_and_convert_image(input_path: str, target_size=1) -> str:
                 .run(quiet=True, overwrite_output=True)
             )
 
-        logger.info(f"Successfully processed image: {temp_image_path}")
+        logger.debug("Successfully processed image")
         return temp_image_path
 
     except Exception as e:
@@ -206,19 +206,19 @@ class DocumentOCRToTextConverter:
         start_time = time.time()
 
         prompt_template = self._build_prompt_template()
-        logger.info("Using prompt for %s format", "markdown" if self.markdown_output else "plain text")
+        logger.debug("Using prompt for %s format", "markdown" if self.markdown_output else "plain text")
 
         client = self._build_client()
 
         try:
             mime_type, _ = mimetypes.guess_type(file_for_ocr)
-            logger.info(f"OCR mime type: {mime_type}")
+            logger.debug("OCR mime type: %s", mime_type)
 
             file_size = os.path.getsize(file_for_ocr)
-            logger.info(f"Initial image file size: {file_size}")
+            logger.debug("Initial image file size: %s", file_size)
 
             if file_size > self.target_size * 1024 * 1024 or mime_type not in SUPPORTED_MIME_TYPES:
-                logger.info(
+                logger.debug(
                     f"Image exceeds {self.target_size}MB or unsupported mime type; compressing/converting"
                 )
                 temp_file_for_ocr = compress_and_convert_image(
@@ -226,11 +226,11 @@ class DocumentOCRToTextConverter:
                     target_size=self.target_size,
                 )
             else:
-                logger.info("No compression/conversion needed")
+                logger.debug("No compression/conversion needed")
                 temp_file_for_ocr = file_for_ocr
 
             file_size = os.path.getsize(temp_file_for_ocr)
-            logger.info(f"Final image file size: {file_size / (1024 * 1024):.2f} MB")
+            logger.debug("Final image file size: %.2f MB", file_size / (1024 * 1024))
 
             mime_type, _ = mimetypes.guess_type(temp_file_for_ocr)
             if mime_type is None:
@@ -281,8 +281,8 @@ class DocumentOCRToTextConverter:
             prompt_tokens = getattr(response.usage, "prompt_tokens", 0) if response.usage else 0
             completion_tokens = getattr(response.usage, "completion_tokens", 0) if response.usage else 0
 
-            logger.info(f"Completion tokens: {completion_tokens}")
-            logger.info(f"Prompt tokens: {prompt_tokens}")
+            logger.debug("Completion tokens: %s", completion_tokens)
+            logger.debug("Prompt tokens: %s", prompt_tokens)
             logger.info(f"OCR performed using {self.ocr_model} in {time_elapsed:.2f} seconds")
 
             return {

{polytext-0.2.8b6 → polytext-0.2.8b8}/polytext/converter/ocr_to_text.py

@@ -97,7 +97,7 @@ def compress_and_convert_image(input_path: str, target_size=1):
                 loglevel='error'
             ).run(quiet=True, overwrite_output=True)
 
-        logger.info(f"Successfully processed image: {temp_image_path}")
+        logger.debug("Successfully processed image")
         return temp_image_path
 
     except Exception as e:
@@ -335,18 +335,15 @@ class OCRToTextConverter:
         start_time = time.time()
 
         if self.markdown_output:
-            logger.info("Using prompt for markdown format")
+            logger.debug("Using prompt for markdown format")
         else:
-            logger.info("Using prompt for plain text format")
+            logger.debug("Using prompt for plain text format")
         prompt_template = self._build_prompt_template()
-        logger.info(prompt_template)
 
         try:
             if self.llm_api_key:
-                logger.info("Using provided Google API key")
                 client = genai.Client(api_key=self.llm_api_key)
             else:
-                logger.info("Using Google API key from ENV")
                 client = genai.Client()
 
             config = types.GenerateContentConfig(
@@ -380,26 +377,26 @@ class OCRToTextConverter:
             )
 
             mime_type, _ = mimetypes.guess_type(file_for_ocr)
-            logger.info(f"OCR mime type: {mime_type}")
+            logger.debug("OCR MIME type: %s", mime_type)
             file_size = os.path.getsize(file_for_ocr)
-            logger.info(f"Initial image file size: {file_size}")
+            logger.debug("Initial OCR image size: %s bytes", file_size)
             if file_size > self.target_size * 1024 * 1024 or mime_type not in SUPPORTED_MIME_TYPES:
-                logger.info(f"Image file size exceeds {self.target_size}MB or unsupported mime type, compressing and converting image")
+                logger.debug("OCR image requires compression or conversion")
                 temp_file_for_ocr = compress_and_convert_image(input_path=file_for_ocr, target_size=self.target_size)
                 should_delete_temp_file = True
                 file_size = os.path.getsize(temp_file_for_ocr)
             else:
-                logger.info(f"Image file size does not exceed {self.target_size}MB and mime type is supported, no compression or conversion needed")
+                logger.debug("OCR image requires no compression or conversion")
                 temp_file_for_ocr = file_for_ocr
 
-            logger.info(f"Final image file size: {file_size / (1024 * 1024):.2f} MB")
+            logger.debug("Final OCR image size: %.2f MB", file_size / (1024 * 1024))
 
             if file_size > 20 * 1024 * 1024:
-                logger.info("Total image file size exceeds 20MB, uploading file before transcription")
+                logger.debug("Uploading large OCR image")
 
                 myfile = client.files.upload(file=temp_file_for_ocr)
 
-                logger.info(f"Uploaded image file - Starting OCR...")
+                logger.debug("OCR image upload completed")
 
                 contents = [myfile]
                 response = client.models.generate_content(
@@ -411,7 +408,7 @@ class OCRToTextConverter:
                 client.files.delete(name=myfile.name)
 
             else:
-                logger.info("Image file size does not exceed 20MB")
+                logger.debug("OCR image can be sent inline")
                 with open(temp_file_for_ocr, "rb") as f:
                     image_data = f.read()
 
@@ -445,8 +442,8 @@ class OCRToTextConverter:
                 threshold=OCR_TAIL_REPETITION_THRESHOLD,
             )
 
-            logger.info(f"Completion tokens: {response.usage_metadata.candidates_token_count}")
-            logger.info(f"Prompt tokens: {response.usage_metadata.prompt_token_count}")
+            logger.debug("OCR completion tokens: %s", response.usage_metadata.candidates_token_count)
+            logger.debug("OCR prompt tokens: %s", response.usage_metadata.prompt_token_count)
 
             if finish_reason and "RECITATION" in finish_reason:
                 raise EmptyDocument(

{polytext-0.2.8b6 → polytext-0.2.8b8}/polytext/converter/ocr_to_text_azure_oai.py

@@ -52,13 +52,13 @@ def compress_and_convert_image(input_path: str, target_size=1) -> str:
         os.close(fd)
 
         original_size = os.path.getsize(input_path)
-        logger.info(f"Original image size: {original_size / 1024 / 1024:.2f}MB")
+        logger.debug("Original image size: %.2fMB", original_size / 1024 / 1024)
 
         if original_size > target_size_bytes:
             compression_ratio = (target_size_bytes / original_size) ** 0.5
             compression_ratio = max(0.01, min(compression_ratio, 1.0))
 
-            logger.info(f"Compressing image with scale ratio ~{compression_ratio:.3f}")
+            logger.debug("Compressing image with scale ratio ~%.3f", compression_ratio)
             (
                 ffmpeg.input(input_path)
                 .output(
@@ -71,7 +71,7 @@ def compress_and_convert_image(input_path: str, target_size=1) -> str:
                 .run(quiet=True, overwrite_output=True)
             )
         else:
-            logger.info("Converting image to PNG without compression")
+            logger.debug("Converting image to PNG without compression")
             (
                 ffmpeg.input(input_path)
                 .output(
@@ -83,7 +83,7 @@ def compress_and_convert_image(input_path: str, target_size=1) -> str:
                 .run(quiet=True, overwrite_output=True)
             )
 
-        logger.info(f"Successfully processed image: {temp_image_path}")
+        logger.debug("Successfully processed image")
         return temp_image_path
 
     except Exception as e:
@@ -181,7 +181,7 @@ class OCRToTextConverter:
         start_time = time.time()
 
         prompt_template = self._build_prompt_template()
-        logger.info("Using prompt for %s format", "markdown" if self.markdown_output else "plain text")
+        logger.debug("Using prompt for %s format", "markdown" if self.markdown_output else "plain text")
 
         # Build Azure client
         azure_api_key = self.llm_api_key or os.getenv("AZURE_OPENAI_API_KEY")
@@ -200,14 +200,14 @@ class OCRToTextConverter:
 
         try:
             mime_type, _ = mimetypes.guess_type(file_for_ocr)
-            logger.info(f"OCR mime type: {mime_type}")
+            logger.debug("OCR mime type: %s", mime_type)
 
             file_size = os.path.getsize(file_for_ocr)
-            logger.info(f"Initial image file size: {file_size}")
+            logger.debug("Initial image file size: %s", file_size)
 
             # Compress/convert if too large or unsupported type
             if file_size > self.target_size * 1024 * 1024 or mime_type not in SUPPORTED_MIME_TYPES:
-                logger.info(
+                logger.debug(
                     f"Image exceeds {self.target_size}MB or unsupported mime type; compressing/converting"
                 )
                 temp_file_for_ocr = compress_and_convert_image(
@@ -215,11 +215,11 @@ class OCRToTextConverter:
                     target_size=self.target_size,
                 )
             else:
-                logger.info("No compression/conversion needed")
+                logger.debug("No compression/conversion needed")
                 temp_file_for_ocr = file_for_ocr
 
             file_size = os.path.getsize(temp_file_for_ocr)
-            logger.info(f"Final image file size: {file_size / (1024 * 1024):.2f} MB")
+            logger.debug("Final image file size: %.2f MB", file_size / (1024 * 1024))
 
             # Azure vision chat expects either a public URL or base64 image data.
             # We'll use base64 data-URL.
@@ -260,8 +260,8 @@ class OCRToTextConverter:
             prompt_tokens = getattr(response.usage, "prompt_tokens", 0) if response.usage else 0
             completion_tokens = getattr(response.usage, "completion_tokens", 0) if response.usage else 0
 
-            logger.info(f"Completion tokens: {completion_tokens}")
-            logger.info(f"Prompt tokens: {prompt_tokens}")
+            logger.debug("Completion tokens: %s", completion_tokens)
+            logger.debug("Prompt tokens: %s", prompt_tokens)
 
             final_ocr_dict = {
                 "text": "" if "no readable text present" in text_out.lower() else text_out,

{polytext-0.2.8b6 → polytext-0.2.8b8}/polytext/converter/pdf.py

@@ -89,7 +89,7 @@ class DocumentConverter:
 
         # Check file extension
         _, ext = os.path.splitext(original_file)
-        logger.info(os.path.splitext(original_file))
+        logger.debug("Original file extension: %s", os.path.splitext(original_file)[1])
         if ext.lower() not in self.supported_extensions and ext.lower() != '.pdf':
             logger.warning(f"File extension '{ext}' may not be supported.")
 
@@ -105,7 +105,7 @@ class DocumentConverter:
         if ext.lower() == '.pdf':
             import shutil
             shutil.copy2(input_file, output_file)
-            logger.info(f"File is already a PDF. Copied to '{output_file}'")
+            logger.debug("Input is already a PDF; copied to output")
             return output_file
 
         # Check if LibreOffice is installed
@@ -134,7 +134,7 @@ class DocumentConverter:
                 text=True,
                 check=True,
             )
-            logger.info(f"Conversion successful: '{output_file}'")
+            logger.debug("Document conversion successful")
         except subprocess.CalledProcessError as e:
             output_parts = []
             if e.stdout:

{polytext-0.2.8b6 → polytext-0.2.8b8}/polytext/loader/audio.py

@@ -89,12 +89,12 @@ class AudioLoader:
         if self.s3_client is not None:
             downloader = Downloader(s3_client=self.s3_client, document_aws_bucket=self.document_aws_bucket)
             downloader.download_file_from_s3(file_path, temp_file_path)
-            logger.info(f'Downloaded {file_path} to {temp_file_path}')
+            logger.debug("Downloaded audio to a temporary file")
             return temp_file_path
         elif self.gcs_client is not None:
             downloader = Downloader(gcs_client=self.gcs_client, document_gcs_bucket=self.document_gcs_bucket)
             downloader.download_file_from_gcs(file_path, temp_file_path)
-            logger.info(f'Downloaded {file_path} to {temp_file_path}')
+            logger.debug("Downloaded audio to a temporary file")
             return temp_file_path
         raise AttributeError('Storage client not provided')
 
@@ -116,20 +116,20 @@ class AudioLoader:
             ValueError: If the `audio_source` is not "cloud" or "local".
         """
 
-        logger.info("Starting text extraction from audio...")
+        logger.debug("Starting text extraction from audio")
 
         # Load or download the video file
         if self.source == "cloud":
             fd, temp_file_path = tempfile.mkstemp()
             try:
                 temp_file_path = self.download_audio(file_path, temp_file_path)
-                logger.info(f"Successfully loaded audio file from {file_path}")
+                logger.debug("Successfully loaded cloud audio")
                 # saved_video_path = self.save_file_locally(temp_file_path, os.getcwd(), 'video')
             finally:
                 os.close(fd)  # Close the file descriptor
         elif self.source == "local":
             temp_file_path = file_path
-            logger.info(f"Successfully loaded audio file from local path {file_path}")
+            logger.debug("Successfully loaded local audio")
         else:
             raise ValueError("Invalid audio source. Choose 'cloud', or 'local'.")
 
@@ -148,7 +148,7 @@ class AudioLoader:
         # Clean up temporary file if it was downloaded
         if self.source == "cloud" and os.path.exists(temp_file_path):
             os.remove(temp_file_path)
-            logger.info(f"Removed temporary file {temp_file_path}")
+            logger.debug("Removed temporary audio")
 
         return result_dict