style: apply Black formatting to fix pre-commit checks

- Format all Python files with Black (v23.7.0)
- Fix line length and formatting issues in page extraction feature files
- Ensure consistent code style across the codebase

Author: jeonsworld

packages/markitdown/src/markitdown/__main__.py

@@ -217,8 +217,8 @@ def main():
         )
     else:
         result = markitdown.convert(
-            args.filename, 
-            stream_info=stream_info, 
+            args.filename,
+            stream_info=stream_info,
             keep_data_uris=args.keep_data_uris,
             extract_pages=args.extract_pages,
         )
@@ -229,20 +229,17 @@ def main():
 def _handle_output(args, result: DocumentConverterResult):
     """Handle output to stdout or file"""
     output_content = ""
-    
+
     if args.extract_pages and result.pages and args.pages_json:
         # Output as JSON with page information
         pages_data = [
-            {
-                "page_number": page.page_number,
-                "content": page.content
-            }
+            {"page_number": page.page_number, "content": page.content}
             for page in result.pages
         ]
         output_data = {
             "markdown": result.markdown,
             "title": result.title,
-            "pages": pages_data
+            "pages": pages_data,
         }
         output_content = json.dumps(output_data, ensure_ascii=False, indent=2)
     elif args.extract_pages and result.pages:
@@ -251,15 +248,15 @@ def _handle_output(args, result: DocumentConverterResult):
         output_content += "\n\n" + "=" * 50 + "\n"
         output_content += f"EXTRACTED {len(result.pages)} PAGES:\n"
         output_content += "=" * 50 + "\n\n"
-        
+
         for page in result.pages:
             output_content += f"--- PAGE {page.page_number} ---\n"
             output_content += page.content
             output_content += "\n\n"
     else:
         # Standard output
         output_content = result.markdown
-    
+
     if args.output:
         with open(args.output, "w", encoding="utf-8") as f:
             f.write(output_content)

packages/markitdown/src/markitdown/_base_converter.py

@@ -4,11 +4,11 @@
 
 class PageInfo:
     """Information about a specific page in a document."""
-    
+
     def __init__(self, page_number: int, content: str):
         """
         Initialize page information.
-        
+
         Parameters:
         - page_number: The page number (1-indexed)
         - content: The markdown content of the page

packages/markitdown/src/markitdown/_stream_info.py

@@ -11,9 +11,9 @@ class StreamInfo:
     mimetype: Optional[str] = None
     extension: Optional[str] = None
     charset: Optional[str] = None
-    filename: Optional[
-        str
-    ] = None  # From local path, url, or Content-Disposition header
+    filename: Optional[str] = (
+        None  # From local path, url, or Content-Disposition header
+    )
     local_path: Optional[str] = None  # If read from disk
     url: Optional[str] = None  # If read from url
 

packages/markitdown/src/markitdown/converters/_docx_converter.py

@@ -77,20 +77,22 @@ def convert(
 
         # Check if page extraction is requested
         extract_pages = kwargs.get("extract_pages", False)
-        
+
         style_map = kwargs.get("style_map", None)
         pre_process_stream = pre_process_docx(file_stream)
-        
+
         # Convert to HTML
         html_result = mammoth.convert_to_html(pre_process_stream, style_map=style_map)
-        
+
         # Convert HTML to markdown
         result = self._html_converter.convert_string(html_result.value, **kwargs)
-        
+
         # Note: DOCX files don't have fixed pages like PDFs.
         # Page breaks depend on rendering settings (margins, font size, etc.)
         # For now, we'll return None for pages even if extract_pages is True
         # This maintains API compatibility while acknowledging the limitation
         pages = None
-        
-        return DocumentConverterResult(markdown=result.markdown, title=result.title, pages=pages)
+
+        return DocumentConverterResult(
+            markdown=result.markdown, title=result.title, pages=pages
+        )

packages/markitdown/src/markitdown/converters/_pptx_converter.py

@@ -80,7 +80,7 @@ def convert(
 
         # Check if page extraction is requested
         extract_pages = kwargs.get("extract_pages", False)
-        
+
         # Perform the conversion
         presentation = pptx.Presentation(file_stream)
         md_content = ""
@@ -157,7 +157,9 @@ def get_shape_content(shape, **kwargs):
 
                 # Tables
                 if self._is_table(shape):
-                    slide_content += self._convert_table_to_markdown(shape.table, **kwargs)
+                    slide_content += self._convert_table_to_markdown(
+                        shape.table, **kwargs
+                    )
 
                 # Charts
                 if shape.has_chart:
@@ -200,13 +202,15 @@ def get_shape_content(shape, **kwargs):
                 if notes_frame is not None:
                     slide_content += notes_frame.text
                 slide_content = slide_content.strip()
-            
+
             # Add to overall content
             md_content += slide_content
-            
+
             # If extracting pages, add to pages list
             if extract_pages:
-                pages.append(PageInfo(page_number=slide_num, content=slide_content.strip()))
+                pages.append(
+                    PageInfo(page_number=slide_num, content=slide_content.strip())
+                )
 
         return DocumentConverterResult(markdown=md_content.strip(), pages=pages)
 

packages/markitdown/tests/test_docx_page_extraction.py

@@ -13,112 +13,110 @@
 
 class TestDocxPageExtraction:
     """Test cases for DOCX page extraction functionality."""
-    
+
     @pytest.fixture(autouse=True)
     def setup(self):
         """Set up test fixtures."""
         self.markitdown = MarkItDown()
         self.test_docx_path = os.path.join(
-            os.path.dirname(__file__), 
-            'test_files', 
-            'test.docx'
+            os.path.dirname(__file__), "test_files", "test.docx"
         )
-    
+
     def test_traditional_docx_conversion(self):
         """Test that traditional DOCX conversion works unchanged."""
         if not os.path.exists(self.test_docx_path):
             pytest.skip("Test DOCX file not found")
-        
+
         result = self.markitdown.convert(self.test_docx_path)
-        
+
         # Verify result structure
         assert isinstance(result, DocumentConverterResult)
         assert isinstance(result.markdown, str)
         assert len(result.markdown) > 0
         assert result.pages is None  # Should be None by default
-        
+
         # Verify backward compatibility
-        assert hasattr(result, 'text_content')
+        assert hasattr(result, "text_content")
         assert result.text_content == result.markdown
         assert str(result) == result.markdown
-    
+
     def test_docx_page_extraction_enabled(self):
         """Test DOCX conversion with page extraction enabled.
-        
-        Note: DOCX files don't have fixed pages like PDFs. 
+
+        Note: DOCX files don't have fixed pages like PDFs.
         Page breaks depend on rendering settings. Currently,
         this returns None for pages even with extract_pages=True.
         """
         if not os.path.exists(self.test_docx_path):
             pytest.skip("Test DOCX file not found")
-        
+
         result = self.markitdown.convert(self.test_docx_path, extract_pages=True)
-        
+
         # Verify result structure
         assert isinstance(result, DocumentConverterResult)
         assert isinstance(result.markdown, str)
         assert len(result.markdown) > 0
-        
+
         # Currently, DOCX doesn't support page extraction due to dynamic pagination
         assert result.pages is None
-    
+
     def test_docx_page_extraction_disabled(self):
         """Test DOCX conversion with page extraction explicitly disabled."""
         if not os.path.exists(self.test_docx_path):
             pytest.skip("Test DOCX file not found")
-        
+
         result = self.markitdown.convert(self.test_docx_path, extract_pages=False)
-        
+
         # Should behave the same as default
         assert isinstance(result, DocumentConverterResult)
         assert isinstance(result.markdown, str)
         assert len(result.markdown) > 0
         assert result.pages is None
-    
+
     def test_backward_compatibility(self):
         """Test that all existing functionality remains intact."""
         if not os.path.exists(self.test_docx_path):
             pytest.skip("Test DOCX file not found")
-        
+
         # Test different ways of calling convert
         result1 = self.markitdown.convert(self.test_docx_path)
         result2 = self.markitdown.convert(self.test_docx_path, extract_pages=False)
         result3 = self.markitdown.convert(self.test_docx_path, extract_pages=True)
-        
+
         # Results should be equivalent for markdown content
         assert result1.markdown == result2.markdown
         assert result1.markdown == result3.markdown
         assert result1.title == result2.title
         assert result1.title == result3.title
-        
+
         # All should have None for pages (DOCX limitation)
         assert result1.pages is None
         assert result2.pages is None
         assert result3.pages is None
-        
+
         # All should work with string conversion
         assert str(result1) == str(result2)
         assert str(result1) == str(result3)
-        
+
         # All should work with text_content property
         assert result1.text_content == result2.text_content
         assert result1.text_content == result3.text_content
-    
+
     def test_extract_pages_parameter_types(self):
         """Test different types for extract_pages parameter."""
         if not os.path.exists(self.test_docx_path):
             pytest.skip("Test DOCX file not found")
-        
+
         # Test with different truthy/falsy values
         result_false = self.markitdown.convert(self.test_docx_path, extract_pages=False)
         result_true = self.markitdown.convert(self.test_docx_path, extract_pages=True)
         result_none = self.markitdown.convert(self.test_docx_path, extract_pages=None)
         result_zero = self.markitdown.convert(self.test_docx_path, extract_pages=0)
         result_one = self.markitdown.convert(self.test_docx_path, extract_pages=1)
-        
+
         # All should return None for pages (DOCX limitation)
         assert result_false.pages is None
         assert result_true.pages is None
         assert result_none.pages is None
         assert result_zero.pages is None
-        assert result_one.pages is None
+        assert result_one.pages is None