Tp3

packages/markitdown/src/markitdown/converters/_markdownify.py

@@ -21,20 +21,33 @@ def __init__(self, **options: Any):
         # Explicitly cast options to the expected type if necessary
         super().__init__(**options)
 
-    def convert_hn(
+    def convert_hN(
         self,
         n: int,
         el: Any,
         text: str,
-        convert_as_inline: Optional[bool] = False,
-        **kwargs,
+        parent_tags: Any = None,
     ) -> str:
         """Same as usual, but be sure to start with a new line"""
-        if not convert_as_inline:
+        # Get the parent's conversion result
+        result = super().convert_hN(n, el, text, parent_tags)  # type: ignore
+
+        # Check if this is an inline heading based on parent tags
+        convert_as_inline = parent_tags and any(tag in ['p', 'span', 'a'] for tag in parent_tags) if isinstance(parent_tags, list) else False
+
+        if convert_as_inline:
+            # For inline headings, remove all leading newlines
+            return result.lstrip('\n')
+        else:
+            # For block headings, ensure exactly one leading newline
+            # Strip existing leading newlines and add exactly one
+            stripped = result.lstrip('\n')
+            # Only add leading newline if the original text didn't start with one
             if not re.search(r"^\n", text):
-                return "\n" + super().convert_hn(n, el, text, convert_as_inline)  # type: ignore
-
-        return super().convert_hn(n, el, text, convert_as_inline)  # type: ignore
+                return "\n" + stripped
+            else:
+                # Text already had a leading newline, don't add another
+                return stripped
 
     def convert_a(
         self,

packages/markitdown/src/markitdown/converters/_rss_converter.py

@@ -143,8 +143,9 @@ def _parse_rss_type(self, doc: Document) -> DocumentConverterResult:
         channel_title = self._get_data_by_tag_name(channel, "title")
         channel_description = self._get_data_by_tag_name(channel, "description")
         items = channel.getElementsByTagName("item")
+        md_text = ""
         if channel_title:
-            md_text = f"# {channel_title}\n"
+            md_text += f"# {channel_title}\n"
         if channel_description:
             md_text += f"{channel_description}\n"
         for item in items:

packages/markitdown/src/markitdown/converters/_youtube_converter.py

@@ -178,13 +178,16 @@ def convert(
                     if len(languages) == 1:
                         print(f"Error fetching transcript: {e}")
                     else:
-                        # Translate transcript into first kwarg
-                        transcript = (
-                            transcript_list.find_transcript(languages)
-                            .translate(youtube_transcript_languages[0])
-                            .fetch()
-                        )
-                        transcript_text = " ".join([part.text for part in transcript])
+                        # Try to translate transcript into first kwarg
+                        try:
+                            transcript = (
+                                transcript_list.find_transcript(languages)
+                                .translate(youtube_transcript_languages[0])
+                                .fetch()
+                            )
+                            transcript_text = " ".join([part.text for part in transcript])
+                        except Exception as translation_error:
+                            print(f"Error translating transcript: {translation_error}")
             if transcript_text:
                 webpage_text += f"\n### Transcript\n{transcript_text}\n"
 

packages/markitdown/tests/test_audio_converter.py

@@ -0,0 +1,80 @@
+import io
+from unittest.mock import patch
+
+import pytest
+
+import markitdown.converters._audio_converter
+from markitdown import StreamInfo, DocumentConverter, MissingDependencyException
+
+
+class TestAudioConverter:
+    @pytest.fixture(autouse=True)
+    def setup(self):
+        self.converter = markitdown.converters._audio_converter.AudioConverter()
+
+
+    @pytest.mark.parametrize("input_value, expected_output", [
+        pytest.param(".mp3", True, id=".mp3_extension_case"),
+        pytest.param(".docx", False, id=".docx_extension_case")
+    ])
+    @patch("markitdown._stream_info.StreamInfo")
+    def test_accepts_valid_extension(self, stream_info, input_value, expected_output):
+        stream_info.extension = input_value
+        stream_info.mimetype = "invalid"
+        assert self.converter.accepts(io.BytesIO(), stream_info) == expected_output
+
+    @pytest.mark.parametrize("input_value, expected_output", [
+        pytest.param("audio/mpeg", True, id="audio/mpeg_mimetype_case"),
+        pytest.param("video/mp4", True, id="video/mp4_mimetype_case"),
+        pytest.param("audio/x-wav", True, id="audio/x-wav_mimetype_case"),
+        pytest.param("x-wav", False, id="x-wav_mimetype_case")
+    ])
+    @patch("markitdown._stream_info.StreamInfo")
+    def test_accepts_valid_mimetype(self, stream_info, input_value, expected_output):
+        stream_info.mimetype = input_value
+        assert self.converter.accepts(io.BytesIO(), stream_info) == expected_output
+
+
+    @pytest.mark.parametrize("mimetype, extension, expected_output", [
+        pytest.param("audio/x-wav", ".wav", True, id=".wav_format_case"),
+        pytest.param("audio/mpeg", ".mp3", True, id=".mp3_format_case"),
+        pytest.param("video/mp4", ".mp4", True, id=".mp4_format_case"),
+        pytest.param("test", ".test", True, id="no_format_case")
+    ])
+    @patch("markitdown.converters._audio_converter.exiftool_metadata")
+    @patch("markitdown.converters._audio_converter.transcribe_audio")
+    @patch("markitdown._stream_info.StreamInfo")
+    def test_convert(self, stream_info, mock_transcribe, mock_exif, mimetype, extension, expected_output):
+        mock_exif.return_value = {
+            "Title": "Song",
+            "Artist": "Alice",
+            "SampleRate": 48000,
+        }
+
+        mock_transcribe.return_value = "hello world"
+
+        stream_info.mimetype = mimetype
+        stream_info.extension = extension
+        result = self.converter.convert(io.BytesIO(), stream_info)
+
+        assert "Title: Song" in result.markdown
+        assert "Artist: Alice" in result.markdown
+        assert "SampleRate: 48000" in result.markdown
+
+    @patch("markitdown.converters._audio_converter.transcribe_audio")
+    @patch("markitdown._stream_info.StreamInfo")
+    def test_convert_raises_exception(self, stream_info, mock_transcribe):
+        mock_transcribe.side_effect = MissingDependencyException("dependency not installed")
+        stream_info.mimetype = "audio/mpeg"
+        stream_info.extension =".mp3"
+        file_stream = io.BytesIO(b"dummy audio data")
+
+
+        mock_transcribe.side_effect = MissingDependencyException("missing dependency")
+
+        # ACT
+        result = self.converter.convert(file_stream, stream_info)
+
+        # ASSERT
+        assert "Audio Transcript" not in result.markdown
+        assert result.markdown == ""  # no metadata, no transcript