%pip installieren "google-genai>=1"

von google importieren genai

# Client erstellen
api_key = "YOUR_API_KEY" # Ersetzen Sie durch Ihren API-Schlüssel.
client = genai.Client(api_key=api_key)

# Definieren Sie das zu verwendende Modell
model_id = "gemini-2.0-flash" # Verwenden Sie auch "gemini-2.0-flash-lite-preview-02-05" oder "gemini-2.0-pro-exp-02-05".

# PDF-Datei hochladen
rechnung_pdf = client.files.upload(file="rechnung.pdf", config={'display_name': 'rechnung'})

# Überprüfen, in wie viele Token die Datei umgewandelt wird
file_size = client.models.count_tokens(model=model_id, contents=invoice_pdf)
print(f'Datei: {Rechnung_pdf.display_name} entspricht {file_size.total_tokens} tokens')

# Musterausgabe: Datei: Rechnung entspricht 821 Token

def extract_structured_data(file_path: str, model: BaseModel).
    # Hochladen einer Datei in die Datei-API
    file = client.files.upload(file=file_path, config={'display_name': file_path.split('/')[-1].split('.') [0]})

    # Generierung einer strukturierten Antwort mit der Gemini-API
    prompt = f "Extrahiere die strukturierten Daten aus der folgenden PDF-Datei"
    response = client.models.generate_content(model=model_id,
                                             model=model_id, contents=[prompt, file],
                                             
                                                     'response_schema': model})

    # wandelt die Antwort in ein Pydantic-Modell um und gibt es zurück
    return response.parsed

from pydantic import BaseModel, Feld

class Item(BaseModel).
    description: str = Field(description="Die Beschreibung des Artikels")
    quantity: float = Field(description="Die Menge des Artikels")
    gross_worth: float = Field(description="Der Bruttowert des Artikels")

class Invoice(BaseModel).
    """Extrahiert die Rechnungsnummer, das Datum und alle Listenpositionen mit Beschreibung, Menge und Bruttowert sowie den Gesamtbruttowert.""""
    invoice_number: str = Field(description="Die Rechnungsnummer z.B. 1234567890")
    date: str = Field(description="Das Datum der Rechnung z.B. 2024-01-01")
    items: list[Item] = Field(description="Die Liste der Positionen mit Beschreibung, Menge und Bruttowert")
    total_gross_worth: float = Field(description="Der Gesamtbruttowert der Rechnung")

# Extrahieren der Daten anhand dieses Modells
Ergebnis = extract_structured_data("Rechnung.pdf", Rechnung)

# Ausgabe der Ergebnisse
print(f "Extrahierte Rechnung: {result.invoice_number} am {result.date} mit Gesamtbruttowert {result.total_gross_worth}")
for item in result.items: print(f "Artikel: {item_gross_worth}")
    print(f "Artikel: {Artikel.Beschreibung} mit Menge {Artikel.Menge} und Bruttowert {Artikel.Bruttowert}")

class Form(BaseModel).
    """Extrahieren Sie die Formularnummer, das Datum für den Beginn und das Ende des Geschäftsjahres sowie die Planverbindlichkeiten zu Beginn und am Ende des Jahres. """"
    form_number: str = Field(description="Die Formularnummer")
    start_date: str = Field(description="Effective Date")
    beginning_of_year: float = Field(description="Die Planverbindlichkeiten zu Beginn des Jahres")
    end_of_year: float = Field(description="Die Planverbindlichkeiten am Ende des Jahres")

# Daten extrahieren
result = extract_structured_data("handschriftliches_formular.pdf", Formular)

# Ausgabe der Ergebnisse
print(f'Extrahierte Formularnummer: {result.form_number} mit Startdatum {result.start_date}. \nPlanverbindlichkeiten Anfang des Jahres {result.beginning_of_year} und Ende des Jahres {result.end_of_year}')
# Ausgabebeispiel: Extrahierte Formularnummer: CA530082 mit Beginndatum 02/05/2022.
# Planverbindlichkeiten Anfang des Jahres 40000.0 und Ende des Jahres 55000.0

CHUNKING_PROMPT = """OCR die folgende Seite in Markdown. Tabellen sollten als HTML formatiert werden.
Umgeben Sie Ihre Ausgabe nicht mit dreifachen Backticks.
Unterteilen Sie das Dokument in Abschnitte von etwa 250 bis 1000 Wörtern. Unser Ziel ist
Unser Ziel ist es, Teile der Seite mit demselben semantischen Thema zu identifizieren.
Diese Chunks werden eingebettet und in einer RAG-Pipeline verwendet.
Umgeben Sie die Chunks mit   html-Tags.""""

# verwendet diese Eingabeaufforderung für die Verarbeitung
response = client.models.generate_content(
    model=model_id,
    contents=[CHUNKING_PROMPT, pdf_file]
)

chunked_content = response.text

class Person(BaseModel): first_name: str = Field(description="Der Vorname der Person")
    first_name: str = Field(description="Der Vorname der Person")
    last_name: str = Field(description="Der Nachname der Person")
    last_name: str = Field(description="Der Nachname der Person") last_name: str = Field(description="Der Nachname der Person")
    work_topics: list[Topic] = Field(description="Die Interessengebiete der Person, falls nicht angegeben, bitte eine leere Liste zurückgeben")

# Generieren einer Antwort unter Verwendung des Modells Person
prompt = "Philipp Schmid ist Senior AI Developer Relations Engineer bei Google DeepMind und arbeitet an Gemini, Gemma mit der Mission, jedem Entwickler zu helfen zu helfen, KI auf verantwortungsvolle Weise zu entwickeln und zu nutzen."
response = client.models.generate_content(
    model=model_id,
    content=prompt,
    config={'response_mime_type': 'application/json', 'response_schema': Person}
)

Das #-SDK wandelt die Antwort automatisch in ein Pydantic-Modell um
philipp: Person = response.parsed
print(f "Vorname ist {philipp.first_name}")

async def batch_process_pdfs(file_paths, model, batch_size=10):: results = [].
    results = []
    for i in range(0, len(file_paths), batch_size):: batch = file_paths[i:i+batch_size): batch = file_paths[i:i
        batch = file_paths[i:i+batch_size]: results = [] for i in range(0, len(file_paths), batch_size).
        tasks = [extract_structured_data(path, model) for path in batch]
        batch_results = await asyncio.gather(*tasks)
        results.extend(batch_results)
        print(f "Verarbeiteter Stapel {i//batch_size + 1}/{(len(file_paths)+batch_size-1)//batch_size}")
    Ergebnisse zurückgeben

def extract_with_retry(file_path, model, max_retries=3):: for attempt in range(max_retries)
    for attempt in range(max_retries).
        try.
            return extract_structured_data(file_path, model): for attempt in range(max_retries): try.
        except Exception as e: if attempt == max_retries
            if attempt == max_retries - 1: print(f "Failed to get to the file.
                print(f "Konnte {file_path} nach {max_retries} Versuchen nicht verarbeiten: {e}")
                return Keine
            print(f "Versuch {Versuch+1} fehlgeschlagen, erneuter Versuch: {e}")
            time.sleep(2 ** attempt) # exponentielle Wiederholungsstrategie

TABLE_EXTRACTION_PROMPT = """Extrahiert alle Tabellen aus der PDF-Datei als HTML-Tabellen.
Behalten Sie die exakte Struktur bei, einschließlich zusammengefügter Zellen, Überschriften und Formatierungen.
Jede Tabelle sollte semantisch vollständig sein und die Beziehungen zwischen den Zellen beibehalten.
Behalten Sie bei numerischen Werten deren exaktes Format bei, wie es im Dokument dargestellt ist. """"