Docling Python: دليل عملي لمعالجة الملفات في 2026

pip install docling

from docling.document_converter import DocumentConverter

# Create a converter
converter = DocumentConverter()

# Convert a document
result = converter.convert("document.pdf")
document = result.document

# Export to markdown
markdown_text = document.export_to_markdown()
print(markdown_text)

from docling.document_converter import DocumentConverter
import requests
import tempfile

converter = DocumentConverter()

# Local file
result = converter.convert("/path/to/document.pdf")

# Remote URL - download first
url = "https://example.com/document.pdf"
response = requests.get(url)
with tempfile.NamedTemporaryFile(suffix='.pdf', delete=False) as tmp:
    tmp.write(response.content)
    tmp_path = tmp.name

result = converter.convert(tmp_path)
# Don't forget to clean up
import os
os.unlink(tmp_path)

from docling.document_converter import DocumentConverter
from docling.chunking import HybridChunker
from transformers import AutoTokenizer

# Convert document
converter = DocumentConverter()
result = converter.convert("document.pdf")
document = result.document

# Set up chunker with your tokenizer
tokenizer = AutoTokenizer.from_pretrained("bert-base-uncased")
chunker = HybridChunker(
    tokenizer=tokenizer,
    max_tokens=512  # Maximum tokens per chunk
)

# Get chunks
chunks = list(chunker.chunk(document))

# Process chunks
for i, chunk in enumerate(chunks):
    print(f"Chunk {i}: {chunk.text[:100]}...")

from docling.document_converter import DocumentConverter

converter = DocumentConverter()
result = converter.convert("document.pdf")
document = result.document

# Access document metadata
if hasattr(document, 'meta'):
    print(f"Document metadata: {document.meta}")

# Chunk with metadata
from docling.chunking import HybridChunker
from transformers import AutoTokenizer

tokenizer = AutoTokenizer.from_pretrained("bert-base-uncased")
chunker = HybridChunker(tokenizer=tokenizer, max_tokens=512)

for chunk in chunker.chunk(document):
    print(f"Text: {chunk.text[:50]}...")
    if hasattr(chunk, 'meta'):
        print(f"Metadata: {chunk.meta}")

from docling.document_converter import DocumentConverter
from docling.chunking import HybridChunker
from transformers import AutoTokenizer

def process_document(file_path, max_tokens=512):
    """Process a document and return chunks ready for embedding."""

    # Step 1: Convert document
    converter = DocumentConverter()
    result = converter.convert(file_path)
    document = result.document

    # Step 2: Set up chunker
    tokenizer = AutoTokenizer.from_pretrained("bert-base-uncased")
    chunker = HybridChunker(
        tokenizer=tokenizer,
        max_tokens=max_tokens
    )

    # Step 3: Get chunks
    chunks = []
    for i, chunk in enumerate(chunker.chunk(document)):
        chunks.append({
            'text': chunk.text,
            'index': i,
            'source': file_path
        })

    return chunks

# Usage
chunks = process_document("my_document.pdf")
print(f"Created {len(chunks)} chunks")
for chunk in chunks:
    print(f"Chunk {chunk['index']}: {chunk['text'][:50]}...")

import os
from pathlib import Path

def process_folder(folder_path, max_tokens=512):
    """Process all PDFs in a folder."""
    all_chunks = []

    for file_path in Path(folder_path).glob("*.pdf"):
        try:
            chunks = process_document(str(file_path), max_tokens)
            all_chunks.extend(chunks)
            print(f"Processed {file_path.name}: {len(chunks)} chunks")
        except Exception as e:
            print(f"Failed to process {file_path.name}: {e}")

    return all_chunks

from docling.document_converter import DocumentConverter

converter = DocumentConverter()
result = converter.convert("document.pdf")
document = result.document

# Export to markdown
markdown = document.export_to_markdown()
with open("output.md", "w", encoding="utf-8") as f:
    f.write(markdown)

# Export to plain text
text = document.export_to_text()
with open("output.txt", "w", encoding="utf-8") as f:
    f.write(text)

def safe_process_document(file_path):
    """Process document with error handling."""
    try:
        converter = DocumentConverter()
        result = converter.convert(file_path)
        return result.document
    except FileNotFoundError:
        print(f"File not found: {file_path}")
        return None
    except Exception as e:
        print(f"Error processing {file_path}: {e}")
        return None

from docling.document_converter import DocumentConverter
from docling.chunking import HybridChunker
from transformers import AutoTokenizer, AutoModel
import torch

# Process and embed documents
def build_document_index(file_paths):
    converter = DocumentConverter()
    tokenizer = AutoTokenizer.from_pretrained("bert-base-uncased")
    model = AutoModel.from_pretrained("bert-base-uncased")
    chunker = HybridChunker(tokenizer=tokenizer, max_tokens=512)

    document_index = []

    for file_path in file_paths:
        # Convert and chunk
        result = converter.convert(file_path)
        chunks = list(chunker.chunk(result.document))

        # Create embeddings for each chunk
        for chunk in chunks:
            inputs = tokenizer(chunk.text, return_tensors="pt",
                             truncation=True, max_length=512)
            with torch.no_grad():
                embedding = model(**inputs).last_hidden_state.mean(dim=1)

            document_index.append({
                'text': chunk.text,
                'embedding': embedding,
                'source': file_path
            })

    return document_index

# For most sentence transformers (512 token limit)
chunker = HybridChunker(tokenizer=tokenizer, max_tokens=512)

# For models with larger context windows
chunker = HybridChunker(tokenizer=tokenizer, max_tokens=2048)

from concurrent.futures import ThreadPoolExecutor

def process_multiple_files(file_paths, max_workers=4):
    with ThreadPoolExecutor(max_workers=max_workers) as executor:
        results = list(executor.map(process_document, file_paths))
    return results