Genie Framework: un framework para Julia

Genie Framework es:

un marco de código abierto con todo lo que necesita para crear rápidamente aplicaciones web centradas en datos y listas para producción con Julia.

En este blog ya hemos escrito sobre Julia:

Un lenguaje de programación enfocado al cálculo, estadística y la matemática en general.

La documentación oficial nos dice:

Genie Framework es un potente framework web integral para el lenguaje de programación Julia, ideal para crear interfaces de usuario interactivas, API y aplicaciones web de producción. Ofrece un enfoque sencillo y de bajo código que facilita el desarrollo web a los usuarios de Julia, incluso a aquellos sin experiencia previa en desarrollo web.

Existen dos versiones:

• Genie Builder, la profesional. 
• Open Source, la de uso libre.

La versión Open Source tiene tres componentes principales:

1. Genie.jl: proporciona herramientas de backend y frontend para que puedas crear aplicaciones web y APIs completas basadas en tu código Julia. 
2.  Stipple.jl: Para una interactividad en tiempo real y una interfaz de usuario completa, como la que se necesita en un panel de control, proporciona una capa de interfaz de usuario reactiva. 
3.  SearchLight.jl: Para la persistencia de la base de datos, el ORM de Genie, que se puede añadir en cualquier momento.

¿Necesito tener Julia Language instalado en mi máquina? Sí, se necesita. Podemos descargarlo desde este enlace:

https://julialang.org/downloads/

Si usas Windows puedes obtenerlo de la Microsoft Store o abrir una terminal y pegar esto:

winget install --name Julia --id 9NJNWW8PVKMN -e -s msstore

Comencemos creando un directorio y posicionarnos sobre el mismo:

1 2	$ mkdir proyecto $ cd proyecto

Crear el proyecto con Julia:

1	$ julia --project

Dentro del REPL de Julia, agregamos el Framework:

1	pkg> add GenieFramework

Este comando instala Genie.jl, Stipple.jl y sus dependencias en su proyecto.

Creamos un archivo ``app.jl``. Escribimos lo siguiente:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19

module App using GenieFramework @genietools @app begin @in name = "Genie" end function ui() [ h1("Mi primera aplicacion Genie") input("Introduce tu nombre", :nombre) p("Hola, {{message}}!") ] end @page("/", ui) end

Salimos del modo Pkg pulsando la tecla Retroceso. Luego, en el REPL de Julia, cargamos y ejecutamos la aplicación:

1 2 3

using GenieFramework Genie.loadapp() up()

Abrimos el navegador en la ruta:

http://localhost:8000

¡Hemos creado nuestra primera aplicación con Genie Framework!

Enlaces:

https://genieframework.com/
https://codemonkeyjunior.blogspot.com/search?q=julia

LangChain, un marco para desarrollar aplicaciones impulsadas por LLMs

LangChain es un marco diseñado para simplificar la creación de aplicaciones que integran LLMs (grandes modelos de lenguajes). LangChain proporciona todos los componentes básicos de la integración de IA en un único marco. Ofrece una arquitectura modular, flexible y escalable, fácil de mantener.

Pero, ¿Qué es un LLM (Large Language Model)?

Es un tipo de inteligencia artificial que puede comprender y generar texto en lenguaje humano.

Ahora, ¿Qué se necesita saber para aprender LangChain? Aquí una breve lista:

1. Programación en Python. 
2. Conceptos de inteligencia artificial y modelos de lenguaje (Ej. Entender qué son los modelos de lenguaje grandes (LLMs) como GPT, LLaMA o BERT). 
3. Procesamiento de lenguaje natural (NLP). 
4. Bases de datos y almacenamiento. 
5. Conceptos de APIs y servicios en la nube

Herramientas necesarias:

• Es necesario instalar o tener instalado Python en su última versión. 
• Instalar LangChain.

Podemos instalarlo de la siguiente forma:

$ pip install langchain

Un ejemplo sencillo:

holamundo.py

import getpass
import os

if not os.environ.get("OPENAI_API_KEY"):
  os.environ["OPENAI_API_KEY"] = getpass.getpass("Enter API key for OpenAI: ")

from langchain.chat_models import init_chat_model

model = init_chat_model("gpt-4o-mini", model_provider="openai")

model.invoke("Hola, mundo!")

Si queremos profundizar sobre el tema podemos acceder a este enlace:

https://python.langchain.com/docs/introduction/

Continuaremos con este tema en próximas entregas.

Enlaces:

https://www.langchain.com/

GCP: línea de comandos de bigquery

La herramienta de línea de comandos bq es una herramienta de línea de comandos basada en Python para BigQuery.

Nos sirve para ejecutar consultas SQL de BigQuery. Veamos algunos ejemplos de cómo usarlo:

Listar version:

1	$ bq version

Obtener ayuda:

1

$ bq help

Listar datasets, jobs, etc.

1 2 3

$ bq ls $ bq ls --location=US $ bq ls --dataset=mydataset

Mostrar información sobre los dataset, jobs, etc.:

1 2 3

$ bq show mydataset $ bq show mydataset.mytable $ bq show --job=job_id

Eliminar datasets, tablas, etc.:

1 2 3

$ bq rm mydataset $ bq rm mydataset.mytable $ bq rm --job=job_id

Consultar datos de una tabla:

1	$ bq query --nouse_legacy_sql "SELECT name, age FROM mi_dataset.mi_tabla WHERE age > 30 LIMIT 10"

Crear un nuevo dataset:

1	$ bq mk --dataset mi_proyecto:mi_nuevo_dataset

Carga un archivo CSV local a una tabla en BigQuery:

1	$ bq load --source_format=CSV --autodetect mi_dataset.mi_tabla ./datos.csv

Exportar datos a Google Cloud Storage

1	$ bq extract --destination_format=CSV mi_dataset.mi_tabla gs://mi_bucket/salida.csv

Ejecutar un script desde un archivo:

1	$ bq query --nouse_legacy_sql < query.sql

Verificar el estado de un job:

1	$ bq show -j job_id

Para poder usarlo, debes estar autenticado:

1	$ gcloud auth login

Además de haber configurado tu proyecto:

1	$ gcloud config set project mi_proyecto

Aquí un script shell para realizar una consulta:

myshell.sh

1 2 3 4 5 6 7 8 9 10 11 12

#!/bin/bash gcloud config set project myProject bq query --use_legacy_sql=false --destination_table=myDataset.myTable \ 'SELECT word, SUM(word_count) AS count FROM `bigquery-public-data`.samples.shakespeare WHERE word LIKE "%raisin%" GROUP BY word'

Dar permisos:

1	$ sudo chmod 777 myshell.sh

Ejecución:

1	$ sh -x myshell.sh

La herramienta de línea de comandos bq de Google BigQuery es muy útil para interactuar con BigQuery desde la terminal.

En próximas entregas ampliaremos los ejemplos de su uso.

Enlaces:

https://medium.com/data-nuggets/11-basic-bigquery-bq-commands-for-data-interaction-59e0d7cee84c
https://stackoverflow.com/questions/76906880/how-to-run-saved-queries-using-bq-command-line-tool
https://cloud.google.com/bigquery/docs/bq-command-line-tool

Padrino: un framework web creado sobre Sinatra

Padrino es un framework web que está creado sobre la biblioteca web Sinatra.

Como hemos mencionado, Sinatra es un framework web ligero y es semejante a otros como Flask que tiene como base al lenguaje Python.

Instalando Padrino

Para instalarlo debemos teclear:

$ gem install padrino

Listamos para verificar instalación:

$ gem list

Creando un proyecto:

$ padrino g project hola_mundo

Nos ubicamos en el directorio creado:

$ cd hola_mundo

Tecleamos lo siguiente:

$ bundle --binstubs

Advertencia: ¡Este framework es bastante complicado de configurar si usamos una versión de Ruby mayor a la 3.0 !

Debemos modificar el archivo Gemfile

source 'https://rubygems.org'
ruby '3.3.4'
gem 'rake'
gem 'rack', '~> 2.2.0' # Especifica una versión compatible
gem 'padrino', '0.15.3'
gem 'webrick'

Hallar el archivo archivo router.rb en una ruta similar a la de:

C:\Users\HP\.local\share\gem\ruby\3.3.0\gems\padrino-core-0.15.3\lib\padrino-core

Lo editamos en la línea 61, añadiendo y sustityendo la línea por:

#match = Regexp.new("^#{Regexp.quote(path).gsub('/', '/+')}(.*)", nil, 'n')
match = Regexp.new("^#{Regexp.quote(path).gsub('/', '/+')}(.*)", nil)

Debemos ejecutar esto para instalar las dependencias descritas en el Gemfile:

$ bundle install

Editamos el programa app.rb

module HolaMundo

  class HolaMundo::App
    get '/' do
      "Hola, mundo"
    end
  end
end

Ejecutamos la aplicación y abrimos el navegador en la ruta http://localhost:3000/

$ bundle exec padrino start

¡Hemos creado nuestra primera y última aplicación usando este Framework!

Conclusión: No recomiendo este framework, ya que la configuración y la resolución de errores te puede llevar mucho tiempo. Considero que Sinatra es mejor y, aunque no lo he usado, Ruby on Rails también son mejores opciones.

Enlaces:

https://padrinorb.com/
https://sinatrarb.com/

Creando una aplicación web con Sinatra (Calculadora de pulsaciones)

Sinatra es un framework web ligero para el lenguaje Ruby que nos permite crear aplicaciones de una manera más sencilla que usando Ruby on Rails (quizás haremos un post al respecto).

En esta ocasión crearemos una sencilla aplicación que nos permita obtener el número de pulsaciones de una persona teniendo estas fórmulas:

No. pulsaciones masculina = (220 - edad) 
No. pulsaciones femenina = (226 - edad)

Requisitos:

1. Tener instalado Ruby. 
2. Tener nociones de HTML, CSS y Javacript. 
3. Tener nociones de Ruby (obviamente).

Comenzaremos con crear un directorio llamado ``pulse_calculator`` y nos posicionamos sobre este.

$ mkdir pulse_calculator
$ cd pulse_calculator

Dentro de esta crearemos una carpeta llamada ``views``. Esta nos servirá para crear las vistas de la aplicación web.

Ahora crearemos un archivo llamado ``Gemfile`` (sin ninguna extensión). Abrimos el archivo y colocamos lo siguiente:

source 'https://rubygems.org'

gem 'sinatra'
gem 'sinatra-contrib'

Es necesario ejecutarlo para instalar las dependencias, lo haremos de la siguiente forma:

$ bundle install

Crearemos el programa principal ``app.rb``, el cual contendrá la lógica del cálculo del número de pulsaciones. Se tomará en cuenta la edad y el género (masculino y femenino) para ello.

require 'sinatra'
require 'sinatra/reloader' if development?

# Ruta para el formulario (home)
get '/' do
  erb :index
end

# Ruata para ver el resultado
post '/calculate' do
  @name = params[:name]
  @age = params[:age].to_i
  @gender = params[:gender]

  # Calculo tomando el genero
  @pulse = if @gender == 'Femenino'
             226 - @age
           else
             220 - @age
           end

  erb :result
end

Como se puede observar:

• La ruta será GET "/" para el formulario de ingreso de datos. 
• La ruta POST "/calculate" para la vista de resultados obtenidos.
• Los datos a tomar en cuenta será la edad y género.

Dentro de la carpeta ``views`` crearemos dos archivos que serán las vistas:

• index.erb , para el formulario de entrada de datos. 
• result.erb , para mostrar los resultados.

index.erb

<!DOCTYPE html>
<html>
<head>
  <title>Pulsaciones Calculator</title>
  <style>
    body { font-family: Arial, sans-serif; margin: 50px; }
    .form-container { border: 1px solid black; padding: 20px; width: 300px; }
    label { display: block; margin: 10px 0 5px; }
    input, select, button { width: 100%; padding: 5px; margin-bottom: 10px; }
    button { background-color: #ccc; border: none; cursor: pointer; }
  </style>
</head>
<body>
  <div class="form-container">
    <h2>Pulsaciones Calculator</h2>
    <form action="/calculate" method="post">
      <label>Nombre:</label>
      <input type="text" name="name" required>

      <label>Edad:</label>
      <input type="number" name="age" required>

      <label>Género:</label>
      <select name="gender" required>
        <option value="Masculino">Masculino</option>
        <option value="Femenino">Femenino</option>
      </select>

      <button type="submit">Calcular</button>
    </form>
  </div>
</body>
</html>

result.erb

<!DOCTYPE html>
<html>
<head>
  <title>Resultados</title>
  <style>
    body { font-family: Arial, sans-serif; margin: 50px; }
    .result-container { border: 1px solid black; padding: 20px; width: 300px; }
    .result-box { border: 2px solid purple; padding: 10px; margin-top: 20px; }
    .pulse { color: red; }
  </style>
</head>
<body>
  <div class="result-container">
    <h2>Pulsaciones Calculator</h2>
    <p><strong>Nombre:</strong> <%= @name %></p>
    <p><strong>Edad:</strong> <%= @age %></p>
    <p><strong>Género:</strong> <%= @gender %></p>

    <div class="result-box">
      <h3>Resultados</h3>
      <p>Número de pulsaciones obtenidas: <span class="pulse"><%= @pulse %> pulsaciones</span></p>
    </div>
  </div>
</body>
</html>

Ejecutamos la aplicación web:

$ ruby app.rb

Si todo va bien, se ejcutará la aplicación web. Abrimos un navegador en la dirección:

http://[::1]:4567/

ó

http://localhost:4567/

¡Hemos creado nuestra aplicación para calcular pulsaciones con Sinatra!

Continuaremos con esta serie en fururas entregas.

Enlaces:

https://sinatrarb.com/
https://www.netguru.com/blog/ruby-on-rails-versus-sinatra
https://blog.appsignal.com/2023/05/31/how-to-use-sinatra-to-build-a-ruby-application.html
https://medium.com/simform-engineering/explore-sinatra-and-its-potential-for-building-web-apps-8463a2db0a0b