markitdown-pro 0.1.0__py3-none-any.whl

markitdown_pro/handlers/tabular_handler.py

@@ -0,0 +1,34 @@
+import os
+
+import pandas as pd
+
+from ..common.logger import logger
+from ..common.utils import ensure_minimum_content
+from .base_handler import BaseHandler
+
+
+class TabularHandler(BaseHandler):
+    """Handler for .csv, .tsv, .xls, .xlsx files."""
+
+    extensions = frozenset([".csv", ".tsv", ".xls", ".xlsx"])
+
+    async def handle(self, file_path: str, *args, **kwargs) -> str:
+        logger.info(f"Processing tabular file: {file_path}")
+        try:
+            ext = os.path.splitext(file_path)[1].lower()
+            if ext in [".csv", ".tsv"]:
+                delimiter = "\t" if ext == ".tsv" else ","
+                df = pd.read_csv(file_path, delimiter=delimiter)
+            elif ext in [".xls", ".xlsx"]:
+                df = pd.read_excel(file_path)
+            else:
+                raise RuntimeError("Unsupported tabular format")
+            md = df.to_markdown(index=False)
+
+            if ensure_minimum_content(md):
+                return md
+            else:
+                raise RuntimeError(f"Insufficient content after conversion: {file_path}")
+        except Exception as e:
+            logger.error(f"Error processing tabular file {file_path}: {e}")
+            raise

markitdown_pro/handlers/text_handler.py

@@ -0,0 +1,38 @@
+import os
+
+import chardet
+
+from ..common.logger import logger
+from ..common.utils import clean_markdown, ensure_minimum_content
+from .base_handler import BaseHandler
+
+
+class TextHandler(BaseHandler):
+    """Handler for .txt, .md, .py, .go, and other text/code files."""
+
+    extensions = frozenset([".txt", ".md", ".py", ".go"])
+
+    async def handle(self, file_path: str, *args, **kwargs) -> str:
+        logger.info(f"Processing text file: {file_path}")
+        try:
+            with open(file_path, "rb") as f:
+                raw_data = f.read()
+                result = chardet.detect(raw_data)
+                encoding = result["encoding"] or "utf-8"
+                logger.debug(f"Detected encoding: {encoding}")
+                content = raw_data.decode(encoding, errors="replace")
+
+            ext = os.path.splitext(file_path)[1].lower()
+            if ext == ".md":
+                content = clean_markdown(content)
+
+            if ensure_minimum_content(content):
+                return content
+            else:
+                raise RuntimeError(
+                    f"Insufficient content. Content length is {len(content)} characters."
+                )
+        except Exception as e:
+            file_name = os.path.basename(file_path)
+            logger.error(f"Error processing text file {file_name}: {e}")
+            raise

markitdown_pro/services/azure_service.py

@@ -0,0 +1,160 @@
+import logging
+import os
+from pathlib import Path
+from typing import Optional
+
+import azure.cognitiveservices.speech as speechsdk
+from azure.ai.documentintelligence import DocumentIntelligenceClient
+from azure.ai.documentintelligence.models import DocumentAnalysisFeature
+from azure.ai.documentintelligence.models import DocumentContentFormat as ContentFormat
+from azure.core.credentials import AzureKeyCredential
+
+from ..common.logger import logger
+from ..common.utils import clean_markdown, ensure_minimum_content
+
+
+class AzureServices:
+    def __init__(self=None):
+        self.azure_doc_client = None
+        self.azure_speech_config = None
+        self.azure_speech_voice_name = "en-US-AndrewMultilingualNeural"
+        self._initialize_azure_services()
+
+    def _initialize_azure_services(self):
+
+        # Initialize Azure Document Intelligence client
+        azure_docint_endpoint = os.getenv("AZURE_DOCINTEL_ENDPOINT", "")
+        azure_docint_key = os.getenv("AZURE_DOCINTEL_KEY", "")
+        if azure_docint_endpoint and azure_docint_key:
+            try:
+                self.azure_doc_client = DocumentIntelligenceClient(
+                    endpoint=azure_docint_endpoint,
+                    credential=AzureKeyCredential(azure_docint_key),
+                )
+            except Exception as e:
+                logging.warning(f"Failed to initialize Azure Document Intelligence client: {e}")
+
+        azure_speech_key = os.getenv("AZURE_SPEECH_KEY", "")
+        azure_speech_region = os.getenv("AZURE_SPEECH_REGION", "")
+        if azure_speech_key and azure_speech_region:
+            try:
+                self.azure_speech_config = speechsdk.SpeechConfig(
+                    subscription=azure_speech_key, region=azure_speech_region
+                )
+            except Exception as e:
+                logging.warning(f"Failed to initialize Azure Speech Service configuration: {e}")
+
+    def process_azure_doc_intelligence(self, file_path: str) -> Optional[str]:
+        """
+        Convert a document to Markdown using Azure Document Intelligence.
+        """
+        if not self.azure_doc_client:
+            logger.info("Azure Document Intelligence client not configured, skipping conversion.")
+            return None
+
+        logger.info(f"Attempting Azure Document Intelligence conversion on '{file_path}'")
+        try:
+            with open(file_path, "rb") as f:
+                file_data = f.read()
+
+            # Detect file extension
+            extension = Path(file_path).suffix.lower()
+            if extension not in [".docx", ".xlsx", ".pptx"]:
+                features = [DocumentAnalysisFeature.LANGUAGES]
+            else:
+                features = []
+
+            poller = self.azure_doc_client.begin_analyze_document(
+                model_id="prebuilt-layout",
+                body=file_data,
+                content_type="application/octet-stream",
+                features=features,
+                output_content_format=ContentFormat.MARKDOWN,
+            )
+            result = poller.result(timeout=120)
+
+            if hasattr(result, "content"):
+                content = result.content or ""
+
+            else:
+                # Fallback for older API responses
+                lines = []
+                for page in result.pages:
+                    for line in page.lines:
+                        lines.append(line.content)
+                content = "\n".join(lines)
+
+            final_md = clean_markdown(content)
+            if ensure_minimum_content(final_md):
+                return final_md
+
+            logger.info("Azure Document Intelligence conversion returned insufficient content.")
+            return None
+
+        except Exception as e:
+            logger.error(f"Error during Azure Document Intelligence conversion: {e}")
+            return None
+
+    async def recognize_azure_speech_to_text_from_file(self, file_path: str) -> Optional[str]:
+        """
+        Recognize speech from an audio file with automatic language detection
+        across the top 6 spoken languages globally.
+
+        Args:
+            file_path (str): Path to the audio file.
+
+        Returns:
+            Optional[str]: Transcribed text if successful, None otherwise.
+        """
+        if not self.azure_speech_config:
+            logging.info("Azure Speech Service not configured, skipping speech recognition.")
+            return None
+
+        try:
+            audio_config = speechsdk.AudioConfig(filename=file_path)
+            languages = ["en-US", "zh-CN", "hi-IN", "es-ES"]
+
+            # Configure auto language detection with the specified languages
+            auto_detect_source_language_config = (
+                speechsdk.languageconfig.AutoDetectSourceLanguageConfig(languages=languages)
+            )
+
+            # Create a speech recognizer with the auto language detection configuration
+            speech_recognizer = speechsdk.SpeechRecognizer(
+                speech_config=self.azure_speech_config,
+                audio_config=audio_config,
+                auto_detect_source_language_config=auto_detect_source_language_config,
+            )
+
+            # Perform speech recognition
+            result = await speech_recognizer.recognize_once_async()
+
+            # Check the result
+            if result.reason == speechsdk.ResultReason.RecognizedSpeech:
+                # Retrieve the detected language
+                detected_language = result.properties.get(
+                    speechsdk.PropertyId.SpeechServiceConnection_AutoDetectSourceLanguageResult,
+                    "Unknown",
+                )
+                logging.debug(f"Detected Language {detected_language}")
+                return result.text
+
+            elif result.reason == speechsdk.ResultReason.NoMatch:
+                logging.warning("No speech could be recognized from the audio.")
+                return None
+
+            elif result.reason == speechsdk.ResultReason.Canceled:
+                cancellation_details = speechsdk.CancellationDetails(result)
+                logging.error(
+                    f"Speech Recognition canceled: {cancellation_details.reason}. "
+                    f"Error details: {cancellation_details.error_details}"
+                )
+                return None
+
+            else:
+                logging.error("Unknown error occurred during speech recognition.")
+                return None
+
+        except Exception as e:
+            logging.error(f"An error occurred during speech recognition: {e}")
+            return None

markitdown_pro/services/openai_services.py

@@ -0,0 +1,209 @@
+import asyncio
+import base64
+
+# import concurrent.futures
+import mimetypes
+import os
+import re
+import tempfile
+from pathlib import Path
+from typing import Optional, Tuple
+
+import fitz
+from langchain_core.messages import HumanMessage
+from langchain_openai import AzureChatOpenAI
+from PIL import Image as PILImage
+
+from ..common.logger import logger
+from ..common.utils import clean_markdown, ensure_minimum_content
+
+
+class GPT4oMiniVision:
+    def __init__(self=None):
+        azure_key = os.getenv("AZURE_OPENAI_API_KEY")
+        api_version = os.getenv("AZURE_OPENAI_API_VERSION")
+
+        GPT4OMINI_DEPLOYMENT_NAME: str = os.getenv("GPT4oMINI_DEPLOYMENT_NAME", "")
+        COMPLETION_TOKENS: int = 4096
+
+        self.client = None
+        if GPT4OMINI_DEPLOYMENT_NAME:
+            try:
+                from pydantic import BaseModel
+
+                class ImageSchema(BaseModel):
+                    ocr: str
+                    analysis: str
+
+                llm = AzureChatOpenAI(
+                    deployment_name=GPT4OMINI_DEPLOYMENT_NAME,
+                    temperature=0,
+                    max_tokens=COMPLETION_TOKENS,
+                    streaming=False,
+                    api_version=api_version,
+                    api_key=azure_key,
+                    cache=False,
+                )
+                self.client = llm.with_structured_output(ImageSchema)
+                logger.info("GPT-4o-mini client initialized successfully.")
+            except Exception as e:
+                logger.warning(f"Failed to initialize GPT-4o-mini client: {e}")
+                self.client = None
+
+    def _build_image_url_block(self, file_or_url: str) -> dict:
+        if isinstance(file_or_url, Path):
+            file_or_url = str(file_or_url)
+
+        # If the input is a URL, return it as an image_url block
+        if re.match(r"^https?://", file_or_url, re.IGNORECASE):
+            return {
+                "type": "image_url",
+                "image_url": {"url": file_or_url},
+            }
+
+        path = Path(file_or_url)
+        if not path.is_file():
+            raise ValueError(f"Local file not found: {file_or_url}")
+
+        try:
+            content_type, _ = mimetypes.guess_type(file_or_url)
+            if not content_type:
+                content_type = "image/jpeg"
+                logger.warning(
+                    f"Could not determine content type for {file_or_url}, defaulting to image/jpeg"
+                )
+
+            # Convert the image to JPEG and encode it in Base64
+            img = PILImage.open(file_or_url)
+            with tempfile.NamedTemporaryFile(suffix=".jpg", delete=False) as tmp_file:
+                img.convert("RGB").save(tmp_file.name, "JPEG")
+                jpeg_path = tmp_file.name
+
+            with open(jpeg_path, "rb") as f:
+                b64_data = base64.b64encode(f.read()).decode("utf-8")
+
+            os.unlink(jpeg_path)  # Delete the temporary JPEG file
+
+            return {
+                "type": "image_url",
+                "image_url": {"url": f"data:{content_type};base64,{b64_data}"},
+            }
+        except Exception as e:
+            logger.error(f"Error building image block for {file_or_url}: {e}")
+            raise
+
+    async def process_image(self, file_or_url: str, prompt: Optional[str] = None) -> Optional[str]:
+        if not prompt:
+            prompt = (
+                "Perform accurate OCR: answer with the markdown of the content of the image. Visually appealing markdown, nothing else. "
+                "Perform Image Analysis: answer with a two line image analysis explaining what you see."
+            )
+
+        try:
+            image_block = self._build_image_url_block(file_or_url)
+            message_content = [
+                {"type": "text", "text": prompt},
+                image_block,
+            ]
+            message = HumanMessage(content=message_content)
+            response = self.client.invoke([message])
+            md_content = clean_markdown(response.analysis)
+            md_content += "\n\n" + clean_markdown(response.ocr)
+
+            return md_content if ensure_minimum_content(md_content) else None
+        except Exception as e:
+            logger.error(f"process_image: Error during GPT-4o-mini image OCR: {e}")
+            return None
+
+    async def process_scanned_pdf_concurrent(self, file_path: str) -> Optional[str]:
+        if not self.client:
+            return None
+
+        try:
+            doc = fitz.open(file_path)
+            num_pages = doc.page_count
+            results = []
+
+            async def ocr_page(page_index: int) -> Tuple[int, str]:
+                try:
+                    page = doc.load_page(page_index)
+                    pix = page.get_pixmap(dpi=150)
+
+                    fd, png_path = tempfile.mkstemp(prefix=f"{page_index:3}-", suffix=".png")
+                    os.close(fd)
+                    pix.save(png_path)
+
+                    try:
+                        file_name = os.path.basename(file_path)
+                        partial_md = await self.process_image(png_path)
+                        if partial_md:
+                            logger.debug(
+                                f"ocr_page: {file_name} - page {page_index}: returned {len(partial_md)} characters"
+                            )
+                        else:
+                            logger.warning(
+                                f"ocr_page: {file_name} - page {page_index}: no OCR result"
+                            )
+                            partial_md = "[No OCR result]"
+                        return (page_index, f"## Page {page_index + 1}\n\n{partial_md}")
+                    finally:
+                        try:
+                            if os.path.exists(png_path):
+                                # Remove the temporary PNG file after processing
+                                logger.debug(f"Removing temporary PNG file: {png_path}")
+                                Path(png_path).unlink(missing_ok=True)
+                        except Exception as e:
+                            logger.error(f"ocr_page: Error removing temporary PNG file: {e}")
+                except Exception as e:
+                    logger.error(f"ocr_page: Error processing page {page_index}: {e}")
+                    return (page_index, None)
+
+            logger.info(
+                f"process_scanned_pdf_concurrent: Starting concurrent GPT-4o-mini OCR on PDF: '{file_path}'"
+            )
+
+            # run tasks concurrently
+            tasks = [ocr_page(i) for i in range(num_pages)]
+            results = await asyncio.gather(*tasks)
+
+            combined_md = clean_markdown("\n\n".join(block for _, block in results))
+            return combined_md if ensure_minimum_content(combined_md) else None
+
+        except Exception as e:
+            logger.error(f"Concurrent GPT-4o-mini OCR error for PDF {file_path}: {e}")
+            return None
+
+    async def process_scanned_pdf_simple(self, file_path: str) -> Optional[str]:
+        if not self.client:
+            return None
+
+        try:
+            doc = fitz.open(file_path)
+            all_md_blocks = []
+
+            logger.info(f"Starting simple GPT-4o-mini OCR on PDF: '{file_path}'")
+            for i in range(doc.page_count):
+                page = doc.load_page(i)
+                pix = page.get_pixmap(dpi=150)
+                with tempfile.NamedTemporaryFile(suffix=".png", delete=False) as tmp_file:
+                    png_path = tmp_file.name
+                    pix.save(png_path)
+                try:
+                    partial_md = await self.process_image(png_path)
+                    if partial_md:
+                        block = f"## Page {i + 1}\n\n{partial_md}"
+                    else:
+                        block = f"## Page {i + 1}\n\n[No OCR result]"
+                    all_md_blocks.append(block)
+                finally:
+                    try:
+                        Path(png_path).unlink(missing_ok=True)
+                    except Exception as e:
+                        logger.error(f"Error removing temporary PNG file in simple OCR: {e}")
+
+            combined_md = clean_markdown("\n\n".join(all_md_blocks))
+            return combined_md if ensure_minimum_content(combined_md) else None
+
+        except Exception as e:
+            logger.error(f"Simple GPT-4o-mini OCR error for PDF {file_path}: {e}")
+            return None