Grakn Python (Cómo Funciona: Una Guía para Desarrolladores)

Introducción

En el mundo de la programación actual, las bases de datos están cambiando para adaptarse a las necesidades de las nuevas aplicaciones. Aún utilizamos bases de datos relacionales tradicionales, pero ahora también tenemos cosas geniales como el mapeo objeto-relacional.(ORM). Esto permite a los programadores trabajar con bases de datos utilizando trucos de programación sofisticados en lugar del viejo y aburrido SQL. Este nuevo método facilita el manejo de datos y mantiene el código en buen estado. También tenemos bases de datos NoSQL ahora. Estos son excelentes para tratar con datos desordenados y funcionan bien para grandes volúmenes de datos y procesamiento rápido de números.

Las bases de datos nativas de la nube también están revolucionando las cosas. Nos brindan servicios flexibles, confiables y gestionados para que no tengamos que preocuparnos tanto por cuidar la tecnología detrás de todo. Las bases de datos gráficas NewSQL mezclan las buenas partes de SQL y NoSQL. Nos brindan la fiabilidad de las bases de datos relacionales y la flexibilidad de NoSQL, lo que funciona para muchas aplicaciones modernas. Al reunir todos estos tipos de bases de datos de nuevas maneras de codificación, podemos crear soluciones que funcionen bien, crezcan y cambien con los tiempos en nuestro mundo loco por los datos. Grakn ahora puede conocerse como TypeDB, pero aún cumple su propósito: gestión y consulta de gráficos de conocimiento. En este artículo, vamos a aprender más sobre Grakn(TypeDB)y cómo podemos integrarlo con IronPDF, una herramienta indispensable al generar y manipular PDFs de manera programática.

¿Qué es Grakn?

Grakn(ahoraTypeDB), creado por Grakn Labs, es la base de datos de gráficos de conocimiento para gestionar y analizar redes complejas de datos. En el núcleo se encuentran las capacidades para modelar relaciones complicadas entre los datos existentes y proporcionar un razonamiento avanzado sobre los datos persistentes. El lenguaje inteligente de Grakn, Graql, permitirá consultar y manipular datos con precisión, respaldando el desarrollo de sistemas inteligentes que pueden obtener grandes y valiosos conocimientos a partir de conjuntos de datos complejos. Al aprovechar las características principales de Grakn, las organizaciones pueden gestionar la comprensión de las estructuras de datos con una representación del conocimiento muy poderosa e inteligente.

Su lenguaje de búsqueda, Graql, está diseñado para trabajar con el modelo de datos de grafo de conocimiento de Grakn, permitiendo a los usuarios cambiar los datos de maneras detalladas y sutiles. Porque puede expandirse lateralmente y manejar grandes conjuntos de datos, TypeDB encaja bien en áreas como finanzas, cuidado de la salud, descubrimiento de medicamentos y seguridad en línea, donde comprender y manejar estructuras de datos gráficas complejas es fundamental.

Instalación y Configuración de Grakn en Python

Instalación de Grakn

Para desarrolladores de Python que buscan usar Grakn(TypeDB), necesitas instalar la biblioteca typedb-driver. Este cliente oficial te permite interactuar con TypeDB. Aquí está el comando que te permite instalar esta biblioteca con pip:

pip install typedb-driver

pip install typedb-driver

Configurar el servidor TypeDB

Antes de comenzar a escribir código, asegúrate de que tu servidor TypeDB esté funcionando. Puedes obtener TypeDB instalándolo desde el sitio web de TypeDB y siguiendo las directrices de configuración para tu sistema operativo.

Luego puedes usar este comando para iniciar el servidor TypeDB:

typedb server

typedb server

Uso de Grakn en Python

Código Python para interactuar con TypeDB

A continuación, se muestra una ilustración sencilla que muestra cómo establecer una conexión con un servidor TypeDB, configurar un esquema y realizar tareas fundamentales como insertar información y recuperarla.

Creando un esquema de base de datos

La siguiente parte del programa está dedicada a configurar una estructura de base de datos. El código nombra a la base de datos como "example_db" y la abre en modo SCHEMA, lo que permite cambios en la estructura. En este modo, inicia una transacción de tipo WRITE para realizar estos cambios. Se define una consulta para delinear la estructura, creando un tipo llamado persona con dos atributos: nombre y edad. El atributo name es de tipo string y el atributo age es de tipo entero largo. Una vez que se define la estructura, la transacción se guarda en la base de datos para hacer permanentes estas modificaciones.

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()

Inserción de datos

Después de establecer el esquema, el script procede a insertar datos en la base de datos. Para hacer esto, se abre una nueva sesión en modo DATA, que es el más apropiado para operaciones de datos. La transacción de escritura se lleva a cabo primero en esta sesión y se emite una consulta de inserción para incluir una nueva entidad de tipo persona con el nombre "Alice" y edad 30. Los datos, al ser insertados, finalizan la transacción y se actualizan los cambios en la base de datos.

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()

Consulta de datos

El último paso que haremos es obtener la información necesaria haciendo una pregunta a la base de datos. El script abre una nueva sesión en modo DATA y comienza una transacción de lectura utilizando TransactionType.READ. A continuación, obtiene los detalles de las personas que tienen el nombre "Alice". La cláusula match determina que las entidades de tipo persona deben tener el nombre especificado, y la cláusula fetch obtiene sus atributos de nombre y edad. Los resultados se procesan a continuación para extraer los valores de nombre y edad de cada resultado. Esta información se muestra en la consola.

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}")

Salida

Cerrando la conexión del cliente

Cuando se completan todas las operaciones de datos, el script cierra la conexión del cliente usando client.close(). Este paso asegura que los recursos se liberen correctamente y que no se intenten más interacciones con el servidor TypeDB.

En general, este código presenta una forma sencilla de establecer una conexión con un servidor TypeDB, definir un esquema, insertar datos, consultar esos datos y cerrar la conexión de manera ordenada.

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()

Presentación de IronPDF

IronPDFpara Python es una biblioteca que puede ayudarte a crear y manejar archivos PDF de forma programática. Incluye una amplia funcionalidad para crear PDFs a partir de HTML, fusionar dos o más archivos PDF y utilizar PDFs existentes con texto, imágenes y anotaciones. IronPDF, por otro lado, ofrece a los usuarios una forma de convertir páginas HTML o contenido web en PDFs de alta calidad, que pueden usarse para crear informes, facturas y otros documentos que tienen un diseño fijo.

La biblioteca ofrece funciones avanzadas que incluyen extracción de contenido, encriptación de documentos y personalización del diseño de página. Los flujos de trabajo de generación de documentos pueden automatizarse al integrar IronPDF con aplicaciones de Python, permitiendo así a los desarrolladores mejorar la funcionalidad general de sus añadidos haciéndolos robustos en términos de capacidades de manejo de PDF.

Instalación de la biblioteca IronPDF

Use pip para instalar paquetes que permitan a Python habilitar la capacidad de IronPDF.

pip install ironpdf

pip install ironpdf

Integrando Grakn TypeDB con IronPDF

El uso de TypeDB e IronPDF en el entorno de Python hace que la generación, gestión y otra documentación relacionada con PDF, basada en los datos complejamente estructurados en un Grakn, sea más eficaz.(TypeDB)base de datos más eficiente. A continuación, se presenta una descripción paso a paso de cómo podría lograr esta integración:

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")

Este ejemplo de código muestra cómo usar TypeDB e IronPDF en Python para obtener datos de una base de datos TypeDB y crear un informe PDF. Primero, se conecta a un servidor local TypeDB y busca entidades llamadas "Alice" para obtener sus nombres y edades. Los resultados se imprimen en la consola. Después de cerrar la conexión del cliente TypeDB, el código utiliza ChromePdfRenderer de IronPDF para convertirHTMLcontenido en un PDF. El contenido HTML que incluye un informe de personas que consta de sus nombres y edades ha sido recuperado y guardado como "output.pdf" después de ser convertido a un documento PDF. Los fragmentos también contienen supresión de advertencias y una clave de licencia vacía que está configurada para IronPDF, lo cual puede ser el caso para que la biblioteca funcione sin advertencias de licencia.

Salida

Licencias

Se necesita una clave de licencia para que el código funcione sin una marca de agua. Puedes registrarte para obtener una licencia de prueba gratuita en este **Enlace. Tenga en cuenta que no se requiere presentar una tarjeta de crédito para obtener uno. Solo necesitas proporcionar tu dirección de correo electrónico para registrarte en la versión de prueba gratuita.

Conclusión

Grakn(ahora TypeDB) conIronPDFes una solución sólida para gestionar y analizar grandes volúmenes de datos derivados de documentos PDF. Esto se lograría aprovechando las capacidades robustas de IronPDF para extraer y manipular datos en PDF y utilizando las potentes características de la base de datos gráfica Grakn en la modelación de relaciones intrincadas y la ejecución de razonamientos mejorados. En este sentido, ahora tienes el poder de componer un flujo de trabajo que transforma datos de documentos no estructurados en datos estructurados y consultables.

En el proceso, simplifica la extracción de información valiosa de los PDFs, mejorando su capacidad de consulta y análisis de los datos con mayor precisión. La gestión de datos de alto nivel de Grakn, cuando se combina con el procesamiento de PDFs de IronPDF, potencia mejores formas de manejar la información hacia una mejor toma de decisiones e ideas sobre conjuntos de datos complejos. **IronSoftwaretambién proporciona una variedad de bibliotecas que facilitan la creación de programas para una variedad de sistemas operativos y plataformas, incluidos Windows, Android, MAC, Linux, etc.