HowdenParser 0.1.13__tar.gz → 0.1.15__tar.gz

howdenparser-0.1.15/HowdenParser/__init__.py

@@ -0,0 +1,3 @@
+from .parser import Parser
+
+__all__ = ["Parser"]

howdenparser-0.1.15/HowdenParser/parameter/__init__.py

@@ -0,0 +1,3 @@
+from .huggingface import Parameter as HuggingfaceParameter
+from .mistralocr import Parameter as MistralocrParameter
+from .llamaparser import Parameter as LlamaparserParameter

howdenparser-0.1.15/HowdenParser/parser.py

@@ -0,0 +1,173 @@
+from abc import ABC, abstractmethod
+import os
+import logging
+from pathlib import Path
+from PyPDF2 import PdfReader
+import dotenv
+
+dotenv.load_dotenv()
+
+
+class BaseParser(ABC):
+    _registry: dict[str, type["BaseParser"]] = {}
+
+    def __init_subclass__(cls, name: str | None = None, **kwargs):
+        """Automatically register subclasses under a key."""
+        super().__init_subclass__(**kwargs)
+        key = name or cls.__name__.lower().replace("parser", "")
+        BaseParser._registry[key] = cls
+        BaseParser._registry.pop("", None)
+
+    @abstractmethod
+    def parse(self, text: str):
+        pass
+
+
+class Parser(BaseParser):
+    """Factory + registry interface for all parsers."""
+
+    @classmethod
+    def available_parsers(cls) -> dict[str, list[str]]:
+        """Return registered parsers and their init arguments."""
+        import inspect
+        result = {}
+        for name, parser_cls in BaseParser._registry.items():
+            sig = inspect.signature(parser_cls.__init__)
+            result[name] = [p for p in sig.parameters if p != "self"]
+        result.pop('', None)
+        return result
+
+    @classmethod
+    def create(cls, config: dict | None = None, **kwargs) -> BaseParser:
+        provider = kwargs["provider_and_model"].split(":")[0].lower()
+        model = kwargs["provider_and_model"].split(":")[1].lower()
+        if provider not in BaseParser._registry:
+            raise ValueError(f"Unknown parser '{provider}'. "
+                             f"Available: {cls.available_parsers()}")
+
+        parser_cls = BaseParser._registry[provider]
+        import inspect
+        merged_args = {**(config or {}), **kwargs}
+        if "model" in inspect.signature(parser_cls.__init__).parameters:
+            merged_args["model"] = model
+
+        # Remove keys not in constructor
+        sig = inspect.signature(parser_cls.__init__)
+        valid_args = {k: v for k, v in merged_args.items() if k in sig.parameters and k != "self"}
+
+        return parser_cls(**valid_args)
+
+
+
+
+    @abstractmethod
+    def parse(self, text: str):
+        pass
+
+
+# --- Parsers ---
+class MistralOCRParser(BaseParser, name="mistralocr"):
+    def __init__(self,provider_and_model:str) -> None:
+        from mistralai import Mistral
+
+        self.model = provider_and_model.split(":")[1]
+        self.current_cost: float = 0.0
+        self.total_cost_euro: float = 0.0
+
+        api_key = os.getenv("MISTRAL-OCR-API-TOKEN")
+        if not api_key:
+            raise EnvironmentError("Missing MISTRAL-OCR-API-TOKEN in .env file.")
+
+        self.client = Mistral(api_key=api_key)
+
+    def parse(self, file_path: Path) -> str:
+        def upload_pdf(filename):
+            uploaded_pdf = self.client.files.upload(
+                file={"file_name": filename, "content": open(filename, "rb")},
+                purpose="ocr"
+            )
+            signed_url = self.client.files.get_signed_url(file_id=uploaded_pdf.id)
+            return signed_url.url
+
+        ocr_response = self.client.ocr.process(
+            model=self.model,
+            document={"type": "document_url", "document_url": upload_pdf(file_path)},
+            include_image_base64=True,
+        )
+
+        self.current_cost = 1 / 1000 * self._count_pages(file_path)
+        self.total_cost_euro += self.current_cost
+
+        return "\n".join(doc.markdown for doc in ocr_response.pages)
+
+    @staticmethod
+    def _count_pages(file_path: Path) -> int:
+        reader = PdfReader(str(file_path))
+        return len(reader.pages)
+
+
+class LangChainParser(BaseParser, name="langchain"):
+    def __init__(self, model: str):
+        from langchain.llms import OpenAI
+        self.model_name = model
+        self.model = OpenAI(model_name=model)
+
+    def parse(self, text: str) -> dict:
+        response = self.model(text)
+        return {"source": "LangChain", "output": response}
+
+
+class LlamaParser(BaseParser, name="llamaparser"):
+    def __init__(self, result_type: str, mode: bool) -> None:
+        logging.info("Initializing LlamaParser...")
+
+        from llama_parse import LlamaParse, ResultType
+
+        if result_type.lower() in ("md", "markdown"):
+            self.result_type = ResultType.MD
+
+        api_key = os.getenv("LLAMA-PARSER-API-TOKEN")
+        if not api_key:
+            raise EnvironmentError("Missing LLAMA-PARSER-API-TOKEN in .env file.")
+
+        self.parser = LlamaParse(api_key=api_key, result_type=self.result_type, premium_mode=mode)
+
+    def parse(self, file_path: Path) -> str:
+        documents = self.parser.load_data(str(file_path))
+        return "\n".join(doc.text for doc in documents)
+
+
+class HuggingFaceParser(BaseParser, name="huggingface"):
+    def __init__(self, model: str, result_type: str) -> None:
+        from transformers import pipeline
+
+        if result_type.lower() in ("md", "markdown"):
+            self.result_type = "markdown"
+        else:
+            self.result_type = "text"
+
+        api_key = os.getenv("HF-API-TOKEN")
+        if not api_key:
+            raise EnvironmentError("Missing HF-API-TOKEN in .env file.")
+
+        self.parser = pipeline(
+            task="document-question-answering",
+            model=model,
+            use_auth_token=api_key
+        )
+
+    def parse(self, file_path: Path) -> str:
+        import fitz
+        pdf_doc = fitz.open(file_path)
+        output_parts = []
+
+        for page in pdf_doc:
+            pix = page.get_pixmap(dpi=200)
+            img_bytes = pix.tobytes("png")
+            response = self.parser(img_bytes, question="Extract all text")
+            if response and "answer" in response[0]:
+                output_parts.append(response[0]["answer"])
+
+        return "\n\n".join(output_parts) if self.result_type == "markdown" else " ".join(output_parts)
+
+

{howdenparser-0.1.13 → howdenparser-0.1.15}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: HowdenParser
-Version: 0.1.13
+Version: 0.1.15
 Summary: A simple configuration manager with Pydantic and JSON export.
 License: MIT
 Keywords: config,configuration,pydantic,json

{howdenparser-0.1.13 → howdenparser-0.1.15}/pyproject.toml

@@ -14,7 +14,7 @@ build-backend = "poetry.core.masonry.api"
 
 [tool.poetry]
 name = "HowdenParser"
-version = "0.1.13"
+version = "0.1.15"
 description = "A simple configuration manager with Pydantic and JSON export."
 authors = [ "JesperThoftIllemannJ <jesper.jaeger@howdendanmark.dk>",]
 readme = "README.md"

howdenparser-0.1.13/HowdenParser/__init__.py

@@ -1,3 +0,0 @@
-from .parser import ParserFactory
-
-__all__ = ["ParserFactory"]

howdenparser-0.1.13/HowdenParser/parameter/__init__.py

@@ -1,15 +0,0 @@
-import os
-import importlib
-
-# Get all .py files in this folder except __init__.py
-current_dir = os.path.dirname(__file__)
-for filename in os.listdir(current_dir):
-    if filename.endswith(".py") and filename != "__init__.py":
-        module_name = filename[:-3]  # remove .py
-        module = importlib.import_module(f".{module_name}", package=__name__)
-
-        # Add all classes from the module to the package namespace
-        for attr_name in dir(module):
-            attr = getattr(module, attr_name)
-            if isinstance(attr, type):  # only classes
-                globals()[attr_name] = attr

howdenparser-0.1.13/HowdenParser/parser.py

@@ -1,159 +0,0 @@
-from abc import ABC, abstractmethod
-from dotenv import load_dotenv
-import os
-from pathlib import Path
-import logging
-from PyPDF2 import PdfReader
-
-load_dotenv()
-
-class BaseParser(ABC):
-    @abstractmethod
-    def parse(self, text: str) -> dict:
-        pass
-
-
-class MistralOCRParser(BaseParser):
-    def __init__(self, model: str) -> None:
-        from mistralai import Mistral
-        self.model = model
-        self.current_cost: float = 0.0
-        self.total_cost_euro: float = 0.0
-
-        name = "MISTRAL-OCR-API-TOKEN"
-        api_key = os.getenv(name)
-        if not api_key:
-            raise EnvironmentError(f"Missing {name} in .env file.")
-
-        self.client = Mistral(api_key=api_key)
-
-    def parse(self, file_path: Path) -> str:
-        def upload_pdf(filename):
-            uploaded_pdf = self.client.files.upload(
-            file={
-            "file_name": filename,
-                "content": open(filename, "rb"),
-            },
-            purpose="ocr"
-            )
-            signed_url = self.client.files.get_signed_url(file_id=uploaded_pdf.id)
-            return signed_url.url
-
-        ocr_response = self.client.ocr.process(
-            model=self.model,
-            document={
-            "type": "document_url",
-            "document_url": upload_pdf(file_path),
-            },
-            include_image_base64=True,
-            )
-
-        self.current_cost = 1/1000 * self._count_pages(file_path)
-        self.total_cost_euro += self.current_cost
-
-        return "\n".join(doc.markdown for doc in ocr_response.pages)
-
-    @staticmethod
-    def _count_pages(file_path: Path) -> int:
-        reader = PdfReader(str(file_path))
-        return len(reader.pages)
-
-
-
-class LangChainParser(BaseParser):
-    def __init__(self, model: str):
-        from langchain.llms import OpenAI
-        self.model_name = model
-        self.model = OpenAI(model_name=model)
-
-    def parse(self, text: str) -> dict:
-        response = self.model(text)
-        return {"source": "LangChain", "output": response}
-
-
-class LlamaParser(BaseParser):
-    def __init__(self, result_type: str, mode: bool) -> None:
-        logging.info("Initializing LlamaParser...")
-        logging.info("Loading LlamaParse package...")
-
-        from llama_parse import LlamaParse, ResultType
-
-        if result_type.lower() == "md" or result_type.lower() == "markdown":
-            self.result_type = ResultType.MD
-
-        name = "LLAMA-PARSER-API-TOKEN"
-        api_key = os.getenv(name)
-        if not api_key:
-            raise EnvironmentError(f"Missing {name} in .env file.")
-
-        logging.info("Initializing LlamaParse parser...")
-        self.parser = LlamaParse(
-            api_key=api_key,
-            result_type=self.result_type,
-            premium_mode=mode
-        )
-        logging.info("LlamaParser initialized successfully.")
-
-    def parse(self, file_path: Path) -> str:
-        logging.info(f"Parsing file: {file_path}")
-        documents = self.parser.load_data(str(file_path))
-        text = "\n".join(doc.text for doc in documents)
-        logging.info(f"Parsing completed. Extracted {len(documents)} documents.")
-        return text
-
-class HuggingFaceParser(BaseParser):
-    def __init__(self, model: str, result_type: str) -> None:
-        from transformers import pipeline
-
-        if result_type.lower() in ("md", "markdown"):
-            self.result_type = "markdown"
-        else:
-            self.result_type = "text"
-
-        name = "HF-API-TOKEN"
-        self.api_key = os.getenv(name)
-        if not self.api_key:
-            raise EnvironmentError(f"Missing {name} in .env file.")
-
-        # Example model: microsoft/layoutlmv3-base-finetuned-docvqa
-        self.parser = pipeline(
-            task="document-question-answering",
-            model=model,
-            use_auth_token=self.api_key
-        )
-
-    def parse(self, file_path: Path) -> str:
-        import fitz
-
-        pdf_doc = fitz.open(file_path)
-        output_parts = []
-
-        for page in pdf_doc:
-            pix = page.get_pixmap(dpi=200)
-            img_bytes = pix.tobytes("png")
-            response = self.parser(img_bytes, question="Extract all text")
-            if response and "answer" in response[0]:
-                output_parts.append(response[0]["answer"])
-
-        if self.result_type == "markdown":
-            return "\n\n".join(output_parts)
-        else:
-            return " ".join(output_parts)
-
-# === Step 3: Dynamic factory using string input ===
-class ParserFactory:
-    @staticmethod
-    def get_parser(provider_model: str, **kwargs) -> BaseParser:
-        provider = provider_model.partition(":")[0].lower()
-        model = provider_model.partition(":")[2]
-        if provider == "langchain":
-            return LangChainParser(model=model)
-        elif provider == "llamaparser":
-            return LlamaParser(kwargs["result_type"], kwargs["mode"])
-        elif provider == "huggingface":
-            return HuggingFaceParser(model=model, **kwargs)
-        elif provider == "mistralocr":
-            return MistralOCRParser(model)
-        else:
-            raise ValueError(f"Unknown parser type: {provider_model}")
-