kreuzberg 3.5.0__py3-none-any.whl → 3.6.0__py3-none-any.whl

kreuzberg/__init__.py

@@ -1,5 +1,6 @@
 from importlib.metadata import version
 
+from kreuzberg._entity_extraction import SpacyEntityExtractionConfig
 from kreuzberg._gmft import GMFTConfig
 from kreuzberg._language_detection import LanguageDetectionConfig
 from kreuzberg._ocr._easyocr import EasyOCRConfig
@@ -8,7 +9,7 @@ from kreuzberg._ocr._tesseract import TesseractConfig
 
 from ._ocr._tesseract import PSMMode
 from ._registry import ExtractorRegistry
-from ._types import ExtractionConfig, ExtractionResult, Metadata, TableData
+from ._types import Entity, ExtractionConfig, ExtractionResult, Metadata, TableData
 from .exceptions import KreuzbergError, MissingDependencyError, OCRError, ParsingError, ValidationError
 from .extraction import (
     batch_extract_bytes,
@@ -25,6 +26,7 @@ __version__ = version("kreuzberg")
 
 __all__ = [
     "EasyOCRConfig",
+    "Entity",
     "ExtractionConfig",
     "ExtractionResult",
     "ExtractorRegistry",
@@ -37,6 +39,7 @@ __all__ = [
     "PSMMode",
     "PaddleOCRConfig",
     "ParsingError",
+    "SpacyEntityExtractionConfig",
     "TableData",
     "TesseractConfig",
     "ValidationError",

kreuzberg/_entity_extraction.py

@@ -0,0 +1,239 @@
+from __future__ import annotations
+
+import re
+from dataclasses import dataclass
+from functools import lru_cache
+from typing import TYPE_CHECKING, Any
+
+from kreuzberg._types import Entity
+from kreuzberg.exceptions import MissingDependencyError
+
+if TYPE_CHECKING:
+    from collections.abc import Sequence
+    from pathlib import Path
+
+
+@dataclass(unsafe_hash=True, frozen=True)
+class SpacyEntityExtractionConfig:
+    """Configuration for spaCy-based entity extraction."""
+
+    model_cache_dir: str | Path | None = None
+    """Directory to cache spaCy models. If None, uses spaCy's default."""
+
+    language_models: dict[str, str] | tuple[tuple[str, str], ...] | None = None
+    """Mapping of language codes to spaCy model names.
+
+    If None, uses default mappings:
+    - en: en_core_web_sm
+    - de: de_core_news_sm
+    - fr: fr_core_news_sm
+    - es: es_core_news_sm
+    - pt: pt_core_news_sm
+    - it: it_core_news_sm
+    - nl: nl_core_news_sm
+    - zh: zh_core_web_sm
+    - ja: ja_core_news_sm
+    """
+
+    fallback_to_multilingual: bool = True
+    """If True and language-specific model fails, try xx_ent_wiki_sm (multilingual)."""
+
+    max_doc_length: int = 1000000
+    """Maximum document length for spaCy processing."""
+
+    batch_size: int = 1000
+    """Batch size for processing multiple texts."""
+
+    def __post_init__(self) -> None:
+        if self.language_models is None:
+            object.__setattr__(self, "language_models", self._get_default_language_models())
+
+        if isinstance(self.language_models, dict):
+            object.__setattr__(self, "language_models", tuple(sorted(self.language_models.items())))
+
+    @staticmethod
+    def _get_default_language_models() -> dict[str, str]:
+        """Get default language model mappings based on available spaCy models."""
+        return {
+            "en": "en_core_web_sm",
+            "de": "de_core_news_sm",
+            "fr": "fr_core_news_sm",
+            "es": "es_core_news_sm",
+            "pt": "pt_core_news_sm",
+            "it": "it_core_news_sm",
+            "nl": "nl_core_news_sm",
+            "zh": "zh_core_web_sm",
+            "ja": "ja_core_news_sm",
+            "ko": "ko_core_news_sm",
+            "ru": "ru_core_news_sm",
+            "pl": "pl_core_news_sm",
+            "ro": "ro_core_news_sm",
+            "el": "el_core_news_sm",
+            "da": "da_core_news_sm",
+            "fi": "fi_core_news_sm",
+            "nb": "nb_core_news_sm",
+            "sv": "sv_core_news_sm",
+            "ca": "ca_core_news_sm",
+            "hr": "hr_core_news_sm",
+            "lt": "lt_core_news_sm",
+            "mk": "mk_core_news_sm",
+            "sl": "sl_core_news_sm",
+            "uk": "uk_core_news_sm",
+        }
+
+    def get_model_for_language(self, language_code: str) -> str | None:
+        """Get the appropriate spaCy model for a language code."""
+        if not self.language_models:
+            return None
+
+        models_dict = dict(self.language_models) if isinstance(self.language_models, tuple) else self.language_models
+
+        if language_code in models_dict:
+            return models_dict[language_code]
+
+        base_lang = language_code.split("-")[0].lower()
+        if base_lang in models_dict:
+            return models_dict[base_lang]
+
+        return None
+
+    def get_fallback_model(self) -> str | None:
+        """Get fallback multilingual model if enabled."""
+        return "xx_ent_wiki_sm" if self.fallback_to_multilingual else None
+
+
+def extract_entities(
+    text: str,
+    entity_types: Sequence[str] = ("PERSON", "ORGANIZATION", "LOCATION", "DATE", "EMAIL", "PHONE"),
+    custom_patterns: frozenset[tuple[str, str]] | None = None,
+    languages: list[str] | None = None,
+    spacy_config: SpacyEntityExtractionConfig | None = None,
+) -> list[Entity]:
+    """Extract entities from text using custom regex patterns and/or a NER model.
+
+    Args:
+        text: The input text to extract entities from.
+        entity_types: List of entity types to extract using the NER model.
+        custom_patterns: Tuple mapping entity types to regex patterns for custom extraction.
+        languages: List of detected languages to choose appropriate spaCy models.
+        spacy_config: Configuration for spaCy entity extraction.
+
+    Returns:
+        list[Entity]: A list of extracted Entity objects with type, text, start, and end positions.
+
+    Raises:
+        MissingDependencyError: If `spacy` is not installed.
+    """
+    entities: list[Entity] = []
+    if custom_patterns:
+        custom_patterns_dict = dict(custom_patterns)
+        for ent_type, pattern in custom_patterns_dict.items():
+            entities.extend(
+                Entity(type=ent_type, text=match.group(), start=match.start(), end=match.end())
+                for match in re.finditer(pattern, text)
+            )
+
+    if spacy_config is None:
+        spacy_config = SpacyEntityExtractionConfig()
+
+    try:
+        import spacy  # noqa: F401
+    except ImportError as e:
+        raise MissingDependencyError.create_for_package(
+            package_name="spacy",
+            dependency_group="entity-extraction",
+            functionality="Entity Extraction",
+        ) from e
+
+    model_name = _select_spacy_model(languages, spacy_config)
+    if not model_name:
+        return entities
+
+    nlp = _load_spacy_model(model_name, spacy_config)
+    if not nlp:
+        return entities
+
+    if len(text) > spacy_config.max_doc_length:
+        text = text[: spacy_config.max_doc_length]
+
+    doc = nlp(text)
+
+    entity_type_mapping = {etype.upper() for etype in entity_types}
+
+    entities.extend(
+        Entity(
+            type=ent.label_,
+            text=ent.text,
+            start=ent.start_char,
+            end=ent.end_char,
+        )
+        for ent in doc.ents
+        if ent.label_ in entity_type_mapping or ent.label_.upper() in entity_type_mapping
+    )
+
+    return entities
+
+
+@lru_cache(maxsize=32)
+def _load_spacy_model(model_name: str, spacy_config: SpacyEntityExtractionConfig) -> Any:
+    """Load a spaCy model with caching."""
+    try:
+        import spacy
+
+        if spacy_config.model_cache_dir:
+            import os
+
+            os.environ["SPACY_DATA"] = str(spacy_config.model_cache_dir)
+
+        nlp = spacy.load(model_name)
+
+        nlp.max_length = spacy_config.max_doc_length
+
+        return nlp
+    except (OSError, ImportError):
+        return None
+
+
+def _select_spacy_model(languages: list[str] | None, spacy_config: SpacyEntityExtractionConfig) -> str | None:
+    """Select the best spaCy model based on detected languages."""
+    if not languages:
+        return spacy_config.get_model_for_language("en")
+
+    for lang in languages:
+        model_name = spacy_config.get_model_for_language(lang)
+        if model_name:
+            return model_name
+
+    return spacy_config.get_fallback_model()
+
+
+def extract_keywords(
+    text: str,
+    keyword_count: int = 10,
+) -> list[tuple[str, float]]:
+    """Extract keywords from text using the KeyBERT model.
+
+    Args:
+        text: The input text to extract keywords from.
+        keyword_count: Number of top keywords to return. Defaults to 10.
+
+    Returns:
+        list[tuple[str, float]]: A list of tuples containing keywords and their relevance scores.
+
+    Raises:
+        MissingDependencyError: If `keybert` is not installed.
+    """
+    try:
+        from keybert import KeyBERT
+
+        kw_model = KeyBERT()
+        keywords = kw_model.extract_keywords(text, top_n=keyword_count)
+        return [(kw, float(score)) for kw, score in keywords]
+    except (RuntimeError, OSError, ValueError):
+        return []
+    except ImportError as e:
+        raise MissingDependencyError.create_for_package(
+            package_name="keybert",
+            dependency_group="entity-extraction",
+            functionality="Keyword Extraction",
+        ) from e

kreuzberg/_types.py

@@ -17,6 +17,7 @@ if TYPE_CHECKING:
     from pandas import DataFrame
     from PIL.Image import Image
 
+    from kreuzberg._entity_extraction import SpacyEntityExtractionConfig
     from kreuzberg._gmft import GMFTConfig
     from kreuzberg._language_detection import LanguageDetectionConfig
     from kreuzberg._ocr._easyocr import EasyOCRConfig
@@ -100,6 +101,20 @@ class Metadata(TypedDict, total=False):
     """Width of the document page/slide/image, if applicable."""
 
 
+@dataclass(frozen=True)
+class Entity:
+    """Represents an extracted entity with type, text, and position."""
+
+    type: str
+    """e.g., PERSON, ORGANIZATION, LOCATION, DATE, EMAIL, PHONE, or custom"""
+    text: str
+    """Extracted text"""
+    start: int
+    """Start character offset in the content"""
+    end: int
+    """End character offset in the content"""
+
+
 @dataclass
 class ExtractionResult:
     """The result of a file extraction."""
@@ -114,6 +129,10 @@ class ExtractionResult:
     """Extracted tables. Is an empty list if 'extract_tables' is not set to True in the ExtractionConfig."""
     chunks: list[str] = field(default_factory=list)
     """The extracted content chunks. This is an empty list if 'chunk_content' is not set to True in the ExtractionConfig."""
+    entities: list[Entity] | None = None
+    """Extracted entities, if entity extraction is enabled."""
+    keywords: list[tuple[str, float]] | None = None
+    """Extracted keywords and their scores, if keyword extraction is enabled."""
     detected_languages: list[str] | None = None
     """Languages detected in the extracted content, if language detection is enabled."""
 
@@ -160,12 +179,28 @@ class ExtractionConfig:
     """Post processing hooks to call after processing is done and before the final result is returned."""
     validators: list[ValidationHook] | None = None
     """Validation hooks to call after processing is done and before post-processing and result return."""
+    extract_entities: bool = False
+    """Whether to extract named entities from the content."""
+    extract_keywords: bool = False
+    """Whether to extract keywords from the content."""
+    keyword_count: int = 10
+    """Number of keywords to extract if extract_keywords is True."""
+    custom_entity_patterns: frozenset[tuple[str, str]] | None = None
+    """Custom entity patterns as a frozenset of (entity_type, regex_pattern) tuples."""
     auto_detect_language: bool = False
     """Whether to automatically detect language and configure OCR accordingly."""
     language_detection_config: LanguageDetectionConfig | None = None
     """Configuration for language detection. If None, uses default settings."""
+    spacy_entity_extraction_config: SpacyEntityExtractionConfig | None = None
+    """Configuration for spaCy entity extraction. If None, uses default settings."""
 
     def __post_init__(self) -> None:
+        if self.custom_entity_patterns is not None and isinstance(self.custom_entity_patterns, dict):
+            object.__setattr__(self, "custom_entity_patterns", frozenset(self.custom_entity_patterns.items()))
+        if self.post_processing_hooks is not None and isinstance(self.post_processing_hooks, list):
+            object.__setattr__(self, "post_processing_hooks", tuple(self.post_processing_hooks))
+        if self.validators is not None and isinstance(self.validators, list):
+            object.__setattr__(self, "validators", tuple(self.validators))
         from kreuzberg._ocr._easyocr import EasyOCRConfig
         from kreuzberg._ocr._paddleocr import PaddleOCRConfig
         from kreuzberg._ocr._tesseract import TesseractConfig

kreuzberg/extraction.py

@@ -1,12 +1,14 @@
 from __future__ import annotations
 
 from pathlib import Path
-from typing import TYPE_CHECKING, Final, cast
+from typing import TYPE_CHECKING, Any, Final, cast
 
 import anyio
 
 from kreuzberg import ExtractionResult
 from kreuzberg._chunker import get_chunker
+from kreuzberg._entity_extraction import extract_entities, extract_keywords
+from kreuzberg._language_detection import detect_languages
 from kreuzberg._mime_types import (
     validate_mime_type,
 )
@@ -24,15 +26,7 @@ if TYPE_CHECKING:
 DEFAULT_CONFIG: Final[ExtractionConfig] = ExtractionConfig()
 
 
-async def _validate_and_post_process_async(result: ExtractionResult, config: ExtractionConfig) -> ExtractionResult:
-    for validator in config.validators or []:
-        await run_maybe_sync(validator, result)
-
-    if config.auto_detect_language and result.content:
-        from kreuzberg._language_detection import detect_languages
-
-        result.detected_languages = detect_languages(result.content, config.language_detection_config)
-
+def _validate_and_post_process_helper(result: ExtractionResult, config: ExtractionConfig) -> ExtractionResult:
     if config.chunk_content:
         result.chunks = _handle_chunk_content(
             mime_type=result.mime_type,
@@ -40,6 +34,39 @@ async def _validate_and_post_process_async(result: ExtractionResult, config: Ext
             content=result.content,
         )
 
+    if config.extract_entities:
+        try:
+            result.entities = extract_entities(
+                result.content,
+                custom_patterns=config.custom_entity_patterns,
+            )
+        except RuntimeError:
+            result.entities = None
+
+    if config.extract_keywords:
+        try:
+            result.keywords = extract_keywords(
+                result.content,
+                keyword_count=config.keyword_count,
+            )
+        except RuntimeError:
+            result.keywords = None
+
+    if config.auto_detect_language:
+        result.detected_languages = detect_languages(
+            result.content,
+            config=config.language_detection_config,
+        )
+
+    return result
+
+
+async def _validate_and_post_process_async(result: ExtractionResult, config: ExtractionConfig) -> ExtractionResult:
+    for validator in config.validators or []:
+        await run_maybe_sync(validator, result)
+
+    result = _validate_and_post_process_helper(result, config)
+
     for post_processor in config.post_processing_hooks or []:
         result = await run_maybe_sync(post_processor, result)
 
@@ -50,17 +77,7 @@ def _validate_and_post_process_sync(result: ExtractionResult, config: Extraction
     for validator in config.validators or []:
         run_sync_only(validator, result)
 
-    if config.auto_detect_language and result.content:
-        from kreuzberg._language_detection import detect_languages
-
-        result.detected_languages = detect_languages(result.content, config.language_detection_config)
-
-    if config.chunk_content:
-        result.chunks = _handle_chunk_content(
-            mime_type=result.mime_type,
-            config=config,
-            content=result.content,
-        )
+    result = _validate_and_post_process_helper(result, config)
 
     for post_processor in config.post_processing_hooks or []:
         result = run_sync_only(post_processor, result)
@@ -72,7 +89,7 @@ def _handle_chunk_content(
     mime_type: str,
     config: ExtractionConfig,
     content: str,
-) -> list[str]:
+) -> Any:
     chunker = get_chunker(mime_type=mime_type, max_characters=config.max_chars, overlap_characters=config.max_overlap)
     return chunker.chunks(content)
 

{kreuzberg-3.5.0.dist-info → kreuzberg-3.6.0.dist-info}/METADATA

@@ -1,12 +1,12 @@
 Metadata-Version: 2.4
 Name: kreuzberg
-Version: 3.5.0
+Version: 3.6.0
 Summary: A text extraction library supporting PDFs, images, office documents and more
 Project-URL: homepage, https://github.com/Goldziher/kreuzberg
 Author-email: Na'aman Hirschfeld <nhirschfed@gmail.com>
 License: MIT
 License-File: LICENSE
-Keywords: document-processing,image-to-text,ocr,pandoc,pdf-extraction,rag,table-extraction,tesseract,text-extraction,text-processing
+Keywords: document-processing,entity-extraction,image-to-text,keyword-extraction,named-entity-recognition,ner,ocr,pandoc,pdf-extraction,rag,spacy,table-extraction,tesseract,text-extraction,text-processing
 Classifier: Development Status :: 5 - Production/Stable
 Classifier: Intended Audience :: Developers
 Classifier: License :: OSI Approved :: MIT License
@@ -36,16 +36,19 @@ Requires-Dist: typing-extensions>=4.14.0; python_version < '3.12'
 Provides-Extra: all
 Requires-Dist: click>=8.2.1; extra == 'all'
 Requires-Dist: easyocr>=1.7.2; extra == 'all'
+Requires-Dist: fast-langdetect>=0.3.2; extra == 'all'
 Requires-Dist: gmft>=0.4.2; extra == 'all'
-Requires-Dist: litestar[opentelemetry,standard,structlog]>=2.1.6; extra == 'all'
+Requires-Dist: keybert>=0.9.0; extra == 'all'
+Requires-Dist: litestar[opentelemetry,standard,structlog]>=2.16.0; extra == 'all'
 Requires-Dist: paddleocr>=3.1.0; extra == 'all'
 Requires-Dist: paddlepaddle>=3.1.0; extra == 'all'
 Requires-Dist: rich>=14.0.0; extra == 'all'
 Requires-Dist: semantic-text-splitter>=0.27.0; extra == 'all'
 Requires-Dist: setuptools>=80.9.0; extra == 'all'
+Requires-Dist: spacy>=3.8.7; extra == 'all'
 Requires-Dist: tomli>=2.0.0; (python_version < '3.11') and extra == 'all'
 Provides-Extra: api
-Requires-Dist: litestar[opentelemetry,standard,structlog]>=2.1.6; extra == 'api'
+Requires-Dist: litestar[opentelemetry,standard,structlog]>=2.16.0; extra == 'api'
 Provides-Extra: chunking
 Requires-Dist: semantic-text-splitter>=0.27.0; extra == 'chunking'
 Provides-Extra: cli
@@ -54,10 +57,13 @@ Requires-Dist: rich>=14.0.0; extra == 'cli'
 Requires-Dist: tomli>=2.0.0; (python_version < '3.11') and extra == 'cli'
 Provides-Extra: easyocr
 Requires-Dist: easyocr>=1.7.2; extra == 'easyocr'
+Provides-Extra: entity-extraction
+Requires-Dist: keybert>=0.9.0; extra == 'entity-extraction'
+Requires-Dist: spacy>=3.8.7; extra == 'entity-extraction'
 Provides-Extra: gmft
 Requires-Dist: gmft>=0.4.2; extra == 'gmft'
 Provides-Extra: langdetect
-Requires-Dist: fast-langdetect>=0.2.0; extra == 'langdetect'
+Requires-Dist: fast-langdetect>=0.3.2; extra == 'langdetect'
 Provides-Extra: paddleocr
 Requires-Dist: paddleocr>=3.1.0; extra == 'paddleocr'
 Requires-Dist: paddlepaddle>=3.1.0; extra == 'paddleocr'

{kreuzberg-3.5.0.dist-info → kreuzberg-3.6.0.dist-info}/RECORD

@@ -1,17 +1,18 @@
-kreuzberg/__init__.py,sha256=zZ_puArNdw0pQk93BV99fXCxzkHFKXB9kINn8-6-y24,1408
+kreuzberg/__init__.py,sha256=wVxbug-w1cO2xHcP04Bf6QeIKmT2Ep6aeenb8EOYLA0,1534
 kreuzberg/__main__.py,sha256=s2qM1nPEkRHAQP-G3P7sf5l6qA_KJeIEHS5LpPz04lg,183
 kreuzberg/_chunker.py,sha256=2eHSRHcZdJ2ZjR3in49y3o9tPl5HMO3vkbnMqaVCbHI,1887
 kreuzberg/_cli_config.py,sha256=WD_seFjbuay_NJv77vGLBW6BVV9WZNujdzf3zQkhzPc,5691
 kreuzberg/_constants.py,sha256=Bxc8oiN-wHwnWXT9bEiJhTUcu1ygPpra5qHirAif3b4,191
+kreuzberg/_entity_extraction.py,sha256=EIasBGpkZ-3FwivjEpisz23LilTwx8os-IbfrDtzNl4,7815
 kreuzberg/_gmft.py,sha256=e-UpYwizRX_V-dn0a7ja0Z9nShAmDKA1Q7HThJy8cyA,14856
 kreuzberg/_language_detection.py,sha256=22-uXoOu_ws0K8Hz2M7U_SF9QX3npRYLhntAE1dNLFU,3283
 kreuzberg/_mime_types.py,sha256=QgX-k8aI4lTKArObDM0TFPt7DUjUVwWrdIaIZDh_XQY,7815
 kreuzberg/_playa.py,sha256=rU6ii2Qnrj8tkDYlSiab5h-BCYLJnUg4QwSLVDEXF5g,11883
 kreuzberg/_registry.py,sha256=c2B_PJbaL0q3ab2eNmj_0jldeyMaqgvRwkZqUU4MM5Q,3290
-kreuzberg/_types.py,sha256=Tnl9yP56dn8ziBZk1sorNk1ZHZbJYMjSoqh7xxImFHs,8092
+kreuzberg/_types.py,sha256=U72a4SXS1e-zV8cXG0tiozMy9mX9wFM1ma6sVz7HpJo,9936
 kreuzberg/cli.py,sha256=S0w2nGXBWPFn1NhxppW7dpUwB9f_3ymFuWSAB2aRu9g,12465
 kreuzberg/exceptions.py,sha256=xRaiJh11i8E6Nc-gAQPgNW5xvhiiFBhRS-CBbCEbHQM,2881
-kreuzberg/extraction.py,sha256=Jz0f31Mm90mBkWwn0L3vn3z7-irdwNIzMHWByIj5d_I,17005
+kreuzberg/extraction.py,sha256=mdH45bMAAUUNXYT7UrNyWJ2oD_gXuLUU-NyuYxQM884,17459
 kreuzberg/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 kreuzberg/_api/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 kreuzberg/_api/main.py,sha256=kZCMPPzP4BGzEege9pdhQTJPKKVjCaC6kZdMMeaqP2M,2599
@@ -46,8 +47,8 @@ kreuzberg/_utils/_serialization.py,sha256=AhZvyAu4KsjAqyZDh--Kn2kSWGgCuH7udio8lT
 kreuzberg/_utils/_string.py,sha256=owIVkUtP0__GiJD9RIJzPdvyIigT5sQho3mOXPbsnW0,958
 kreuzberg/_utils/_sync.py,sha256=oT4Y_cDBKtE_BFEoLTae3rSisqlYXzW-jlUG_x-dmLM,4725
 kreuzberg/_utils/_tmp.py,sha256=hVn-VVijIg2FM7EZJ899gc7wZg-TGoJZoeAcxMX-Cxg,1044
-kreuzberg-3.5.0.dist-info/METADATA,sha256=jJXbwUuTXevmry2VVg1H8d6rEzebILJyN7q7kJ0M9mQ,8790
-kreuzberg-3.5.0.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
-kreuzberg-3.5.0.dist-info/entry_points.txt,sha256=VdoFaTl3QSvVWOZcIlPpDd47o6kn7EvmXSs8FI0ExLc,48
-kreuzberg-3.5.0.dist-info/licenses/LICENSE,sha256=-8caMvpCK8SgZ5LlRKhGCMtYDEXqTKH9X8pFEhl91_4,1066
-kreuzberg-3.5.0.dist-info/RECORD,,
+kreuzberg-3.6.0.dist-info/METADATA,sha256=zlqw5yTQit-jYeZVnM27kPsn2mCfulpL8wssptrQR8Q,9160
+kreuzberg-3.6.0.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+kreuzberg-3.6.0.dist-info/entry_points.txt,sha256=VdoFaTl3QSvVWOZcIlPpDd47o6kn7EvmXSs8FI0ExLc,48
+kreuzberg-3.6.0.dist-info/licenses/LICENSE,sha256=-8caMvpCK8SgZ5LlRKhGCMtYDEXqTKH9X8pFEhl91_4,1066
+kreuzberg-3.6.0.dist-info/RECORD,,