Publishing for 25.3.4

Author: muhammadumargroupdocs

packages/__init__.py

@@ -2,21 +2,17 @@
 from pathlib import Path
 from openize.markitdown.processor import DocumentProcessor
 
-def run_conversion():
-    processor = DocumentProcessor()
-
-    # Process PDF file
-    # processor.process_document("file.pdf", insert_into_llm=False)
-
-    # Process Word document (.docx)
-    # processor.process_document("example.docx", insert_into_llm=False)
 
-    # Process PowerPoint file (.pptx)
-    # processor.process_document("presentation.pptx", insert_into_llm=False)
 
-    # Process Excel file (.xlsx)
-    # processor.process_document("data.xlsx", insert_into_llm=False)
+def run_conversion(input_file):
+    processor = DocumentProcessor()
+    processor.process_document(input_file, insert_into_llm=False)
+    print(f"Conversion completed: {input_file}")
 
 if __name__ == "__main__":
-    run_conversion()
+    parser = argparse.ArgumentParser(description="Convert documents to Markdown.")
+    parser.add_argument("input_file", type=str, help="Path to the input file")
+    args = parser.parse_args()
+
+    run_conversion(args.input_file)
 

packages/__pycache__/__init__.cpython-312.pyc

@@ -1,6 +1,6 @@
 [metadata]
 name = openize-markitdown
-version = 25.3.2
+version = 25.3.4
 author = Openize
 author_email = packages@openize.com
 description = A document converter for Word, PDF, Excel, and PowerPoint to Markdown.

packages/markitdown/main.py

@@ -6,12 +6,13 @@
 (.docx, .pdf, .xlsx, .pptx) to Markdown format.
 """
 
-__version__ = "0.1.0"
+__version__ = "25.3.4"
 
 from .processor import DocumentProcessor
 from .converters import WordConverter, PDFConverter, ExcelConverter, PowerPointConverter
 from .factory import ConverterFactory
 from .llm_strategy import SaveLocally, InsertIntoLLM
+from .license_manager import LicenseManager
 
 __all__ = [
     'DocumentProcessor',
@@ -22,4 +23,5 @@
     'ConverterFactory',
     'SaveLocally',
     'InsertIntoLLM',
+    'LicenseManager',
 ]

packages/markitdown/setup.cfg

@@ -0,0 +1,17 @@
+import configparser
+
+def get_config():
+    """Reads settings from setup.cfg"""
+    config = configparser.ConfigParser()
+    config.read("../../setup.cfg")
+    return config
+
+def get_license_path():
+    """Fetches Aspose license path from setup.cfg or uses a default."""
+    config = get_config()
+    return config.get("aspose", "license_path", fallback="Aspose.Total.lic")
+
+def use_aspose_license():
+    """Checks if Aspose license should be applied (True/False)."""
+    config = get_config()
+    return config.getboolean("aspose", "use_aspose_license", fallback=True)  # Defaults to True

packages/markitdown/src/openize/markitdown/__init__.py

@@ -5,49 +5,61 @@
 import aspose.words as aw
 import aspose.cells as ac
 import aspose.slides as asl
-from config import Config
-
 
 from abc import ABC, abstractmethod
 
 logging.basicConfig(level=logging.INFO, format='%(asctime)s - %(levelname)s - %(message)s')
 
-
 class DocumentConverter(ABC):
     @abstractmethod
-    def convert_to_md(self, input_path, output_dir): pass
+    def convert_to_md(self, input_path, output_dir):
+        pass
 
     @staticmethod
     def clean_text(text):
-        return re.sub(r"<[^>]*>", "", text).replace("&nbsp;", " ").strip()
+        # Remove HTML tags and normalize spaces
+        text = re.sub(r"<[^>]*>", "", text).replace("&nbsp;", " ").strip()
+        text = re.sub(r"\s+", " ", text)  # Normalize whitespace
+        return text
 
 class WordConverter(DocumentConverter):
     def convert_to_md(self, input_path, output_dir):
         try:
-            doc = aw.Document(str(input_path))
-            output_file = output_dir / (input_path.stem + ".md")
+            doc = aw.Document(input_path.resolve())
+            output_file = output_dir / f"{input_path.stem}.md"
             doc.save(str(output_file), aw.SaveFormat.MARKDOWN)
             return output_file
+        except FileNotFoundError:
+            logging.error(f"File not found: {input_path}")
+        except aw.FileFormatException:
+            logging.error(f"Invalid Word file format: {input_path}")
         except Exception as e:
             logging.error(f"Error converting {input_path}: {e}")
 
 class PDFConverter(DocumentConverter):
     def convert_to_md(self, input_path, output_dir):
         try:
-            doc = aw.Document(str(input_path))
-            output_file = output_dir / (input_path.stem + ".md")
+            doc = aw.Document(input_path.resolve())
+            output_file = output_dir / f"{input_path.stem}.md"
             doc.save(str(output_file), aw.SaveFormat.MARKDOWN)
             return output_file
+        except FileNotFoundError:
+            logging.error(f"File not found: {input_path}")
+        except aw.FileFormatException:
+            logging.error(f"Invalid PDF file format: {input_path}")
         except Exception as e:
             logging.error(f"Error converting {input_path}: {e}")
-
 class ExcelConverter(DocumentConverter):
     def convert_to_md(self, input_path, output_dir):
         try:
             workbook = ac.Workbook(str(input_path))
             output_file = output_dir / (input_path.stem + ".md")
             workbook.save(str(output_file), ac.SaveFormat.MARKDOWN)
             return output_file
+        except FileNotFoundError:
+            logging.error(f"File not found: {input_path}")
+        except ac.CellsException:
+            logging.error(f"Invalid Excel file format: {input_path}")
         except Exception as e:
             logging.error(f"Error converting {input_path}: {e}")
 
@@ -58,6 +70,9 @@ def convert_to_md(self, input_path, output_dir):
             output_file = output_dir / (input_path.stem + ".md")
             presentation.save(str(output_file), asl.export.SaveFormat.MD)
             return output_file
+        except FileNotFoundError:
+            logging.error(f"File not found: {input_path}")
+        except asl.PptxReadException:
+            logging.error(f"Invalid PowerPoint file format: {input_path}")
         except Exception as e:
             logging.error(f"Error converting {input_path}: {e}")
-

packages/markitdown/src/openize/markitdown/config.py

@@ -0,0 +1,32 @@
+import aspose.words as aw
+import aspose.cells as ac
+import aspose.slides as asl
+import logging
+from config_loader import get_license_path, use_aspose_license
+
+class LicenseManager:
+    """Manages the application of Aspose licenses for different file format APIs."""
+
+    def __init__(self):
+        """Initialize LicenseManager with license settings."""
+        self.license_path = get_license_path()
+        self.use_license = use_aspose_license()
+
+    def apply_license(self):
+        """Apply the Aspose license if enabled in setup.cfg."""
+        if not self.use_license:
+            logging.info("Aspose license is disabled in setup.cfg. Running in free mode.")
+            return
+
+        try:
+            license_files = [aw.License(), ac.License(), asl.License()]
+            for license in license_files:
+                license.set_license(self.license_path)
+            logging.info(f"Aspose license applied from {self.license_path}")
+        except Exception as e:
+            logging.warning(f"Failed to apply Aspose license: {e}")
+
+# Usage example:
+# license_manager = LicenseManager()
+# license_manager.apply_license()
+