docling-core 0.0.1__py3-none-any.whl

docling_core/utils/ds_generate_docs.py

@@ -0,0 +1,144 @@
+#
+# Copyright IBM Corp. 2024 - 2024
+# SPDX-License-Identifier: MIT
+#
+
+"""Generate documentation of Docling types in HTML and Markdown.
+
+Example:
+    python docling_core/utils/ds_generate_docs.py /tmp/docling_core_files
+"""
+import argparse
+import glob
+import json
+import os
+from argparse import BooleanOptionalAction
+from pathlib import Path
+from shutil import rmtree
+from typing import Final
+
+from json_schema_for_humans.generate import generate_from_filename
+from json_schema_for_humans.generation_configuration import GenerationConfiguration
+
+from docling_core.utils.ds_generate_jsonschema import generate_json_schema
+
+MODELS: Final = ["Document", "Record", "Generic"]
+
+
+def _prepare_directory(folder: str, clean: bool = False) -> None:
+    """Create a directory or empty its content if it already exists.
+
+    Args:
+        folder: The name of the directory.
+        clean: Whether any existing content in the directory should be removed.
+    """
+    if os.path.isdir(folder):
+        if clean:
+            for path in Path(folder).glob("**/*"):
+                if path.is_file():
+                    path.unlink()
+                elif path.is_dir():
+                    rmtree(path)
+    else:
+        os.makedirs(folder, exist_ok=True)
+
+
+def generate_collection_jsonschema(folder: str):
+    """Generate the JSON schema of Docling collections and export them to a folder.
+
+    Args:
+        folder: The name of the directory.
+    """
+    for item in MODELS:
+        json_schema = generate_json_schema(item)
+        with open(
+            os.path.join(folder, f"{item}.json"), mode="w", encoding="utf8"
+        ) as json_file:
+            json.dump(json_schema, json_file, ensure_ascii=False, indent=2)
+
+
+def generate_collection_html(folder: str):
+    """Generate HTML pages documenting the data model of Docling collections.
+
+    The JSON schemas files need to be in a folder and the generated HTML pages will be
+    written in the same folder.
+
+    Args:
+        folder: The name of the directory.
+    """
+    config = GenerationConfiguration(
+        template_name="js_offline",
+        expand_buttons=True,
+        link_to_reused_ref=False,
+        with_footer=False,
+    )
+
+    for doc_json in glob.glob(os.path.join(folder, "*.json")):
+        doc_html = doc_json.removesuffix(".json") + ".html"
+        generate_from_filename(doc_json, doc_html, config=config)
+
+
+def generate_collection_markdown(folder: str):
+    """Generate Markdown pages documenting the data model of Docling collections.
+
+    The JSON schemas files need to be in a folder and the generated markdown pages will
+    be written in the same folder.
+
+    Args:
+        folder: The name of the directory.
+    """
+    config = GenerationConfiguration(
+        template_name="md_nested",
+        expand_buttons=True,
+        link_to_reused_ref=False,
+        with_footer=False,
+        show_toc=False,
+    )
+
+    for doc_json in glob.glob(os.path.join(folder, "*.json")):
+        doc_html = doc_json.removesuffix(".json") + ".md"
+        generate_from_filename(doc_json, doc_html, config=config)
+
+
+def main() -> None:
+    """Generate the JSON Schema of Docling collections and export documentation."""
+    argparser = argparse.ArgumentParser()
+    argparser.add_argument(
+        "directory",
+        help=(
+            "Directory to generate files. If it exists, any existing content will be"
+            " removed."
+        ),
+    )
+    argparser.add_argument(
+        "--clean",
+        help="Whether any existing content in directory should be removed.",
+        action=BooleanOptionalAction,
+        dest="clean",
+        default=False,
+        required=False,
+    )
+    argparser.add_argument(
+        "--template",
+        action="store",
+        default="markdown",
+        choices=["html", "markdown"],
+        type=str,
+        required=False,
+        dest="template",
+        help="Documentation template.",
+    )
+    args = argparser.parse_args()
+
+    _prepare_directory(args.directory, args.clean)
+
+    generate_collection_jsonschema(args.directory)
+
+    if args.template == "html":
+        generate_collection_html(args.directory)
+    elif args.template == "markdown":
+        generate_collection_markdown(args.directory)
+
+
+if __name__ == "__main__":
+    main()

docling_core/utils/ds_generate_jsonschema.py

@@ -0,0 +1,62 @@
+#
+# Copyright IBM Corp. 2024 - 2024
+# SPDX-License-Identifier: MIT
+#
+
+"""Generate the JSON Schema of pydantic models and export them to files.
+
+Example:
+    python docling_core/utils/ds_generate_jsonschema.py doc.base.TableCell
+
+"""
+import argparse
+import json
+from typing import Any, Union
+
+from pydantic import BaseModel
+
+
+def _import_class(class_reference: str) -> Any:
+    components = class_reference.split(".")
+    module_ref = ".".join(components[:-1])
+    class_name = components[-1]
+    mod = __import__(module_ref, fromlist=[class_name])
+    class_type = getattr(mod, class_name)
+
+    return class_type
+
+
+def generate_json_schema(class_reference: str) -> Union[dict, None]:
+    """Generate a jsonable dict of a model's schema from DS data types.
+
+    Args:
+        class_reference: The reference to a class in 'src.data_types'.
+
+    Returns:
+        A jsonable dict of the model's schema.
+    """
+    if not class_reference.startswith("docling_core.types."):
+        class_reference = "docling_core.types." + class_reference
+    class_type = _import_class(class_reference)
+    if issubclass(class_type, BaseModel):
+        return class_type.model_json_schema()
+    else:
+        return None
+
+
+def main() -> None:
+    """Print the JSON Schema of a model."""
+    argparser = argparse.ArgumentParser()
+    argparser.add_argument(
+        "class_ref", help="Class reference, e.g., doc.base.TableCell"
+    )
+    args = argparser.parse_args()
+
+    json_schema = generate_json_schema(args.class_ref)
+    print(
+        json.dumps(json_schema, ensure_ascii=False, indent=2).encode("utf-8").decode()
+    )
+
+
+if __name__ == "__main__":
+    main()

docling_core/utils/validate.py

@@ -0,0 +1,86 @@
+#
+# Copyright IBM Corp. 2024 - 2024
+# SPDX-License-Identifier: MIT
+#
+
+"""Validation of Document-related files against their data schemas."""
+import argparse
+import json
+import logging
+
+from docling_core.utils.validators import (
+    validate_ann_schema,
+    validate_ocr_schema,
+    validate_raw_schema,
+)
+
+logger = logging.getLogger("docling-core")
+
+
+def parse_arguments():
+    """Parse the arguments from the command line."""
+    argparser = argparse.ArgumentParser(description="validate example-file with schema")
+
+    argparser.add_argument(
+        "-f", "--format", required=True, help="format of the file [RAW, ANN, OCR]"
+    )
+
+    argparser.add_argument(
+        "-i", "--input-file", required=True, help="JSON filename to be validated"
+    )
+
+    pargs = argparser.parse_args()
+
+    return pargs.format, pargs.input_file
+
+
+def run():
+    """Run the validation of a file containing a Document."""
+    file_format, input_file = parse_arguments()
+
+    with open(input_file, "r") as fd:
+        file_ = json.load(fd)
+
+    result = (False, "Empty result")
+
+    if file_format == "RAW":
+        result = validate_raw_schema(file_)
+
+    elif file_format == "ANN":
+        result = validate_ann_schema(file_)
+
+    elif file_format == "OCR":
+        result = validate_ocr_schema(file_)
+
+    else:
+        logger.error("format of the file needs to `RAW`, `ANN` or `OCR`")
+
+    if result[0]:
+        logger.info("Done!")
+    else:
+        logger.error("invalid schema: {}".format(result[1]))
+
+
+def main():
+    """Set up the environment and run the validation of a Document."""
+    logger.setLevel(logging.DEBUG)
+
+    # create console handler and set level to debug
+    ch = logging.StreamHandler()
+    ch.setLevel(logging.DEBUG)
+
+    # create formatter
+    formatter = logging.Formatter("[%(asctime)s] [%(levelname)s] %(message)s")
+
+    # add formatter to ch
+    ch.setFormatter(formatter)
+
+    # add ch to logger
+    # logger.addHandler(ch)
+
+    logging.basicConfig(handlers=[ch])
+    run()
+
+
+if __name__ == "__main__":
+    main()

docling_core/utils/validators.py

@@ -0,0 +1,100 @@
+#
+# Copyright IBM Corp. 2024 - 2024
+# SPDX-License-Identifier: MIT
+#
+
+"""Module for custom type validators."""
+import json
+import logging
+from datetime import datetime
+from importlib import resources
+from typing import Hashable, TypeVar
+
+import jsonschema
+from pydantic_core import PydanticCustomError
+
+logger = logging.getLogger("docling-core")
+
+T = TypeVar("T", bound=Hashable)
+
+
+def validate_schema(file_: dict, schema: dict) -> tuple[bool, str]:
+    """Check wheter the workflow is properly formatted JSON and contains valid keys.
+
+    Where possible, this also checks a few basic dependencies between properties, but
+    this functionality is limited.
+    """
+    try:
+        jsonschema.validate(file_, schema)
+        return (True, "All good!")
+
+    except jsonschema.ValidationError as err:
+        return (False, err.message)
+
+
+def validate_raw_schema(file_: dict) -> tuple[bool, str]:
+    """Validate a RAW file."""
+    logger.debug("validate RAW schema ... ")
+
+    schema_txt = (
+        resources.files("docling_core")
+        .joinpath("resources/schemas/doc/RAW.json")
+        .read_text("utf-8")
+    )
+    schema = json.loads(schema_txt)
+
+    return validate_schema(file_, schema)
+
+
+def validate_ann_schema(file_: dict) -> tuple[bool, str]:
+    """Validate an annotated (ANN) file."""
+    logger.debug("validate ANN schema ... ")
+
+    schema_txt = (
+        resources.files("docling_core")
+        .joinpath("resources/schemas/doc/ANN.json")
+        .read_text("utf-8")
+    )
+    schema = json.loads(schema_txt)
+
+    return validate_schema(file_, schema)
+
+
+def validate_ocr_schema(file_: dict) -> tuple[bool, str]:
+    """Validate an OCR file."""
+    logger.debug("validate OCR schema ... ")
+
+    schema_txt = (
+        resources.files("docling_core")
+        .joinpath("resources/schemas/doc/OCR-output.json")
+        .read_text("utf-8")
+    )
+    schema = json.loads(schema_txt)
+
+    return validate_schema(file_, schema)
+
+
+def validate_unique_list(v: list[T]) -> list[T]:
+    """Validate that a list has unique values.
+
+    Validator for list types, since pydantic V2 does not support the `unique_items`
+    parameter from V1. More information on
+    https://github.com/pydantic/pydantic-core/pull/820#issuecomment-1670475909
+
+    Args:
+        v: any list of hashable types
+
+    Returns:
+        The list, after checking for unique items.
+    """
+    if len(v) != len(set(v)):
+        raise PydanticCustomError("unique_list", "List must be unique")
+    return v
+
+
+def validate_datetime(v, handler):
+    """Validate that a value is a datetime or a non-numeric string."""
+    if type(v) is datetime or (type(v) is str and not v.isnumeric()):
+        return handler(v)
+    else:
+        raise ValueError("Value type must be a datetime or a non-numeric string")

docling_core-0.0.1.dist-info/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2024 International Business Machines
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

docling_core-0.0.1.dist-info/METADATA

@@ -0,0 +1,133 @@
+Metadata-Version: 2.1
+Name: docling-core
+Version: 0.0.1
+Summary: A python library to define and validate data types in Docling.
+Home-page: https://ds4sd.github.io/
+License: MIT
+Keywords: docling,discovery,etl,information retrieval,analytics,database,database schema,schema,JSON
+Author: Cesar Berrospi Ramis
+Author-email: ceb@zurich.ibm.com
+Maintainer: Cesar Berrospi Ramis
+Maintainer-email: ceb@zurich.ibm.com
+Requires-Python: >=3.9,<4.0
+Classifier: Development Status :: 5 - Production/Stable
+Classifier: Intended Audience :: Developers
+Classifier: Intended Audience :: Science/Research
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Natural Language :: English
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Topic :: Database
+Classifier: Topic :: Scientific/Engineering :: Information Analysis
+Classifier: Topic :: Software Development :: Libraries :: Python Modules
+Classifier: Typing :: Typed
+Requires-Dist: json-schema-for-humans (>=1.0.0,<2.0.0)
+Requires-Dist: jsonref (>=1.1.0,<2.0.0)
+Requires-Dist: jsonschema (>=4.16.0,<5.0.0)
+Requires-Dist: poetry (>=1.8.3,<2.0.0)
+Requires-Dist: pydantic (>=2.6.0,<3.0.0)
+Requires-Dist: pyproject-toml (>=0.0.10,<0.0.11)
+Project-URL: Repository, https://github.com/DS4SD/docling-core
+Description-Content-Type: text/markdown
+
+[![PyPI version](https://img.shields.io/pypi/v/docling-core)](https://pypi.org/project/docling-core/)
+![Python](https://img.shields.io/badge/python-3.9%20%7C%203.10%20%7C%203.11-blue)
+[![Poetry](https://img.shields.io/endpoint?url=https://python-poetry.org/badge/v0.json)](https://python-poetry.org/)
+[![Code style: black](https://img.shields.io/badge/code%20style-black-000000.svg)](https://github.com/psf/black)
+[![Imports: isort](https://img.shields.io/badge/%20imports-isort-%231674b1?style=flat&labelColor=ef8336)](https://pycqa.github.io/isort/)
+[![Checked with mypy](https://www.mypy-lang.org/static/mypy_badge.svg)](https://mypy-lang.org/)
+[![Pydantic v2](https://img.shields.io/endpoint?url=https://raw.githubusercontent.com/pydantic/pydantic/main/docs/badge/v2.json)](https://pydantic.dev)
+[![pre-commit](https://img.shields.io/badge/pre--commit-enabled-brightgreen?logo=pre-commit&logoColor=white)](https://github.com/pre-commit/pre-commit)
+[![License MIT](https://img.shields.io/github/license/ds4sd/deepsearch-toolkit)](https://opensource.org/licenses/MIT)
+
+# Docling Core
+
+Docling Core is a library that defines the data types in [Docling](https://ds4sd.github.io), leveraging pydantic models.
+
+## Installation
+
+Using [Poetry](https://python-poetry.org), create and activate a virtual environment.
+
+```
+poetry shell
+```
+
+Install the defined dependencies of the project.
+
+```
+poetry install
+```
+
+Test the installation running the pytest suite.
+
+```
+poetry run pytest test
+```
+
+## Basic Usage
+
+- You can validate your JSON objects using the pydantic class definition.
+
+  ```py
+  from docling_core.types import Document
+
+  data_dict = {...}  # here the object you want to validate, as a dictionary
+  Document.model_validate(data_dict)
+
+  data_str = {...}  # here the object as a JSON string
+  Document.model_validate_json(data_str)
+  ```
+
+- You can generate the JSON schema of a model with the script `ds_generate_jsonschema`.
+
+  ```py
+  # for the `Document` type
+  ds_generate_jsonschema Document
+
+  # for the use `Record` type
+  ds_generate_jsonschema Record
+  ```
+
+## Documentation
+
+Docling supports 3 main data types:
+
+- **Document** for publications like books, articles, reports, or patents. When Docling converts an unstructured PDF document, the generated JSON follows this schema.
+  The Document type also models the metadata that may be attached to the converted document.
+  Check [Document](docs/Document.md) for the full JSON schema. 
+- **Record** for structured database records, centered on an entity or _subject_ that is provided with a list of attributes.
+  Related to records, the statements can represent annotations on text by Natural Language Processing (NLP) tools.
+  Check [Record](docs/Record.md) for the full JSON schema. 
+- **Generic** for any data representation, ensuring minimal configuration and maximum flexibility.
+  Check [Generic](docs/Generic.md) for the full JSON schema. 
+
+The data schemas are defined using [pydantic](https://pydantic-docs.helpmanual.io/) models, which provide built-in processes to support the creation of data that adhere to those models.
+
+## Contributing
+
+Please read [Contributing to Docling Core](./CONTRIBUTING.md) for details.
+
+## References
+
+If you use `Docling Core` in your projects, please consider citing the following:
+
+```bib
+@software{Docling,
+author = {Deep Search Team},
+month = {7},
+title = {{Docling}},
+url = {https://github.com/DS4SD/docling},
+version = {main},
+year = {2024}
+}
+```
+
+## License
+
+The `Docling Core` codebase is under MIT license.
+For individual model usage, please refer to the model licenses found in the original packages.
+

docling_core-0.0.1.dist-info/RECORD

@@ -0,0 +1,46 @@
+docling_core/__init__.py,sha256=D0afxif-BMUrgx2cYk1cwxiwATRYaGXsIMk_z4nw1Vs,90
+docling_core/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+docling_core/resources/schemas/doc/ANN.json,sha256=04U5j-PU9m5w7IagJ_rHcAx7qUtLkUuaWZO9GuYHnTA,4202
+docling_core/resources/schemas/doc/DOC.json,sha256=9tVKpCqDGGq3074Nn5qlUCdTN-5k1Q0ri_scJblwnLE,6686
+docling_core/resources/schemas/doc/OCR-output.json,sha256=56A3g5dbUEzUYwEqhQhnoNi-Jgm8n8YMp3U5F23cZVM,3080
+docling_core/resources/schemas/doc/RAW.json,sha256=yN7bQacrV8d6a60eQKFNlxfHlA3OQuJsPnN8UJ6WCPM,4034
+docling_core/resources/schemas/generated/ccs_document_schema.json,sha256=G4yy3dkdJXDfcrj_qWhMOJ9DPEIKaYHMYK8Sk8aVwy0,22484
+docling_core/resources/schemas/generated/minimal_document_schema_flat.json,sha256=XP0gdvKdXhs-owtzlXOy7icvqmf6aFRATo1a2E1SqyI,29982
+docling_core/resources/schemas/search/search_doc_mapping.json,sha256=1QNzBJt_ZIokKbO-5kBjvoBeoTTY4EuHnIZvsOPtSD0,2015
+docling_core/resources/schemas/search/search_doc_mapping_v2.json,sha256=ZIr4tqhfX4S9QHG2Ei08QbzJbspPTf5duSwbdhzdUWA,6009
+docling_core/search/__init__.py,sha256=RucCUQjDlTZ7VfgbfnKDRBL-A-_Lcc2JWWeiVWHtoOY,147
+docling_core/search/json_schema_to_search_mapper.py,sha256=9crSFuSbcXrJej7j1rYWK6b0x37cHDmPF6va5j3gknA,12933
+docling_core/search/mapping.py,sha256=6rqG7LgYSeWmooKNEcRa5gFDLp1ZdzPqDGlwTA5gpOk,724
+docling_core/search/meta.py,sha256=wSurrsqdP1N3gQKx027fVdzVmc33a7Y6rPl-FClQvtA,3318
+docling_core/search/package.py,sha256=Q0_FAWFt71_g0ifcFkCuXEpVAgpVFiT9mOdzq1fqeDM,1824
+docling_core/types/__init__.py,sha256=6mrAEKRW85uHJwNQBufwjPcMWCjm3oocA6MaO4_NLgg,805
+docling_core/types/base.py,sha256=fNtfQ20NKa_RBNBWbq0DfO8o0zC1Cec8UAMu0Znsltk,8170
+docling_core/types/doc/__init__.py,sha256=Pzj_8rft6SJTVTCHgXRwHtuZjL6LK_6dcBWjikL9biY,125
+docling_core/types/doc/base.py,sha256=-j4vVs3JZuaUjm0fHIkLU9TD_4IZXQuGouLrddEAwPw,5508
+docling_core/types/doc/doc_ann.py,sha256=8pV2efUglw19jxl4_oqB__mSxjWvtGIcllyCdqA-b2s,1196
+docling_core/types/doc/doc_ocr.py,sha256=6PC0C-OczF-MyfgRxEI1xs3PWgNOzi7i2yEQbTqZz0I,1387
+docling_core/types/doc/doc_raw.py,sha256=Y69G6IiauNDaoT-5el4xo1ypWpnBJQ75akGGkCMTZSc,3888
+docling_core/types/doc/document.py,sha256=cMduCiFkPVCmXQehvNkXqXtDiXJJtB72o7_LZXz_S6I,12549
+docling_core/types/gen/__init__.py,sha256=C6TuCfvpSnSL5XDOFMcYHUY2-i08vvfOGRcdu6Af0pI,124
+docling_core/types/gen/generic.py,sha256=l4CZ4_Lb8ONG36WNJWbKX5hGKvTh_yU-hXp5hsm7uVU,844
+docling_core/types/nlp/__init__.py,sha256=hGcztAeVK7xkRBqRRvc4zbY4PGeJ0r0QrEsetnSx9nI,119
+docling_core/types/nlp/qa.py,sha256=TyZjubqkEoREv0YzmuLKlq4WW_TnJNj7BoBY1_r2a1E,2731
+docling_core/types/nlp/qa_labels.py,sha256=YLW2SYM9M1riktCUYctsg83Msb988NV2I754w4ibWzA,5880
+docling_core/types/rec/__init__.py,sha256=JVcjGAc7FsIryBmlE1syiOJYWhh3hpJIpp2o7VrX_vE,123
+docling_core/types/rec/attribute.py,sha256=PzPdaPhP5NWbFo8rYOoBl3Vfyx4zJUxN6ZpXl8UY7FM,1551
+docling_core/types/rec/base.py,sha256=jhTfInNGyB9NUw7o33PElrFGL80TqhU8MLcLZNZYj3E,3222
+docling_core/types/rec/predicate.py,sha256=4iDwXl9c4jzHTDIlRNE88yvDzKA9_od0xjPUUUP5IjI,3959
+docling_core/types/rec/record.py,sha256=r1QgPepwH3YjmMHlwwmeK00ZHEJnAsvyOMeXFY_D9_Q,2750
+docling_core/types/rec/statement.py,sha256=BXkuKBz0BL7eiowL_aaYxsz_WBLfR4hfgiqTby4TRnk,920
+docling_core/types/rec/subject.py,sha256=wX9qsihwDbR7ZNSzY3vQymxi0eN1nxxsonrhSZzsMhA,2565
+docling_core/utils/__init__.py,sha256=VauNNpWRHG0_ISKrsy5-gTxicrdQZSau6qMfuMl3iqk,120
+docling_core/utils/alias.py,sha256=B6Lqvss8CbaNARHLR4qSmNh9OkB6LvqTpxfsFmkLAFo,874
+docling_core/utils/ds_generate_docs.py,sha256=0xGBagdC_PGjyeHXYZo90VnVrSTMZgHb0SYhFa6X7bQ,4248
+docling_core/utils/ds_generate_jsonschema.py,sha256=EhNQutqWJFWuN-yl9UUPFZ7DJTvGqg54qBIvUMHTHdA,1647
+docling_core/utils/validate.py,sha256=3FmnxnKTDZC5J9OGxCL3U3DGRl0t0bBV1NcySXswdas,2031
+docling_core/utils/validators.py,sha256=fBdyWX4PvFh7o_d25ZTs4iwmeo75QTbrxsvXv2kXkTg,2777
+docling_core-0.0.1.dist-info/LICENSE,sha256=2M9-6EoQ1sxFztTOkXGAtwUDJvnWaAHdB9BYWVwGkIw,1087
+docling_core-0.0.1.dist-info/METADATA,sha256=WcF2o7nPSZFydFZOCxd8tPnEYS53c940KzWPxlRem_U,5174
+docling_core-0.0.1.dist-info/WHEEL,sha256=sP946D7jFCHeNz5Iq4fL4Lu-PrWrFsgfLXbbkciIZwg,88
+docling_core-0.0.1.dist-info/entry_points.txt,sha256=XHhtJEkdUuLxXSNxLdFIzx_siQ3z2UFQEKp-P8VYAE4,189
+docling_core-0.0.1.dist-info/RECORD,,

docling_core-0.0.1.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: poetry-core 1.9.0
+Root-Is-Purelib: true
+Tag: py3-none-any

docling_core-0.0.1.dist-info/entry_points.txt

@@ -0,0 +1,5 @@
+[console_scripts]
+ds_generate_docs=docling_core.utils.ds_generate_docs:main
+ds_generate_jsonschema=docling_core.utils.ds_generate_jsonschema:main
+validate=docling_core.utils.validate:main
+