Nachrichtensymbol
Zum Fußzeileninhalt springen
  1. IronPDF for Python
  2. IronPDF for Python Blog
  3. Hilfe für Python
  4. Grakn Python
PYTHON-HILFE

Grakn Python (Wie es funktioniert: Ein Leitfaden für Entwickler)

Curtis Chau
Curtis Chau
Aktualisiert:

In der heutigen Programmierwelt entwickeln sich Datenbanken weiter, um den Anforderungen neuer Anwendungen gerecht zu werden. Während traditionelle relationale Datenbanken weiterhin verwendet werden, haben wir jetzt Fortschritte wie Object-Relational Mapping (ORM), die es Entwicklern ermöglichen, mit Datenbanken mit Hilfe von höheren Programmierabstraktionen zu interagieren, anstatt sich ausschließlich auf SQL zu verlassen. Dieser Ansatz vereinfacht die Datenverwaltung und fördert eine sauberere Code-Organisation. Zusätzlich sind NoSQL-Datenbanken als nützliche Werkzeuge für den Umgang mit unstrukturierten Daten entstanden, insbesondere in Big-Data-Anwendungen und Echtzeitanalysen.

Cloud-native Datenbanken haben ebenfalls einen bedeutenden Einfluss, da sie skalierbare, zuverlässige und verwaltete Dienste bieten, die die Last der Wartung der zugrunde liegenden Infrastruktur reduzieren. Darüber hinaus kombinieren NewSQL- und Graphdatenbanken die Stärken von SQL und NoSQL, indem sie die Zuverlässigkeit von relationalen Datenbanken mit der Flexibilität von NoSQL bieten. Diese Mischung macht sie geeignet für viele moderne Anwendungen. Durch die Integration dieser verschiedenen Datenbanktypen mit innovativen Programmierparadigmen können wir skalierbare und adaptive Lösungen schaffen, die den datenorientierten Anforderungen von heute entsprechen. Grakn, jetzt bekannt als TypeDB, exemplifiziert diesen Trend, indem es die Verwaltung und Abfrage von Wissensgraphen unterstützt. In diesem Artikel werden wir Grakn (TypeDB) und seine Integration mit IronPDF erkunden, einem wichtigen Werkzeug zur programmgesteuerten Erzeugung und Manipulation von PDFs.

Was ist Grakn?

Grakn (jetzt TypeDB), erstellt von Grakn Labs, ist eine Wissensgraph-Datenbank, die darauf ausgelegt ist, komplexe Netzwerke von Daten zu verwalten und zu analysieren. Es zeichnet sich dadurch aus, komplexe Beziehungen innerhalb bestehender Datensätze zu modellieren und leistungsstarke Schlussfolgerungsfähigkeiten über gespeicherte Daten zu bieten. Grakn's Abfragesprache Graql ermöglicht präzise Datenmanipulation und -abfragen und unterstützt die Entwicklung intelligenter Systeme, die wertvolle Erkenntnisse aus komplexen Datensätzen extrahieren können. Durch die Nutzung der Kernfunktionen von Grakn können Organisationen Datenstrukturen mit einer robusten und intelligenten Wissensrepräsentation verwalten.

Grakn Python (Wie es funktioniert: Ein Leitfaden für Entwickler): Abbildung 1 - TypeDB-Webseite

Graql, die Abfragesprache von Grakn, wurde speziell dafür entwickelt, effektiv mit dem Grakn-Wissensgraphmodell zu interagieren, was detaillierte und nuancierte Datenumwandlungen ermöglicht. Aufgrund seiner horizontalen Skalierbarkeit und der Fähigkeit, große Datensätze zu verarbeiten, ist TypeDB gut geeignet für Bereiche wie Finanzen, Gesundheitswesen, Wirkstoffforschung und Cybersicherheit, in denen das Verständnis und das Management komplexer Graphstrukturen entscheidend sind.

Installation und Konfiguration von Grakn in Python

Installation von Grakn

Für in Grakn (TypeDB) interessierte Python-Entwickler ist die Installation der typedb-driver Bibliothek essenziell. Dieses offizielle Client-Tool erleichtert die Interaktion mit TypeDB. Benutzen Sie den folgenden pip-Befehl, um diese Bibliothek zu installieren:

pip install typedb-driver
pip install typedb-driver
SHELL

Einrichten des TypeDB-Servers

Stellen Sie sicher, dass Ihr TypeDB-Server vor dem Schreiben von Code läuft. Befolgen Sie die Installations- und Einrichtungsanweisungen auf der TypeDB-Website für Ihr Betriebssystem. Nach der Installation können Sie den folgenden Befehl verwenden, um den TypeDB-Server zu starten:

./typedb server
./typedb server
SHELL

Grakn in Python verwenden

Python-Code zur Interaktion mit TypeDB

Dieser Abschnitt illustriert das Herstellen einer Verbindung zu einem TypeDB-Server, das Einrichten eines Datenbank-Schemas sowie das Ausführen grundlegender Operationen wie Dateneinfügung und -abruf.

Ein Datenbankschema erstellen

Im folgenden Codeblock definieren wir die Datenbankstruktur, indem wir einen Typ namens person mit zwei Attributen: name und age erstellen. Wir öffnen eine Sitzung im SCHEMA-Modus, die strukturelle Änderungen ermöglicht. Hier ist, wie das Schema definiert und übernommen wird:

from typedb.driver import TypeDB, SessionType, TransactionType

# Connect to TypeDB server
client = TypeDB.core_driver("localhost:1729")

# Create a database (if not already created)
database_name = "example_db"
if not client.databases().contains(database_name):
    client.databases().create(database_name)

with client.session(database_name, SessionType.SCHEMA) as session:
    with session.transaction(TransactionType.WRITE) as transaction:
        transaction.query().define("""
        define
        person sub entity, owns name, owns age;
        name sub attribute, value string;
        age sub attribute, value long;
        """)
        transaction.commit()
from typedb.driver import TypeDB, SessionType, TransactionType

# Connect to TypeDB server
client = TypeDB.core_driver("localhost:1729")

# Create a database (if not already created)
database_name = "example_db"
if not client.databases().contains(database_name):
    client.databases().create(database_name)

with client.session(database_name, SessionType.SCHEMA) as session:
    with session.transaction(TransactionType.WRITE) as transaction:
        transaction.query().define("""
        define
        person sub entity, owns name, owns age;
        name sub attribute, value string;
        age sub attribute, value long;
        """)
        transaction.commit()
PYTHON

Einfügen von Daten

Nach der Festlegung des Schemas fügt das Skript Daten in die Datenbank ein. Wir öffnen eine Sitzung im DATA-Modus, geeignet für Datenoperationen, und führen eine Einfügeabfrage durch, um eine neue person-Einheit mit dem Namen "Alice" und dem Alter 30 hinzuzufügen:

# Insert data into the database
with client.session(database_name, SessionType.DATA) as session:
    with session.transaction(TransactionType.WRITE) as transaction:
        # Create a person entity
        transaction.query().insert("""
        insert $p isa person, has name "Alice", has age 30;
        """)
        transaction.commit()
# Insert data into the database
with client.session(database_name, SessionType.DATA) as session:
    with session.transaction(TransactionType.WRITE) as transaction:
        # Create a person entity
        transaction.query().insert("""
        insert $p isa person, has name "Alice", has age 30;
        """)
        transaction.commit()
PYTHON

Datenabfrage

Letztendlich rufen wir Informationen von der Datenbank ab, indem wir nach Entitäten mit dem Namen "Alice" abfragen. Wir öffnen eine neue Sitzung im DATA-Modus und initiieren eine Lese-Transaktion mit TransactionType.READ. Die Ergebnisse werden verarbeitet, um den Namen und das Alter zu extrahieren und anzuzeigen:

# Query the data from the database
with client.session(database_name, SessionType.DATA) as session:
    with session.transaction(TransactionType.READ) as transaction:
        # Query entities where the person has the name 'Alice'
        results = transaction.query().match("""
        match 
        $p isa person, has name "Alice";
        $p has name $n, has age $a;
        get;
        """)
        for result in results:
            person_name = result.get("n").get_value()
            person_age = result.get("a").get_value()
            print(f"Person Name: {person_name}, Age: {person_age}")
# Query the data from the database
with client.session(database_name, SessionType.DATA) as session:
    with session.transaction(TransactionType.READ) as transaction:
        # Query entities where the person has the name 'Alice'
        results = transaction.query().match("""
        match 
        $p isa person, has name "Alice";
        $p has name $n, has age $a;
        get;
        """)
        for result in results:
            person_name = result.get("n").get_value()
            person_age = result.get("a").get_value()
            print(f"Person Name: {person_name}, Age: {person_age}")
PYTHON

Ausgabe

Grakn Python (Wie es funktioniert: Ein Leitfaden für Entwickler): Abbildung 2 - Konsolenausgabe von der Abfrage der Datenbank

Schließen der Client-Verbindung

Um Ressourcen ordnungsgemäß freizugeben und weitere Interaktionen mit dem TypeDB-Server zu verhindern, schließen Sie die Client-Verbindung mit client.close():

# Close the client connection
client.close()
# Close the client connection
client.close()
PYTHON

Einführung in IronPDF

Grakn Python (Wie es funktioniert: Ein Leitfaden für Entwickler): Abbildung 3 - IronPDF für Python-Webseite

IronPDF für Python ist eine leistungsstarke Bibliothek für die programmgesteuerte Erstellung und Manipulation von PDF-Dateien. Es bietet umfassende Funktionalität für die Erstellung von PDFs aus HTML, das Zusammenführen von PDF-Dateien und das Anmerken bestehender PDF-Dokumente. IronPDF ermöglicht auch die Konvertierung von HTML- oder Webinhalten in hochwertige PDFs, was es zur idealen Wahl für die Erstellung von Berichten, Rechnungen und anderen Dokumenten im festen Layout macht.

Die Bibliothek bietet erweiterte Funktionen wie Inhaltsextraktion, Dokumentenverschlüsselung und Seitenlayout-Anpassung. Durch die Integration von IronPDF in Python-Anwendungen können Entwickler Dokumentenerstellungs-Workflows automatisieren und die allgemeinen Fähigkeiten ihrer PDF-Bearbeitung verbessern.

Installation der IronPDF-Bibliothek

Um die IronPDF-Funktionalität in Python zu aktivieren, installieren Sie die Bibliothek mit pip:

pip install ironpdf
pip install ironpdf
SHELL

Integration von Grakn TypeDB mit IronPDF

Durch die Kombination von TypeDB und IronPDF in einer Python-Umgebung können Entwickler effizient PDF-Dokumentationen basierend auf komplex strukturierten Daten in einer Grakn (TypeDB) Datenbank erzeugen und verwalten. Hier ist ein Integrationsbeispiel:

from typedb.driver import TypeDB, SessionType, TransactionType
from ironpdf import *
import warnings

# Suppress potential warnings
warnings.filterwarnings('ignore')

# Replace with your own license key
License.LicenseKey = "YOUR LICENSE KEY GOES HERE"

# Initialize data list
data = []

# Connect to TypeDB server
client = TypeDB.core_driver("localhost:1729")

# Query the data from the database
with client.session(database_name, SessionType.DATA) as session:
    with session.transaction(TransactionType.READ) as transaction:
        # Fetch details of persons named 'Alice'
        results = transaction.query().match("""
        match 
        $p isa person, has name "Alice";
        $p has name $n, has age $a;
        get;
        """)
        for result in results:
            person_name = result.get("n").get_value()
            person_age = result.get("a").get_value()
            data.append({"name": person_name, "age": person_age})

# Close the client connection
client.close()

# Create a PDF from HTML content
html_to_pdf = ChromePdfRenderer()
content = "<h1>Person Report</h1>"
for item in data:
    content += f"<p>Name: {item['name']}, Age: {item['age']}</p>"

# Render the HTML content as a PDF
pdf_document = html_to_pdf.RenderHtmlAsPdf(content)

# Save the PDF to a file
pdf_document.SaveAs("output.pdf")
from typedb.driver import TypeDB, SessionType, TransactionType
from ironpdf import *
import warnings

# Suppress potential warnings
warnings.filterwarnings('ignore')

# Replace with your own license key
License.LicenseKey = "YOUR LICENSE KEY GOES HERE"

# Initialize data list
data = []

# Connect to TypeDB server
client = TypeDB.core_driver("localhost:1729")

# Query the data from the database
with client.session(database_name, SessionType.DATA) as session:
    with session.transaction(TransactionType.READ) as transaction:
        # Fetch details of persons named 'Alice'
        results = transaction.query().match("""
        match 
        $p isa person, has name "Alice";
        $p has name $n, has age $a;
        get;
        """)
        for result in results:
            person_name = result.get("n").get_value()
            person_age = result.get("a").get_value()
            data.append({"name": person_name, "age": person_age})

# Close the client connection
client.close()

# Create a PDF from HTML content
html_to_pdf = ChromePdfRenderer()
content = "<h1>Person Report</h1>"
for item in data:
    content += f"<p>Name: {item['name']}, Age: {item['age']}</p>"

# Render the HTML content as a PDF
pdf_document = html_to_pdf.RenderHtmlAsPdf(content)

# Save the PDF to a file
pdf_document.SaveAs("output.pdf")
PYTHON

Dieser Code demonstriert die Verwendung von TypeDB und IronPDF in Python, um Daten aus einer TypeDB-Datenbank zu extrahieren und einen PDF-Bericht zu erstellen. Es stellt eine Verbindung zu einem lokalen TypeDB-Server her, ruft Entitäten mit dem Namen "Alice" ab und ermittelt deren Namen und Alter. Die Ergebnisse werden dann zur Konstruktion von HTML-Inhalten verwendet, die mit dem ChromePdfRenderer von IronPDF in ein PDF-Dokument umgewandelt und als "output.pdf" gespeichert werden.

Ausgabe

Grakn Python (Wie es funktioniert: Ein Leitfaden für Entwickler): Abbildung 4 - Ausgegebenes PDF aus dem vorherigen Code

Lizenzierung

Ein Lizenzschlüssel ist erforderlich, um Wasserzeichen aus den erzeugten PDFs zu entfernen. Sie können sich für eine kostenlose Testversion unter diesem Link registrieren. Bitte beachten Sie, dass keine Kreditkarte für die Registrierung benötigt wird; nur eine E-Mail-Adresse ist für die kostenlose Testversion erforderlich.

Grakn Python (Wie es funktioniert: Ein Leitfaden für Entwickler): Abbildung 5 - IronPDF-Lizenzierungsplan

Abschluss

Grakn (jetzt TypeDB) integriert mit IronPDF bietet eine robuste Lösung zur Verwaltung und Analyse großer Datenmengen aus PDF-Dokumenten. Mit den Möglichkeiten von IronPDF in Datenextraktion und -manipulation und Grakn's Expertise in der Modellierung komplexer Beziehungen und Schlussfolgerungen können Sie unstrukturierte Dokumentendaten in strukturierte, abfragbare Informationen umwandeln.

Diese Integration vereinfacht die Extraktion wertvoller Einblicke aus PDFs und verbessert deren Abfrage- und Analysefähigkeiten mit erhöhter Präzision. Durch die Kombination von Grakn's Hochleistungs-Datenmanagement mit den PDF-Verarbeitungsfunktionen von IronPDF können Sie effizientere Wege zur Handhabung von Informationen entwickeln, um bessere Entscheidungen zu treffen und tiefere Einblicke in komplexe Datensätze zu erhalten. Iron Software bietet auch eine Vielzahl von Bibliotheken an, um die Anwendungsentwicklung über mehrere Betriebssysteme und Plattformen hinweg zu erleichtern, einschließlich Windows, Android, macOS, Linux und mehr.

Curtis Chau
Curtis Chau
  Jetzt mit dem Ingenieurteam chatten
Technischer Autor

Curtis Chau hat einen Bachelor-Abschluss in Informatik von der Carleton University und ist spezialisiert auf Frontend-Entwicklung mit Expertise in Node.js, TypeScript, JavaScript und React. Leidenschaftlich widmet er sich der Erstellung intuitiver und ästhetisch ansprechender Benutzerschnittstellen und arbeitet gerne mit modernen Frameworks sowie der Erstellung gut strukturierter, optisch ansprechender ...

Weiterlesen

Verwandte Artikel

30-Tage-Testversion → Volles Produkt. Keine Grenzen. Keine Karte. Gratis testen