PyPI - docling-core - Versions diffs - 2.5.1__tar.gz → 2.6.0__tar.gz - Mend

docling-core 2.5.1tar.gz → 2.6.0tar.gz

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Potentially problematic release.

This version of docling-core might be problematic. Click here for more details.

Files changed (57) hide show

{docling_core-2.5.1 → docling_core-2.6.0}/PKG-INFO RENAMED Viewed

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: docling-core
-Version: 2.5.1
+Version: 2.6.0
 Summary: A python library to define and validate data types in Docling.
 Home-page: https://ds4sd.github.io/
 License: MIT
@@ -32,6 +32,7 @@ Requires-Dist: pillow (>=10.3.0,<11.0.0)
 Requires-Dist: pydantic (>=2.6.0,<2.10)
 Requires-Dist: pyyaml (>=5.1,<7.0.0)
 Requires-Dist: tabulate (>=0.9.0,<0.10.0)
+Requires-Dist: typing-extensions (>=4.12.2,<5.0.0)
 Project-URL: Repository, https://github.com/DS4SD/docling-core
 Description-Content-Type: text/markdown

{docling_core-2.5.1 → docling_core-2.6.0}/docling_core/types/doc/document.py RENAMED Viewed

@@ -810,14 +810,8 @@ class PictureItem(FloatingItem):
             ):
                 return default_response
-            if (
-                isinstance(self.image.uri, AnyUrl) and self.image.uri.scheme == "file"
-            ) or isinstance(self.image.uri, Path):
-                text = f"\n![Image]({str(self.image.uri)})\n"
-                return text
-            else:
-                return default_response
+            text = f"\n![Image]({str(self.image.uri)})\n"
+            return text
         else:
             return default_response
@@ -870,14 +864,8 @@ class PictureItem(FloatingItem):
             ):
                 return default_response
-            if (
-                isinstance(self.image.uri, AnyUrl) and self.image.uri.scheme == "file"
-            ) or isinstance(self.image.uri, Path):
-                img_text = f'<img src="{str(self.image.uri)}">'
-                return f"<figure>{caption_text}{img_text}</figure>"
-            else:
-                return default_response
+            img_text = f'<img src="{str(self.image.uri)}">'
+            return f"<figure>{caption_text}{img_text}</figure>"
         else:
             return default_response
@@ -1211,19 +1199,58 @@ class DoclingDocument(BaseModel):
     """DoclingDocument."""
     _HTML_DEFAULT_HEAD: str = r"""<head>
+    <link rel="icon" type="image/png"
+    href="https://ds4sd.github.io/docling/assets/logo.png"/>
     <meta charset="UTF-8">
+    <title>
+    Powered by Docling
+    </title>
     <style>
+    html {
+    background-color: LightGray;
+    }
+    body {
+    margin: 0 auto;
+    width:800px;
+    padding: 30px;
+    background-color: White;
+    font-family: Arial, sans-serif;
+    box-shadow: 10px 10px 10px grey;
+    }
+    figure{
+    display: block;
+    width: 100%;
+    margin: 0px;
+    margin-top: 10px;
+    margin-bottom: 10px;
+    }
+    img {
+    display: block;
+    margin: auto;
+    margin-top: 10px;
+    margin-bottom: 10px;
+    max-width: 640px;
+    max-height: 640px;
+    }
     table {
-    border-collapse: separate;
-    /* Maintain separate borders */
-    border-spacing: 5px; /*
-    Space between cells */
-    width: 50%;
+    min-width:500px;
+    background-color: White;
+    border-collapse: collapse;
+    cell-padding: 5px;
+    margin: auto;
+    margin-top: 10px;
+    margin-bottom: 10px;
     }
     th, td {
     border: 1px solid black;
-    /* Add lines etween cells */
-    padding: 8px; }
+    padding: 8px;
+    }
+    th {
+    font-weight: bold;
+    }
+    table tr:nth-child(even) td{
+    background-color: LightGray;
+    }
     </style>
     </head>"""
@@ -1733,6 +1760,20 @@ class DoclingDocument(BaseModel):
         with open(filename, "w") as fw:
             json.dump(out, fw, indent=indent)
+    @classmethod
+    def load_from_json(cls, filename: Path) -> "DoclingDocument":
+        """load_from_json.
+        :param filename: The filename to load a saved DoclingDocument from a .json.
+        :type filename: Path
+        :returns: The loaded DoclingDocument.
+        :rtype: DoclingDocument
+        """
+        with open(filename, "r") as f:
+            return cls.model_validate(json.loads(f.read()))
     def save_as_yaml(
         self,
         filename: Path,
@@ -1825,26 +1866,28 @@ class DoclingDocument(BaseModel):
         from_element and to_element; defaulting to the whole document.
         :param delim: Delimiter to use when concatenating the various
-                Markdown parts. Defaults to "\n\n".
-        :type delim: str
+                Markdown parts. (Default value = "\n").
+        :type delim: str = "\n"
         :param from_element: Body slicing start index (inclusive).
-                Defaults to 0.
-        :type from_element: int
+                (Default value = 0).
+        :type from_element: int = 0
         :param to_element: Body slicing stop index
-                (exclusive). Defaults to 0maxint.
-        :type to_element: int
-        :param delim: str:  (Default value = "\n\n")
-        :param labels: set[DocItemLabel]
-        :param "subtitle-level-1":
-        :param "paragraph":
-        :param "caption":
-        :param "table":
-        :param "Text":
-        :param "text":
-        :param strict_text: bool:  (Default value = False)
-        :param image_placeholder str:  (Default value = "<!-- image -->")
-            the placeholder to include to position images in the markdown.
-        :param indent: int (default=4): indent of the nested lists
+                (exclusive). (Default value = maxint).
+        :type to_element: int = sys.maxsize
+        :param labels: The set of document labels to include in the export.
+        :type labels: set[DocItemLabel] = DEFAULT_EXPORT_LABELS
+        :param strict_text: bool: Whether to only include the text content
+            of the document. (Default value = False).
+        :type strict_text: bool = False
+        :param image_placeholder: The placeholder to include to position
+            images in the markdown. (Default value = "\<!-- image --\>").
+        :type image_placeholder: str = "<!-- image -->"
+        :param image_mode: The mode to use for including images in the
+            markdown. (Default value = ImageRefMode.PLACEHOLDER).
+        :type image_mode: ImageRefMode = ImageRefMode.PLACEHOLDER
+        :param indent: The indent in spaces of the nested lists.
+            (Default value = 4).
+        :type indent: int = 4
         :returns: The exported Markdown representation.
         :rtype: str
         """

docling_core-2.6.0/docling_core/types/io/__init__.py ADDED Viewed

@@ -0,0 +1,19 @@
+#
+# Copyright IBM Corp. 2024 - 2024
+# SPDX-License-Identifier: MIT
+#
+"""Models for io."""
+from io import BytesIO
+from pydantic import BaseModel, ConfigDict
+class DocumentStream(BaseModel):
+    """Wrapper class for a bytes stream with a filename."""
+    model_config = ConfigDict(arbitrary_types_allowed=True)
+    name: str
+    stream: BytesIO

docling_core-2.6.0/docling_core/utils/file.py ADDED Viewed

@@ -0,0 +1,210 @@
+#
+# Copyright IBM Corp. 2024 - 2024
+# SPDX-License-Identifier: MIT
+#
+"""File-related utilities."""
+import importlib
+import tempfile
+from io import BytesIO
+from pathlib import Path
+from typing import Dict, Optional, Union
+import requests
+from pydantic import AnyHttpUrl, TypeAdapter, ValidationError
+from typing_extensions import deprecated
+from docling_core.types.io import DocumentStream
+def resolve_remote_filename(
+    http_url: AnyHttpUrl,
+    response_headers: Dict[str, str],
+    fallback_filename="file",
+) -> str:
+    """Resolves the filename from a remote url and its response headers.
+    Args:
+        source AnyHttpUrl: The source http url.
+        response_headers Dict: Headers received while fetching the remote file.
+        fallback_filename str: Filename to use in case none can be determined.
+    Returns:
+        str: The actual filename of the remote url.
+    """
+    fname = None
+    # try to get filename from response header
+    if cont_disp := response_headers.get("Content-Disposition"):
+        for par in cont_disp.strip().split(";"):
+            # currently only handling directive "filename" (not "*filename")
+            if (split := par.split("=")) and split[0].strip() == "filename":
+                fname = "=".join(split[1:]).strip().strip("'\"") or None
+                break
+    # otherwise, use name from URL:
+    if fname is None:
+        fname = Path(http_url.path or "").name or fallback_filename
+    return fname
+def resolve_source_to_stream(
+    source: Union[Path, AnyHttpUrl, str], headers: Optional[Dict[str, str]] = None
+) -> DocumentStream:
+    """Resolves the source (URL, path) of a file to a binary stream.
+    Args:
+        source (Path | AnyHttpUrl | str): The file input source. Can be a path or URL.
+        headers (Dict | None): Optional set of headers to use for fetching
+            the remote URL.
+    Raises:
+        ValueError: If source is of unexpected type.
+    Returns:
+        DocumentStream: The resolved file loaded as a stream.
+    """
+    try:
+        http_url: AnyHttpUrl = TypeAdapter(AnyHttpUrl).validate_python(source)
+        # make all header keys lower case
+        _headers = headers or {}
+        req_headers = {k.lower(): v for k, v in _headers.items()}
+        # add user-agent is not set
+        if "user-agent" not in req_headers:
+            agent_name = f"docling-core/{importlib.metadata.version('docling-core')}"
+            req_headers["user-agent"] = agent_name
+        # fetch the page
+        res = requests.get(http_url, stream=True, headers=req_headers)
+        res.raise_for_status()
+        fname = resolve_remote_filename(http_url=http_url, response_headers=res.headers)
+        stream = BytesIO(res.content)
+        doc_stream = DocumentStream(name=fname, stream=stream)
+    except ValidationError:
+        try:
+            local_path = TypeAdapter(Path).validate_python(source)
+            stream = BytesIO(local_path.read_bytes())
+            doc_stream = DocumentStream(name=local_path.name, stream=stream)
+        except ValidationError:
+            raise ValueError(f"Unexpected source type encountered: {type(source)}")
+    return doc_stream
+def _resolve_source_to_path(
+    source: Union[Path, AnyHttpUrl, str],
+    headers: Optional[Dict[str, str]] = None,
+    workdir: Optional[Path] = None,
+) -> Path:
+    doc_stream = resolve_source_to_stream(source=source, headers=headers)
+    # use a temporary directory if not specified
+    if workdir is None:
+        workdir = Path(tempfile.mkdtemp())
+    # create the parent workdir if it doesn't exist
+    workdir.mkdir(exist_ok=True, parents=True)
+    # save result to a local file
+    local_path = workdir / doc_stream.name
+    with local_path.open("wb") as f:
+        f.write(doc_stream.stream.read())
+    return local_path
+def resolve_source_to_path(
+    source: Union[Path, AnyHttpUrl, str],
+    headers: Optional[Dict[str, str]] = None,
+    workdir: Optional[Path] = None,
+) -> Path:
+    """Resolves the source (URL, path) of a file to a local file path.
+    If a URL is provided, the content is first downloaded to a local file, located in
+      the provided workdir or in a temporary directory if no workdir provided.
+    Args:
+        source (Path | AnyHttpUrl | str): The file input source. Can be a path or URL.
+        headers (Dict | None): Optional set of headers to use for fetching
+            the remote URL.
+        workdir (Path | None): If set, the work directory where the file will
+            be downloaded, otherwise a temp dir will be used.
+    Raises:
+        ValueError: If source is of unexpected type.
+    Returns:
+        Path: The local file path.
+    """
+    return _resolve_source_to_path(
+        source=source,
+        headers=headers,
+        workdir=workdir,
+    )
+@deprecated("Use `resolve_source_to_path()` or `resolve_source_to_stream()`  instead")
+def resolve_file_source(
+    source: Union[Path, AnyHttpUrl, str],
+    headers: Optional[Dict[str, str]] = None,
+) -> Path:
+    """Resolves the source (URL, path) of a file to a local file path.
+    If a URL is provided, the content is first downloaded to a temporary local file.
+    Args:
+        source (Path | AnyHttpUrl | str): The file input source. Can be a path or URL.
+        headers (Dict | None): Optional set of headers to use for fetching
+            the remote URL.
+    Raises:
+        ValueError: If source is of unexpected type.
+    Returns:
+        Path: The local file path.
+    """
+    return _resolve_source_to_path(
+        source=source,
+        headers=headers,
+    )
+def relative_path(src: Path, target: Path) -> Path:
+    """Compute the relative path from `src` to `target`.
+    Args:
+        src (str | Path): The source directory or file path (must be absolute).
+        target (str | Path): The target directory or file path (must be absolute).
+    Returns:
+        Path: The relative path from `src` to `target`.
+    Raises:
+        ValueError: If either `src` or `target` is not an absolute path.
+    """
+    src = Path(src).resolve()
+    target = Path(target).resolve()
+    # Ensure both paths are absolute
+    if not src.is_absolute():
+        raise ValueError(f"The source path must be absolute: {src}")
+    if not target.is_absolute():
+        raise ValueError(f"The target path must be absolute: {target}")
+    # Find the common ancestor
+    common_parts = []
+    for src_part, target_part in zip(src.parts, target.parts):
+        if src_part == target_part:
+            common_parts.append(src_part)
+        else:
+            break
+    # Determine the path to go up from src to the common ancestor
+    up_segments = [".."] * (len(src.parts) - len(common_parts))
+    # Add the path from the common ancestor to the target
+    down_segments = target.parts[len(common_parts) :]
+    # Combine and return the result
+    return Path(*up_segments, *down_segments)

{docling_core-2.5.1 → docling_core-2.6.0}/pyproject.toml RENAMED Viewed

@@ -1,6 +1,6 @@
 [tool.poetry]
 name = "docling-core"
-version = "2.5.1"
+version = "2.6.0"
 description = "A python library to define and validate data types in Docling."
 license = "MIT"
 authors = [
@@ -54,6 +54,7 @@ tabulate = "^0.9.0"
 pandas = "^2.1.4"
 pillow = "^10.3.0"
 pyyaml = ">=5.1,<7.0.0"
+typing-extensions = "^4.12.2"
 [tool.poetry.group.dev.dependencies]
 black = "^24.4.2"

docling_core-2.5.1/docling_core/utils/file.py DELETED Viewed

@@ -1,107 +0,0 @@
-#
-# Copyright IBM Corp. 2024 - 2024
-# SPDX-License-Identifier: MIT
-#
-"""File-related utilities."""
-import importlib
-import tempfile
-from pathlib import Path
-from typing import Dict, Optional, Union
-import requests
-from pydantic import AnyHttpUrl, TypeAdapter, ValidationError
-def resolve_file_source(
-    source: Union[Path, AnyHttpUrl, str], headers: Optional[Dict[str, str]] = None
-) -> Path:
-    """Resolves the source (URL, path) of a file to a local file path.
-    If a URL is provided, the content is first downloaded to a temporary local file.
-    Args:
-        source (Path | AnyHttpUrl | str): The file input source. Can be a path or URL.
-    Raises:
-        ValueError: If source is of unexpected type.
-    Returns:
-        Path: The local file path.
-    """
-    try:
-        http_url: AnyHttpUrl = TypeAdapter(AnyHttpUrl).validate_python(source)
-        # make all header keys lower case
-        _headers = headers or {}
-        req_headers = {k.lower(): v for k, v in _headers.items()}
-        # add user-agent is not set
-        if "user-agent" not in req_headers:
-            agent_name = f"docling-core/{importlib.metadata.version('docling-core')}"
-            req_headers["user-agent"] = agent_name
-        # fetch the page
-        res = requests.get(http_url, stream=True, headers=req_headers)
-        res.raise_for_status()
-        fname = None
-        # try to get filename from response header
-        if cont_disp := res.headers.get("Content-Disposition"):
-            for par in cont_disp.strip().split(";"):
-                # currently only handling directive "filename" (not "*filename")
-                if (split := par.split("=")) and split[0].strip() == "filename":
-                    fname = "=".join(split[1:]).strip().strip("'\"") or None
-                    break
-        # otherwise, use name from URL:
-        if fname is None:
-            fname = Path(http_url.path or "").name or "file"
-        local_path = Path(tempfile.mkdtemp()) / fname
-        with open(local_path, "wb") as f:
-            for chunk in res.iter_content(chunk_size=1024):  # using 1-KB chunks
-                f.write(chunk)
-    except ValidationError:
-        try:
-            local_path = TypeAdapter(Path).validate_python(source)
-        except ValidationError:
-            raise ValueError(f"Unexpected source type encountered: {type(source)}")
-    return local_path
-def relative_path(src: Path, target: Path) -> Path:
-    """Compute the relative path from `src` to `target`.
-    Args:
-        src (str | Path): The source directory or file path (must be absolute).
-        target (str | Path): The target directory or file path (must be absolute).
-    Returns:
-        Path: The relative path from `src` to `target`.
-    Raises:
-        ValueError: If either `src` or `target` is not an absolute path.
-    """
-    src = Path(src).resolve()
-    target = Path(target).resolve()
-    # Ensure both paths are absolute
-    if not src.is_absolute():
-        raise ValueError(f"The source path must be absolute: {src}")
-    if not target.is_absolute():
-        raise ValueError(f"The target path must be absolute: {target}")
-    # Find the common ancestor
-    common_parts = []
-    for src_part, target_part in zip(src.parts, target.parts):
-        if src_part == target_part:
-            common_parts.append(src_part)
-        else:
-            break
-    # Determine the path to go up from src to the common ancestor
-    up_segments = [".."] * (len(src.parts) - len(common_parts))
-    # Add the path from the common ancestor to the target
-    down_segments = target.parts[len(common_parts) :]
-    # Combine and return the result
-    return Path(*up_segments, *down_segments)