langchain-ocr-lib 0.1.0__tar.gz

langchain_ocr_lib-0.1.0/PKG-INFO

@@ -0,0 +1,28 @@
+Metadata-Version: 2.3
+Name: langchain-ocr-lib
+Version: 0.1.0
+Summary: 
+License: MIT
+Author: Andreas Klos
+Author-email: aklos@outlook.de
+Requires-Python: >=3.11,<4.0
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Requires-Dist: deprecated (>=1.2.14,<2.0.0)
+Requires-Dist: inject (>=5.2.1,<6.0.0)
+Requires-Dist: langchain-community (>=0.3.19,<0.4.0)
+Requires-Dist: langchain-ollama (>=0.2.0,<0.3.0)
+Requires-Dist: langchain-openai (>=0.3.8,<0.4.0)
+Requires-Dist: langfuse (>=2.59.7,<3.0.0)
+Requires-Dist: openai (>=1.42.0,<2.0.0)
+Requires-Dist: pdf2image (>=1.17.0,<2.0.0)
+Requires-Dist: pillow (>=11.0.0,<12.0.0)
+Requires-Dist: pycountry (>=24.6.1,<25.0.0)
+Requires-Dist: pytest-asyncio (>=0.25.0,<0.26.0)
+Requires-Dist: pyyaml (>=6.0.2,<7.0.0)
+Description-Content-Type: text/markdown
+
+

langchain_ocr_lib-0.1.0/pyproject.toml

@@ -0,0 +1,113 @@
+[build-system]
+requires = ["poetry-core"]
+build-backend = "poetry.core.masonry.api"
+
+[tool.poetry.scripts]
+langchain-ocr = "langchain_ocr_lib.main:main"
+
+[tool.poetry]
+name = "langchain-ocr-lib"
+version = "0.1.0"
+description = ""
+authors = ["Andreas Klos <aklos@outlook.de>"]
+readme = "README.md"
+packages = [{ include = "langchain_ocr_lib", from = "src" }]
+license = "MIT"
+
+[tool.poetry.dependencies]
+python = "^3.11"
+deprecated = "^1.2.14"
+pyyaml = "^6.0.2"
+openai = "^1.42.0"
+pillow = "^11.0.0"
+langchain-ollama = "^0.2.0"
+pytest-asyncio = "^0.25.0"
+langchain-community = "^0.3.19"
+langchain-openai = "^0.3.8"
+langfuse = "^2.59.7"
+pycountry = "^24.6.1"
+pdf2image = "^1.17.0"
+inject = "^5.2.1"
+
+[tool.poetry.group.dev.dependencies]
+debugpy = "^1.8.1"
+pytest = "^8.2.1"
+coverage = "^7.5.4"
+flake8 = "^7.1.0"
+flake8-black = "^0.3.6"
+flake8-pyproject = "^1.2.3"
+flake8-quotes = "^3.4.0"
+flake8-return = "^1.2.0"
+flake8-annotations-complexity = "^0.0.8"
+flake8-bandit = "^4.1.1"
+flake8-bugbear = "^24.8.19"
+flake8-builtins = "^2.5.0"
+flake8-comprehensions = "^3.15.0"
+flake8-eradicate = "^1.5.0"
+flake8-expression-complexity = "^0.0.11"
+flake8-pytest-style = "^2.0.0"
+pep8-naming = "^0.14.1"
+flake8-eol = "^0.0.8"
+flake8-exceptions = "^0.0.1a0"
+flake8-simplify = "^0.21.0"
+flake8-wot = "^0.2.0"
+flake8-function-order = "^0.0.5"
+flake8-tidy-imports = "^4.10.0"
+black = "^23.9.1"
+# flake8-logging-format = "^2024.24.12"
+flake8-docstrings = "^1.7.0"
+
+
+[tool.flake8]
+exclude= [".eggs", ".git", ".hg", ".mypy_cache", ".tox", ".venv", ".devcontainer", "venv", "_build", "buck-out", "build", "dist", "**/__init__.py", "src/langchain_ocr_lib/prompt_templates/ocr_prompt.py"]
+statistics = true
+show-source = false
+max-complexity = 8
+max-annotations-complexity = 3
+docstring-convention = 'numpy'
+max-line-length = 120
+ignore = ["E203", "W503", "E704"]
+inline-quotes = '"'
+docstring-quotes = '"""'
+multiline-quotes = '"""'
+dictionaries = ["en_US", "python", "technical", "pandas"]
+ban-relative-imports = true
+per-file-ignores = """
+
+"""
+
+[tool.black]
+line-length = 120
+exclude = """
+/(
+     .eggs
+    | .git
+    | .hg
+    | .mypy_cache
+    | .nox
+    | .pants.d
+    | .tox
+    | .venv
+    | _build
+    | buck-out
+    | build
+    | dist
+    | node_modules
+    | venv
+)/
+"""
+
+[tool.isort]
+profile = "black"
+skip = ['.eggs', '.git', '.hg', '.mypy_cache', '.nox', '.pants.d', '.tox', '.venv', '_build', 'buck-out', 'build', 'dist', 'node_modules', 'venv']
+skip_gitignore = true
+known_local_folder = ["langchain_ocr_lib"]
+
+[tool.pylint]
+max-line-length = 120
+
+[tool.pytest.ini_options]
+log_cli = 1
+log_cli_level = "DEBUG"
+testpaths = "tests"
+pythonpath = "src"

langchain_ocr_lib-0.1.0/src/langchain_ocr_lib/chains/chain.py

@@ -0,0 +1,55 @@
+"""Module for the base class of chains."""
+
+from abc import ABC, abstractmethod
+from typing import Any, Optional
+
+from langchain_core.runnables import Runnable, RunnableConfig
+from langchain_core.runnables.utils import Input, Output
+
+
+class Chain(Runnable[Input, Output], ABC):
+    """Base class for chains."""
+
+    @abstractmethod
+    async def ainvoke(self, chain_input: Input, config: Optional[RunnableConfig] = None, **kwargs: Any) -> Output:
+        """Asynchronously invoke the chain with the given input and configuration.
+
+        Parameters
+        ----------
+        chain_input : Input
+            The input data required to asynchronously invoke the chain.
+        config : Optional[RunnableConfig], optional
+            The configuration settings for the chain invocation, by default None.
+        **kwargs : Any
+            Additional keyword arguments that may be required for the chain invocation.
+
+        Returns
+        -------
+        Output
+            The result of the chain invocation.
+        """
+
+    @abstractmethod
+    def invoke(self, chain_input: Input, config: Optional[RunnableConfig] = None, **kwargs: Any) -> Output:
+        """
+        Invoke the chain with the given input and configuration.
+
+            Typing indicates `Output` will be the return, but because no implementation is planned,
+            this will never be returned. This method is not implemented and will raise a not implemented error.
+
+        Notes
+        -----
+        This method should never be called. It exists only because the base class requires an implementation.
+
+        Parameters
+        ----------
+        chain_input : Input
+            The input data required to invoke the chain.
+        config : Optional[RunnableConfig], optional
+            The configuration settings for the chain invocation, by default None.
+
+        Returns
+        -------
+        Output
+            The result of the chain invocation.
+        """

langchain_ocr_lib-0.1.0/src/langchain_ocr_lib/converter/converter.py

@@ -0,0 +1,52 @@
+"""Module for the File2MarkdownConverter class."""
+
+from abc import ABC, abstractmethod
+import inject
+
+
+class File2MarkdownConverter(ABC):
+    """Abstract base class for the File2MarkdownConverter class."""
+
+    _chain = inject.attr("LangfuseTracedChain")
+
+    @abstractmethod
+    async def aconvert2markdown(self, file: bytes) -> str:
+        """Asynchronously convert file to markdown format.
+
+        Parameters
+        ----------
+        file : bytes
+            The file to convert.
+
+        Returns
+        -------
+        str
+            The markdown representation of the file.
+
+        Raises
+        ------
+        NotImplementedError
+            If the method is not implemented.
+        """
+        raise NotImplementedError
+
+    @abstractmethod
+    def convert2markdown(self, file: bytes) -> str:
+        """Convert file to markdown format.
+
+        Parameters
+        ----------
+        file : bytes
+            The file to convert.
+
+        Returns
+        -------
+        str
+            The markdown representation of the file.
+
+        Raises
+        ------
+        NotImplementedError
+            If the method is not implemented.
+        """
+        raise NotImplementedError

langchain_ocr_lib-0.1.0/src/langchain_ocr_lib/di_config.py

@@ -0,0 +1,86 @@
+"""Module containing the dependency injection container for managing application dependencies."""
+
+from inject import Binder
+import inject
+from langchain_ollama import ChatOllama
+from langchain_openai import ChatOpenAI
+from langfuse import Langfuse
+
+from langchain_ocr_lib.impl.chains.ocr_chain import OcrChain
+from langchain_ocr_lib.impl.settings.ollama_chat_settings import OllamaSettings
+from langchain_ocr_lib.impl.settings.openai_chat_settings import OpenAISettings
+from langchain_ocr_lib.impl.settings.llm_class_type_settings import LlmClassTypeSettings
+from langchain_ocr_lib.impl.settings.langfuse_settings import LangfuseSettings
+from langchain_ocr_lib.impl.settings.language_settings import LanguageSettings
+from langchain_ocr_lib.impl.tracers.langfuse_traced_chain import LangfuseTracedChain
+from langchain_ocr_lib.prompt_templates.ocr_prompt import ocr_prompt_template_builder
+from langchain_ocr_lib.impl.llms.llm_factory import llm_provider
+from langchain_ocr_lib.impl.langfuse_manager.langfuse_manager import LangfuseManager
+from langchain_ocr_lib.impl.converter.pdf_converter import Pdf2MarkdownConverter
+from langchain_ocr_lib.impl.converter.image_converter import Image2MarkdownConverter
+
+
+def lib_di_config(binder: Binder):
+    """Configure dependency injection bindings for the OCR library.
+
+    Parameters
+    ----------
+    binder : Binder
+        The dependency injection binder instance used to register the bindings.
+
+    Raises
+    ------
+    NotImplementedError
+        If the configured LLM type is not implemented.
+
+    """
+    langfuse_settings = LangfuseSettings()
+    llm_class_type_settings = LlmClassTypeSettings()
+    language_settings = LanguageSettings()
+
+    if llm_class_type_settings.llm_type == "ollama":
+        settings = OllamaSettings()
+        llm_instance = llm_provider(settings, ChatOllama)
+    elif llm_class_type_settings.llm_type == "openai":
+        settings = OpenAISettings()
+        llm_instance = llm_provider(settings, ChatOpenAI)
+    else:
+        raise NotImplementedError("Configured LLM is not implemented")
+    binder.bind("LargeLanguageModel", llm_instance)
+
+    prompt = ocr_prompt_template_builder(language=language_settings.language, model_name=settings.model)
+
+    binder.bind(
+        "LangfuseClient",
+        Langfuse(
+            public_key=langfuse_settings.public_key,
+            secret_key=langfuse_settings.secret_key,
+            host=langfuse_settings.host,
+        ),
+    )
+
+    binder.bind(
+        "LangfuseManager",
+        LangfuseManager(
+            managed_prompts={
+                OcrChain.__name__: prompt,
+            },
+        ),
+    )
+
+    binder.bind("OcrChain", OcrChain())
+
+    binder.bind(
+        "LangfuseTracedChain",
+        LangfuseTracedChain(
+            settings=langfuse_settings,
+        ),
+    )
+
+    binder.bind("PdfConverter", Pdf2MarkdownConverter())
+    binder.bind("ImageConverter", Image2MarkdownConverter())
+
+
+def configure_di():
+    """Configure dependency injection using the `inject` library."""
+    inject.configure(lib_di_config, allow_override=True, clear=True)

langchain_ocr_lib-0.1.0/src/langchain_ocr_lib/impl/chains/ocr_chain.py

@@ -0,0 +1,86 @@
+"""Module for LLM answer generation chain."""
+
+from typing import Any, Optional
+
+from langchain_core.runnables import Runnable, RunnableConfig
+from langchain_core.runnables.utils import Input
+import inject
+
+from langchain_ocr_lib.chains.chain import Chain
+
+RunnableInput = Input  # TODO: adjust properly
+RunnableOutput = str
+
+
+class OcrChain(Chain[RunnableInput, RunnableOutput]):
+    """Base class for LLM answer generation chain."""
+
+    _langfuse_manager = inject.attr("LangfuseManager")
+
+    def __init__(self):
+        """Initialize the AnswerGenerationChain.
+
+        Parameters
+        ----------
+        langfuse_manager : LangfuseManager
+            Manager instance for handling Langfuse operations and monitoring
+        """
+
+    async def ainvoke(
+        self, chain_input: RunnableInput, config: Optional[RunnableConfig] = None, **kwargs: Any
+    ) -> RunnableOutput:
+        """
+        Asynchronously invokes the chain with given input.
+
+        Parameters
+        ----------
+        chain_input : RunnableInput
+            The input to be processed by the chain.
+        chain_config : Optional[RunnableConfig]
+            Configuration for the chain execution (default None).
+        **kwargs : Any
+            Additional keyword arguments passed to the chain.
+
+        Returns
+        -------
+        RunnableOutput
+            The output generated by the chain.
+
+        Raises
+        ------
+        ChainError
+            If an error occurs during chain execution.
+        """
+        return await self._create_chain().ainvoke(chain_input, config=config)
+
+    def invoke(
+        self, chain_input: RunnableInput, config: Optional[RunnableConfig] = None, **kwargs: Any
+    ) -> RunnableOutput:
+        """
+        Invoke the chain with given input.
+
+        Parameters
+        ----------
+        chain_input : RunnableInput
+            The input to be processed by the chain.
+        chain_config : Optional[RunnableConfig]
+            Configuration for the chain execution (default None).
+        **kwargs : Any
+            Additional keyword arguments passed to the chain.
+
+        Returns
+        -------
+        RunnableOutput
+            The output generated by the chain.
+
+        Raises
+        ------
+        ChainError
+            If an error occurs during chain execution.
+        """
+        return self._create_chain().invoke(chain_input, config=config)
+
+    def _create_chain(self) -> Runnable:
+        return self._langfuse_manager.get_base_prompt(self.__class__.__name__) | self._langfuse_manager.get_base_llm(
+            self.__class__.__name__
+        )

langchain_ocr_lib-0.1.0/src/langchain_ocr_lib/impl/converter/image_converter.py

@@ -0,0 +1,88 @@
+"""Module for converting an image to markdown using a Langchain chain."""
+
+import io
+import base64
+from PIL import Image
+from PIL.ImageFile import ImageFile
+
+from langchain_ocr_lib.converter.converter import File2MarkdownConverter
+
+
+class Image2MarkdownConverter(File2MarkdownConverter):
+    """Converts an image to markdown using a Langchain chain."""
+
+    async def aconvert2markdown(self, file: ImageFile | None = None, filename: str | None = None) -> str:
+        """
+        Asynchronously converts an image to markdown using a Langchain chain.
+
+        Parameters
+        ----------
+        file : ImageFile | None, optional
+            PIL Image object to convert, by default None
+        filename : str | None, optional
+            Path to the image file to convert, by default None
+
+        Returns
+        -------
+        str
+            Markdown representation of the image.
+
+        Raises
+        ------
+        ValueError
+            If no file or filename is provided.
+        ValueError
+            If the file is corrupted or the file type is unsupported.
+        """
+        if file is None and filename is None:
+            raise ValueError("No file provided")
+        if file is None:
+            try:
+                file = Image.open(filename)
+            except Exception as e:
+                raise ValueError("Image corrupted or unsupported file type, %s" % e)
+
+        buf = io.BytesIO()
+        file.save(buf, format="PNG")
+        base64_img = base64.b64encode(buf.getvalue()).decode("utf-8")
+        response = await self._chain.ainvoke({"image_data": base64_img})
+
+        return response.content
+
+    def convert2markdown(self, file: ImageFile | None = None, filename: str | None = None) -> str:
+        """
+        Convert an image to markdown using a Langchain chain.
+
+        Parameters
+        ----------
+        file : ImageFile | None, optional
+            PIL Image object to convert, by default None
+        filename : str | None, optional
+            Path to the image file to convert, by default None
+
+        Returns
+        -------
+        str
+            Markdown representation of the image.
+
+        Raises
+        ------
+        ValueError
+            If no file or filename is provided.
+        ValueError
+            If the file is corrupted or the file type is unsupported.
+        """
+        if file is None and filename is None:
+            raise ValueError("No file provided")
+        if file is None:
+            try:
+                file = Image.open(filename)
+            except Exception as e:
+                raise ValueError("Image corrupted or unsupported file type, %s" % e)
+
+        buf = io.BytesIO()
+        file.save(buf, format="PNG")
+        base64_img = base64.b64encode(buf.getvalue()).decode("utf-8")
+        response = self._chain.invoke({"image_data": base64_img})
+
+        return response.content

langchain_ocr_lib-0.1.0/src/langchain_ocr_lib/impl/converter/pdf_converter.py

@@ -0,0 +1,105 @@
+"""Module for converting PDF files to markdown."""
+
+from pdf2image import convert_from_bytes
+import io
+import base64
+
+from langchain_ocr_lib.converter.converter import File2MarkdownConverter
+
+
+class Pdf2MarkdownConverter(File2MarkdownConverter):
+    """Converts PDF files to markdown format.
+
+    This class provides methods to convert PDF files, either provided as bytes or by filename,
+    into markdown format.
+
+    Attributes
+    ----------
+    _chain : Chain
+        The OCR chain used to process images.
+    """
+
+    async def aconvert2markdown(self, file: bytes | None = None, filename: str | None = None) -> str:
+        """Asynchronously converts a PDF file (either provided as bytes or by filename) into markdown.
+
+        Parameters
+        ----------
+        file : bytes, optional
+            The PDF file as bytes. Defaults to None.
+        filename : str, optional
+            The path to the PDF file. Defaults to None.
+
+        Returns
+        -------
+        str
+            The markdown representation of the PDF content extracted via OCR.
+
+        Raises
+        ------
+        ValueError
+            If neither `file` nor `filename` is provided.
+        ValueError
+            If the PDF file is corrupted or the file type is unsupported.
+        """
+        if file is None and filename is None:
+            raise ValueError("No file provided")
+        if file is None:
+            try:
+                with open(filename, "rb") as f:
+                    file = f.read()
+            except Exception as e:
+                raise ValueError("PDF corrupted or unsupported file type, %s" % e)
+
+        images = convert_from_bytes(file)
+
+        markdown = ""
+        for image in images:
+            # Wrap the image in a Document if your chain expects it.
+            buf = io.BytesIO()
+            image.save(buf, format="PNG")
+            base64_img = base64.b64encode(buf.getvalue()).decode("utf-8")
+            response = await self._chain.ainvoke({"image_data": base64_img})
+            markdown += response.content
+        return markdown
+
+    def convert2markdown(self, file: bytes | None = None, filename: str | None = None) -> str:
+        """Convert a PDF file (either provided as bytes or by filename) into markdown.
+
+        Parameters
+        ----------
+        file : bytes, optional
+            The PDF file as bytes. Defaults to None.
+        filename : str, optional
+            The path to the PDF file. Defaults to None.
+
+        Returns
+        -------
+        str
+            The markdown representation of the PDF content extracted via OCR.
+
+        Raises
+        ------
+        ValueError
+            If neither `file` nor `filename` is provided.
+        ValueError
+            If the PDF file is corrupted or the file type is unsupported.
+        """
+        if file is None and filename is None:
+            raise ValueError("No file provided")
+        if file is None:
+            try:
+                with open(filename, "rb") as f:
+                    file = f.read()
+            except Exception as e:
+                raise ValueError("PDF corrupted or unsupported file type") from e
+
+        images = convert_from_bytes(file)
+
+        markdown = ""
+        for image in images:
+            buf = io.BytesIO()
+            image.save(buf, format="PNG")
+            base64_img = base64.b64encode(buf.getvalue()).decode("utf-8")
+            response = self._chain.invoke({"image_data": base64_img})
+            markdown += response.content
+        return markdown