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

Einführung

In der heutigen Programmierwelt ändern sich Datenbanken, um mit den Anforderungen neuer Apps Schritt zu halten. Wir verwenden immer noch herkömmliche relationale Datenbanken, aber jetzt haben wir auch coole Dinge wie Object-Relational Mapping.(ORM). Dies ermöglicht es Programmierern, mit Datenbanken unter Verwendung raffinierter Programmiertechniken zu arbeiten, anstatt mit langweiligem alten SQL. Diese neue Methode erleichtert es, Daten zu handhaben und den Code in gutem Zustand zu halten. Wir haben jetzt auch NoSQL-Datenbanken. Diese eignen sich hervorragend zur Bewältigung von unordentlichen Daten und funktionieren gut für Big Data und schnelle Zahlenverarbeitung.

Cloud-native Datenbanken wirbeln ebenfalls einiges durcheinander. Sie bieten uns flexible, zuverlässige und verwaltete Dienste, sodass wir uns keine großen Sorgen um die Pflege der dahinterliegenden Technik machen müssen. NewSQL-Grafdatenbanken kombinieren die guten Eigenschaften von SQL und NoSQL. Sie bieten uns die Zuverlässigkeit relationaler Datenbanken und die Flexibilität von NoSQL, was für viele moderne Apps funktioniert. Indem wir all diese Datenbanktypen auf neue Weise in die Programmierung integrieren, können wir Lösungen schaffen, die gut funktionieren, wachsen und sich in unserer datenverrückten Welt mit der Zeit verändern. Grakn mag jetzt als TypeDB bekannt sein, erfüllt aber weiterhin seinen Zweck: das Verwalten und Abfragen von Wissensgraphen. In diesem Artikel werden wir mehr über Grakn erfahren.(TypeDB)und wie wir es mit IronPDF integrieren können, einem unverzichtbaren Werkzeug bei der programmgesteuerten Erstellung und Bearbeitung von PDFs.

Was ist Grakn?

Grakn(jetztTypeDB), erstellt von Grakn Labs, ist die Knowledge-Graph-Datenbank zur Verwaltung und Analyse komplexer Datennetzwerke. Im Kern liegen die Fähigkeiten, komplizierte Beziehungen zwischen vorhandenen Daten zu modellieren und fortgeschrittene Schlussfolgerungen über gespeicherte Daten bereitzustellen. Die intelligente Sprache von Grakn, Graql, ermöglicht es, Daten präzise abzufragen und zu manipulieren – dies unterstützt die Entwicklung intelligenter Systeme, die wertvolle Erkenntnisse aus komplexen Datensätzen ableiten können. Durch die Nutzung der Grakn-Kernfunktionen können Organisationen Datenstrukturen mit einer äußerst leistungsfähigen, intelligenten Wissensdarstellung verwalten.

Seine Abfragesprache Graql ist darauf ausgelegt, mit dem Grakn-Wissensgraph-Datenmodell zu arbeiten, wodurch Benutzer Daten auf detaillierte und subtile Weise ändern können. Weil es seitwärts skalieren und mit großen Datenmengen umgehen kann, passt TypeDB gut in Bereiche wie Finanzen, Gesundheitswesen, Medikamentenforschung und Online-Sicherheit, wo das Verstehen und Bearbeiten komplexer Graphdatenstrukturen entscheidend ist.

Installation und Konfiguration von Grakn in Python

Installation von Grakn

Für Python-Entwickler, die Grakn verwenden möchten(TypeDB)müssen Sie die Bibliothek typedb-driver installieren. Dieser offizielle Client ermöglicht die Interaktion mit TypeDB. Hier ist der Befehl, mit dem Sie diese Bibliothek mit pip installieren können:

pip install typedb-driver

pip install typedb-driver

Einrichtung des TypeDB-Servers

Bevor Sie mit dem Schreiben des Codes beginnen, stellen Sie sicher, dass Ihr TypeDB-Server läuft. Sie können TypeDB erhalten, indem Sie es von der TypeDB-Website herunterladen und die Einrichtungshinweise für Ihr Betriebssystem befolgen.

Sie können dann diesen Befehl verwenden, um den TypeDB-Server zu starten:

typedb server

typedb server

Verwendung von Grakn in Python

Python-Code zur Interaktion mit TypeDB

Hier ist eine einfache Illustration, die zeigt, wie man eine Verbindung zu einem TypeDB-Server herstellt, ein Schema einrichtet und grundlegende Aufgaben wie das Einfügen und Abrufen von Informationen durchführt.

Erstellung eines Datenbankschemas

Der folgende Teil des Programms ist dem Einrichten einer Datenbankstruktur gewidmet. Der Code benennt die Datenbank als "example_db" und öffnet sie im SCHEMA-Modus, der Änderungen an der Struktur ermöglicht. In diesem Modus wird eine Transaktion vom Typ WRITE gestartet, um diese Änderungen vorzunehmen. Eine Abfrage wird definiert, um die Struktur zu skizzieren, indem ein Typ namens Person mit zwei Attributen erstellt wird: Name und Alter. Das Attribut "name" ist vom Typ String, und das Attribut "age" ist vom Typ Long Integer. Sobald die Struktur definiert ist, wird die Transaktion in der Datenbank gespeichert, um diese Änderungen dauerhaft zu machen.

from typedb.driver import TypeDB, SessionType, TransactionType, TypeDBOptions, TypeDBCredential
# Connect to TypeDB server
client = TypeDB.core_driver("localhost:1729")
# Create a database (if not already created)
database_name = "example_db"
client.databases().create(database_name)  # Ensure the database is created
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, TypeDBOptions, TypeDBCredential
# Connect to TypeDB server
client = TypeDB.core_driver("localhost:1729")
# Create a database (if not already created)
database_name = "example_db"
client.databases().create(database_name)  # Ensure the database is created
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()

Einfügen von Daten

Nachdem das Schema festgelegt ist, fügt das Skript Daten in die Datenbank ein. Um dies zu tun, wird eine neue Sitzung im DATA-Modus geöffnet, der am besten für Datenoperationen geeignet ist. Die Schreibtransaktion wird zuerst in dieser Sitzung durchgeführt und eine Einfügeabfrage wird ausgegeben, um eine neue Entität vom Typ Person mit dem Namen "Alice" und dem Alter 30 einzufügen. Die Daten, sobald sie eingefügt sind, machen die Transaktion abgeschlossen und die Datenbankänderungen werden aktualisiert.

from typedb.driver import TypeDB, SessionType, TransactionType, TypeDBOptions, TypeDBCredential
# Connect to TypeDB server
client = TypeDB.core_driver("localhost:1729")
# 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 using the logical inference of typeDB
        transaction.query.insert("""
        insert $p isa person, has name "Alice", has age 30;
        """)
        transaction.commit()

from typedb.driver import TypeDB, SessionType, TransactionType, TypeDBOptions, TypeDBCredential
# Connect to TypeDB server
client = TypeDB.core_driver("localhost:1729")
# 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 using the logical inference of typeDB
        transaction.query.insert("""
        insert $p isa person, has name "Alice", has age 30;
        """)
        transaction.commit()

Daten abfragen

Der letzte Schritt, den wir machen werden, ist, die benötigten Informationen durch eine Anfrage an die Datenbank zu erhalten. Das Skript öffnet eine neue Sitzung im DATA-Modus und startet eine Lese-Transaktion mit TransactionType.READ. Dann ruft es die Details von Personen ab, die den Namen "Alice" haben. Der Match-Abschnitt bestimmt, dass die Entitäten vom Typ Person den angegebenen Namen haben müssen, und der Fetch-Abschnitt holt ihre Namens- und Altersattribute. Die Ergebnisse werden dann verarbeitet, um die Namen und Altersangaben aus jedem Ergebnis zu extrahieren. Diese Information wird auf der Konsole angezeigt.

from typedb.driver import TypeDB, SessionType, TransactionType, TypeDBOptions, TypeDBCredential
# 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:
        # Simple Query language for persons with name "Alice"
        results = list(transaction.query.fetch(f"""
        match 
        $p isa person, has name $fn;
        $fn = 'Alice';
        fetch 
        $p: name, age;
        """))
        for result in results:
            person_name = result.get('p')['name'][0]['value']
            person_age = result.get('p')['age'][0]['value']
            print(f"Person Name: {person_name}, Age: {person_age}")

from typedb.driver import TypeDB, SessionType, TransactionType, TypeDBOptions, TypeDBCredential
# 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:
        # Simple Query language for persons with name "Alice"
        results = list(transaction.query.fetch(f"""
        match 
        $p isa person, has name $fn;
        $fn = 'Alice';
        fetch 
        $p: name, age;
        """))
        for result in results:
            person_name = result.get('p')['name'][0]['value']
            person_age = result.get('p')['age'][0]['value']
            print(f"Person Name: {person_name}, Age: {person_age}")

Ausgabe

Die Verbindung mit dem Client schließen

Wenn alle Datenoperationen durchgeführt wurden, schließt das Skript die Clientverbindung mit client.close(). Dieser Schritt stellt sicher, dass Ressourcen ordnungsgemäß freigegeben werden und keine weiteren Interaktionen mit dem TypeDB-Server versucht werden.

Im Allgemeinen bietet dieser Code eine einfache Möglichkeit, eine Verbindung zu einem TypeDB-Server herzustellen, ein Schema zu definieren, Daten einzufügen, diese Daten abzufragen und die Verbindung sauber zu beenden.

from typedb.driver import TypeDB, SessionType, TransactionType, TypeDBOptions, TypeDBCredential
# Connect to TypeDB server
client = TypeDB.core_driver("localhost:1729")
# Close the client connection
client.close()

from typedb.driver import TypeDB, SessionType, TransactionType, TypeDBOptions, TypeDBCredential
# Connect to TypeDB server
client = TypeDB.core_driver("localhost:1729")
# Close the client connection
client.close()

Einführung in IronPDF

IronPDFfür Python ist eine Bibliothek, mit der Sie programmgesteuert PDF-Dateien erstellen und verwalten können. Es umfasst eine umfassende Funktionalität zum Erstellen von PDFs aus HTML, zum Zusammenführen von zwei oder mehr PDF-Dateien und zur Nutzung bestehender PDFs mit Text, Bildern und Anmerkungen. IronPDF hingegen bietet den Benutzern eine Möglichkeit, HTML-Seiten oder Webinhalte in hochwertige PDFs zu konvertieren, die zur Erstellung von Berichten, Rechnungen und anderen Dokumenten mit festem Layout verwendet werden können.

Die Bibliothek bietet erweiterte Funktionen, die Inhaltsextraktion, Dokumentenverschlüsselung und Seitengestaltung anpassen umfassen. Dokumentenerstellungs-Workflows können automatisiert werden, indem IronPDF mit Python-Anwendungen integriert wird, wodurch Entwickler die Gesamtfunktionalität ihrer Ergänzungen verbessern können, indem sie diese in Bezug auf PDF-Verarbeitungsfähigkeiten robust machen.

Installieren der IronPDF-Bibliothek

Verwenden Sie pip, um Pakete zu installieren, die es Python ermöglichen, IronPDF-Funktionalität zu aktivieren.

pip install ironpdf

pip install ironpdf

Integration von Grakn TypeDB mit IronPDF

Die Verwendung von TypeDB und IronPDF in der Python-Umgebung ermöglicht die Erstellung, Verwaltung und andere PDF-bezogene Dokumentation auf Basis der komplex strukturierten Daten in einem Grakn.(TypeDB)Datenbank effizienter. Hier ist eine schrittweise Übersicht, wie Sie diese Integration durchführen könnten:

from typedb.driver import TypeDB, SessionType, TransactionType, TypeDBOptions, TypeDBCredential
from ironpdf import *     import warnings
warnings.filterwarnings('ignore')
# Ensure that you have replaces the string with your own license key
License.LicenseKey = "YOUR LICENSE KEY GOES HERE";
data=[]
# Connect to TypeDB server
client = TypeDB.core_driver("localhost:1729")
# Create a database (if not already created)
database_name = "example_db"
# Query the data from the database
with client.session(database_name, SessionType.DATA) as session:
    with session.transaction(TransactionType.READ) as transaction:
        # Query for persons with name "Alice"
        results = list(transaction.query.fetch(f"""
        match 
        $fn == 'Alice';
        $p isa person, has name $fn;
       fetch
       $p: name, age;
        """)
        )
        for result in results:
            person_Name = result.get('p')['name'][0]['value']
            person_age = result.get('p')['age'][0]['value']
            data.append({"name": person_Name, "age": person_age})
# Close the client connection
client.close()
html_to_pdf = ChromePdfRenderer()
content = "<h1>Person Report</h1>"
for item in data:
    content += f"<p>Name: {item['name']}, Age: {item['age']}</p>"
pdf_document = html_to_pdf.RenderHtmlAsPdf(content)
pdf_document.SaveAs("output.pdf")

from typedb.driver import TypeDB, SessionType, TransactionType, TypeDBOptions, TypeDBCredential
from ironpdf import *     import warnings
warnings.filterwarnings('ignore')
# Ensure that you have replaces the string with your own license key
License.LicenseKey = "YOUR LICENSE KEY GOES HERE";
data=[]
# Connect to TypeDB server
client = TypeDB.core_driver("localhost:1729")
# Create a database (if not already created)
database_name = "example_db"
# Query the data from the database
with client.session(database_name, SessionType.DATA) as session:
    with session.transaction(TransactionType.READ) as transaction:
        # Query for persons with name "Alice"
        results = list(transaction.query.fetch(f"""
        match 
        $fn == 'Alice';
        $p isa person, has name $fn;
       fetch
       $p: name, age;
        """)
        )
        for result in results:
            person_Name = result.get('p')['name'][0]['value']
            person_age = result.get('p')['age'][0]['value']
            data.append({"name": person_Name, "age": person_age})
# Close the client connection
client.close()
html_to_pdf = ChromePdfRenderer()
content = "<h1>Person Report</h1>"
for item in data:
    content += f"<p>Name: {item['name']}, Age: {item['age']}</p>"
pdf_document = html_to_pdf.RenderHtmlAsPdf(content)
pdf_document.SaveAs("output.pdf")

Dieses Codebeispiel zeigt, wie man TypeDB und IronPDF in Python verwendet, um Daten aus einer TypeDB-Datenbank abzurufen und einen PDF-Bericht zu erstellen. Zunächst wird eine Verbindung zu einem lokalen TypeDB-Server hergestellt, um nach Entitäten mit dem Namen "Alice" zu suchen und deren Namen und Alter zurückzubekommen. Die Ergebnisse werden auf die Konsole gedruckt. Nach dem Schließen der TypeDB-Client-Verbindung verwendet der Code IronPDFs ChromePdfRenderer, um zu konvertierenHTMLInhalt in ein PDF. Der HTML-Inhalt, der einen Bericht über Personen enthält, einschließlich ihrer Namen und Alter, wurde abgerufen und als "output.pdf" gespeichert, nachdem er in ein PDF-Dokument konvertiert wurde. Die Code-Schnipsel enthalten auch Warnunterdrückung und einen leeren Lizenzschlüssel, der für IronPDF gesetzt ist, was der Fall sein kann, damit die Bibliothek ohne Lizenzwarnungen funktioniert.

Ausgabe

Lizenzvergabe

Ein Lizenzschlüssel ist erforderlich, damit der Code ohne Wasserzeichen funktioniert. Sie können sich für eine kostenlose Testlizenz registrieren unter diesemLink. Beachten Sie, dass Sie keine Kreditkarte vorlegen müssen, um eine zu erhalten. Sie müssen nur Ihre E-Mail-Adresse angeben, um sich für die kostenlose Testversion zu registrieren.

Schlussfolgerung

Grakn(jetzt TypeDB) mitIronPDFist eine starke Lösung für die Verwaltung und Analyse großer Datenmengen aus PDF-Dokumenten. Dies würde erreicht, indem man die robusten Fähigkeiten von IronPDF zur Extraktion und Manipulation von Daten in PDFs nutzt und die leistungsstarken Funktionen der Grakn-Grafdatenbank verwendet, um komplexe Beziehungen zu modellieren und erweitertes logisches Denken auszuführen. In dieser Hinsicht haben Sie jetzt die Möglichkeit, einen solchen Arbeitsablauf zu erstellen, der unstrukturierte Dokumentdaten in strukturierte und abfragbare Daten umwandelt.

Im Prozess vereinfacht es das Herausziehen wertvoller Erkenntnisse aus PDFs und verbessert ihre Abfrage- und Analysefähigkeit gegenüber den Daten mit erhöhter Präzision. Die hochrangige Datenverwaltung von Grakn, in Kombination mit der IronPDF-Verarbeitung von PDFs, ermöglicht bessere Möglichkeiten der Informationsverarbeitung für fundiertere Entscheidungsfindung und Einblicke in komplexe Datensätze. IronSoftwarebietet auch eine Vielzahl von Bibliotheken, die es Ihnen erleichtern, Programme für eine Reihe von Betriebssystemen und Plattformen zu erstellen, einschließlich Windows, Android, MAC, Linux usw.