nanobot es una plataforma de asistente personal de IA diseñada para ejecutarse en tu propia infraestructura, ya sea una laptop, un servidor pequeño o un contenedor en la nube (VPS). A diferencia de otros frameworks que se centran únicamente en el "prompt engineering", nanobot siguiendo la filosofía de OpenClaw, trata al agente de IA como un problema de infraestructura, construyendo un entorno de ejecución estructurado que gestiona sesiones, memoria, sandboxing de herramientas y enrutamiento de mensajes. Los LLM solo proveen inteligencia y razonamiento, nanobot prepara el terreno para que el agente pueda tomar control del sistema donde es instalado y ejecutar las herramientas.

Inspirado en OpenClaw, su propuesta radical es ofrecer funcionalidad completa de agente con un 99% menos de líneas de código. Mientras que los frameworks tradicionales suelen ser "cajas negras" complejas, nanobot mantiene un núcleo de aproximadamente 4,000 líneas, facilitando que desarrolladores e investigadores entiendan, modifiquen y extiendan el sistema.

Como Funciona nanobot: Visión general

Nanobot no es solo una interfaz para un API de modelos de lenguaje o un chatbot conectado a un LLM, es un entorno de ejecución que sigue una arquitectura limpia orientado a eventos. El sistema actúa como un puente entre múltiples interfaces de entrada (Telegram, Discord, Slack, etc.) y un núcleo de inteligencia centralizado.

El corazón del sistema es el Message Bus, que actúa como plano de control, desacoplando la capa de comunicación de la lógica del agente. Esto permite que una única instancia del agente sea accesible simultáneamente a través de diversos canales, manteniendo la coherencia del estado de la conversación y el acceso a herramientas en hardware local.

Componentes principales

1. Canales

Cada plataforma de mensajería utiliza un adaptador dedicado que implementa la clase BaseChannel. Estos adaptadores normalizan la entrada y salida de datos:

• Autenticación y Conexión: Utiliza diversos métodos según la plataforma, como polling para Telegram, WebSockets para Discord y Feishu, o un bridge de Node.js para WhatsApp.

• Normalización: Los canales extraen texto y manejan archivos multimedia (imágenes, voz) para convertirlos en un objeto estándar de entrada InboundMessage.

• Control de Acceso: Implementan listas de permitidos allowFrom para restringir quién puede interactuar con el bot a nivel de plataforma.

2. Interfaz de Control

Nanobot ofrece múltiples formas de interacción:

• CLI (Línea de Comandos): Es la interfaz principal para la administración. Permite iniciar el asistente en modo interactivo nanobot agent, gestionar configuraciones onboard y autenticar canales channels login.

• Modo Gateway: Permite que el sistema funcione en segundo plano conectando todos los canales de chat configurados simultáneamente.

3. Gateway

El Gateway es el punto central que coordina el estado del sistema. Sus responsabilidades incluyen:

• Gestión de Conexiones: Inicia y mantiene los hilos o tareas asíncronas para cada canal de chat activo.

• Servicios Proactivos: Aloja el servicio de Cron para tareas programadas y el sistema de Heartbeat, que despierta al agente cada 30 minutos para ejecutar tareas autónomas definidas en el archivo HEARTBEAT.md.

4. Entorno de Ejecución del Agente (Agent Runtime)

Representado por la clase AgentLoop, es donde ocurre el procesamiento de la IA. El runtime sigue un ciclo de cuatro pasos:

1. Resolución de Sesión: Identifica el historial de conversación específico para cada usuario o hilo de chat.

2. Construcción de Contexto: Ensambla el prompt del sistema combinando la identidad del agente, las habilidades skills, la memoria persistente y el historial de la sesión.

3. Invocación del Modelo: Interactúa con proveedores (OpenAI, Anthropic, Ollama, etc.) mediante una capa de abstracción que normaliza las APIs.

4. Ejecución de Herramientas: Intercepta las solicitudes de llamadas a herramientas del LLM para ejecutar comandos de sistema, búsquedas web o manipulación de archivos.

Iteración y Coordinación

La arquitectura de nanobot permite una coordinación fluida entre componentes:

• Message Bus: Utiliza colas asíncronas para mensajes entrantes y salientes, asegurando que el sistema sea responsivo incluso durante procesos intensivos del LLM.

• Sistema de Habilidades (Skills): Permite inyectar capacidades específicas (como gestión de GitHub o clima) mediante archivos Markdown en la capeta ~/.nanobot/skills/, que el agente carga dinámicamente según la necesidad.

• Herramientas Externas (MCP): Soporta el Model Context Protocol, lo que permite conectar servidores de herramientas externas y usarlos como si fueran capacidades nativas.

Flujo de mensaje de extremo a extremo

El flujo de un mensaje desde que el usuario lo envía hasta que recibe la respuesta sigue estos pasos técnicos:

• Ingesta: El ChannelLayer recibe el input y publica un InboundMessage en el bus. Un ejemplo podría ser recibir un mensaje de Telegram.

• Carga de Sesión: El AgentLoop extrae el mensaje y recupera el historial desde el SessionManager, ubicado en ~/.nanobot/sessions/ .

• Ensamblaje: El ContextBuilder construye el prompt del sistema incluyendo contexto, la memoria usando como base el MEMORY.md y herramientas.

• Bucle de Iteración:

  • Llama al LLM a través de un Provider (OpenRouter, Anthropic, OpenAI, etc.).

  • Si el modelo solicita herramientas (shell, filesystem, web, etc.), estas se ejecutan y los resultados se reinyecta en el contexto.

• Finalización: Una vez generada la respuesta de texto, se publica un OutboundMessage en el bus y el canal lo entrega al usuario.

Gestión de datos y estado

Nanobot almacena su estado de forma sencilla y transparente ~/.nanobot:

• Configuración: Un único archivo ~/.nanobot/config.json centraliza las claves de API y ajustes de canales.

• Memoria a largo plazo: Utiliza un archivo MEMORY.md en formato Markdown dentro del workspace. Esto permite que la memoria sea legible para humanos y fácil de editar manualmente.

• Historial de Sesión: Almacenado en archivos JSON individuales por usuario, permitiendo persistencia total entre reinicios.

Arquitectura de Seguridad

La seguridad se implementa en múltiples capas:

• Aislamiento del Workspace: Si se activa restrictToWorkspace, todas las operaciones de archivos y comandos de shell se confinan estrictamente al directorio ~/.nanobot/workspace/, bloqueando ataques de salto de directorio (path traversal).

• Control de Acceso: Las listas de permitidos allowFrom aseguran que solo usuarios autorizados puedan interactuar con el agente.

• Gestión de Claves: Las API keys se cargan como variables de entorno por solicitud y nunca se registran en los logs del sistema. Además las claves se almacenan con permisos restringidos (600).

Arquitecturas de despliegue

Nanobot soporta tres patrones principales:

1. Local/CLI: Ejecución directa mediante el binario para pruebas rápidas y desarrollo de herramientas simples o scripts.

2. Servicio de Linux (Systemd): Permite que el gateway se ejecute permanentemente en segundo plano, reiniciándose automáticamente tras fallos o reinicios del servidor y manteniendo el contexto por sesión.

3. Contenedor de Docker: Ideal para despliegues aislados, persistiendo la configuración y el workspace mediante volúmenes montados.

Conclusión

Nanobot demuestra que es posible construir una infraestructura de IA potente bajo una filosofía de simplicidad radical que hacen que su código no solo sea eficiente sino legible. Al separar las interfaces del runtime y mantener una base de código plana y modular, ofrece un sistema que es a la vez una herramienta de productividad diaria y una plataforma ideal para la investigación con agentes de IA.

Es, en esencia, la arquitectura mínima necesaria para un asistente que no solo responde, sino que actúa. No tiene el nivel de complejidad y funcionalidades que posee OpenClaw pero tampoco lo necesita, cumple con los objetivos que buscas en algo más que un agente, si OpenClaw se define como un sistema operativo para los Agentes, nanobot entonces sería un mini sistema operativo para agentes.

Ejemplo de implementación de la arquitectura

femtobot es un agente creado para demostrar una pequeña implementación de la arquitectura bajo la cual nanobot funciona, es una buena base de inspiración y estudio para este tipo de sistema de agentes.

https://github.com/rafnixg/femtobot

Referencias

Github oficial nanobot

Documentación técnica nanobot

Documentación femtobot

Al final de este tutorial tendremos configurado un workflow que construye y publica en PyPI de forma automática con cada nueva release que se cree en el repositorio de GitHub.

👉 Si aún no publicaste tu librería en PyPI, te recomiendo comenzar por este tutorial previo:

⚙️ ¿Qué es GitHub Actions?

GitHub Actions es una plataforma de CI/CD (Integración y Entrega Continua) integrada directamente en GitHub. Permite automatizar tareas dentro del ciclo de vida de tu proyecto, como ejecutar tests, construir paquetes, y desplegar código, todo sin salir de tu repositorio.

La magia está en los workflows, que son conjuntos de instrucciones definidas en archivos YAML. Estos workflows se ejecutan en respuesta a eventos específicos, como hacer un push, crear un tag, abrir un pull request o crear un nuevo release.

En el caso de una librería de Python, esto nos permite automatizar pasos como:

• Construir los paquetes (sdist y wheel)

• Publicar automáticamente en PyPI o TestPyPI cuando subimos una nueva versión

Con unas pocas líneas de configuración, podemos lograr que todo esto suceda de forma automática cada vez que haces un release, reduciendo errores y ganando tiempo.

📦 Automatizando la publicación en PyPI con GitHub Actions

✅ Requisitos previos

Antes de iniciar, asegúrate de tener:

• Un repositorio de GitHub con tu librería

• Una cuenta de PyPI

• Un API Token generado de tu cuenta de PyPI

👉 Si ya seguiste el tutorial anterior, deberías tener todo esto listo. Si no, te recomiendo revisarlo antes de seguir.

🔐 Agregar tu token de PyPI como secret en GitHub

Debemos configurar en nuestro repositorio un nuevo secret para usarlo en los workflows, para esto solo debemos seguir los siguientes pasos:

1. Ir a tu repositorio en GitHub.

2. Hacer clic en Settings.

3. En el menú lateral, clic en Secrets and variables → Actions.

4. Clic en New repository secret.

5. El nombre será PYPI_API_TOKEN y en el valor pegá tu API key de PyPI.

6. Clic en Add secret.

Esto es lo que usa GitHub Actions para autenticar y publicar la librería.

📁 Estructura de archivos

Ya con todo esto listo podemos empezar, lo primero que debemos saber es que para que nuestra Github Actions funcione los workflows deben estar en una carpeta llama .github/workflows en la raíz de nuestro repositorio, dentro de esta carpeta ira nuestro archivo de workflow llamado python-publish.yml.

Podemos crear todo usando los siguientes comandos:

$ mkdir -p .github/workflows
$ touch .github/workflows/python-publish.yml

La estructura de archivos quedaría similar a esta:

rafnixg-lib/
│
├── .github/
│   └── workflows/
│       └── python-publish.yml
├── src/
│   └── rafnixg/
│       ├── __init__.py
│       ├── __main__.py
│       └── rafnixg.py
│
├── LICENSE
├── README.md
└── pyproject.toml

🚀 Configurando el workflow

Vamos a iniciar creando el contenido de nuestro archivo de workflow python-publish.yml.

🎯Activando el workflow al publicar un release

name: Publicar Paquete a PyPI

on:
  release:
    types: [published]

Esto indica el nombre que tendrá nuestro workflow y también define que solo se va a ejecutar cuando las release sean published con esto limitamos que solo estas acciones sean las que disparen nuestro workflow.

🛡️Definir permisos mínimos necesarios

permissions:
  contents: read

Acá le decimos a GitHub Actions que este workflow solo necesita leer el contenido del repositorio. Es una buena práctica limitar los permisos al mínimo necesario.

🛠️Crear el job y configurar el entorno

jobs:
  deploy:
    runs-on: ubuntu-latest

Creamos un job llamado deploy, que se ejecutará en un entorno virtual Ubuntu. Este job va a encargarse de construir y publicar nuestro paquete.

📋Agregar los pasos del workflow

Los steps son partes del proceso que irán ejecutando de forma secuencia y serán lo que ejecutarán los pasos para publicar nuestra librería en PyPI luego de ser construida.

En los steps se puede hacer uso de otros actions creados por otros usuarios como si de librerías se tratase, solo debemos indicarlo con uses: actions/nombre-del-actions@version y tambien podemos usar comando sobre la máquina virtual donde se está ejecutando la actions con el comando run: comando bash

steps:
    - name: Clonando repositorio
      uses: actions/checkout@v3

    - name: Configurando Python 3
      uses: actions/setup-python@v3
      with:
        python-version: '3.x'

    - name: Instalando dependencias
      run: |
        python -m pip install --upgrade pip
        pip install build

    - name: Construir Paquete
      run: python -m build

    - name: Publicar Paquete
      uses: pypa/gh-action-pypi-publish@release/v1
      with:
        user: __token__
        password: ${{ secrets.PYPI_API_TOKEN }}

📂 Clonando el repositorio

- name: Clonando repositorio
  uses: actions/checkout@v3

Usamos la acción oficial para clonar el código del repositorio, paso necesario para poder construir el paquete.

🐍 Configurar el entorno de Python

- name: Configurando Python 3
  uses: actions/setup-python@v3
  with:
    python-version: '3.x'

Le decimos a GitHub Actions que configure un entorno de Python (versión 3.x). Esto es clave para poder instalar dependencias y ejecutar los comandos de build.

📥 Instalando las dependencias necesarias

- name: Instalando dependencias
  run: |
    python -m pip install --upgrade pip
    pip install build

Actualizamos pip y luego instalamos el módulo build, que nos permite crear los archivos .tar.gz y .whl que necesita PyPI.

🏗️Construir el paquete

- name: Construir Paquete
  run: python -m build

Este paso ejecuta python -m build, que genera el paquete listo para ser publicado en la carpeta dist/.

📤Publicar el paquete en PyPI

- name: Publicar Paquete
  uses: pypa/gh-action-pypi-publish@release/v1
  with:
    user: __token__
    password: ${{ secrets.PYPI_API_TOKEN }}

Finalmente, usamos la acción oficial para subir el paquete a PyPI. Aquí usamos el API Key que se guarda como Secret en el repositorio de GitHub (PYPI_API_TOKEN), para evitar exponer credenciales.

📄 Archivo completo del workflow (python-publish.yml)

El archivo python-publish.yml finalmente queda de la siguiente manera:

name: Publicar Paquete a PyPI
on:
  release:
    types: [published]
jobs:
  deploy:
    runs-on: ubuntu-latest
    steps:
        - name: Clonando repositorio
          uses: actions/checkout@v3

        - name: Configurando Python 3
          uses: actions/setup-python@v3
          with:
            python-version: '3.x'

        - name: Instalando dependencias
          run: |
            python -m pip install --upgrade pip
            pip install build

        - name: Construir Paquete
          run: python -m build

        - name: Publicar Paquete
          uses: pypa/gh-action-pypi-publish@release/v1
          with:
            user: __token__
            password: ${{ secrets.PYPI_API_TOKEN }}

💾 Subiendo los cambios al repositorio

Ya con nuestro archivo creado, solo nos resta subir un commit con los cambios que tenemos:

$ git add .github/workflows/python-publish.yml
$ git commit -m "Add GitHub Actions workflow for PyPI release"
$ git push origin

Creamos un tag y lo subimos:

$ git tag v1.0.1
$ git push origin --tags

Revisamos nuestro repositorio de GitHub y nos aseguramos de que se subió todo correctamente, para seguir con la creación de una nueva release.

🏷️ Crear una nueva release en GitHub

En nuestro repositorio hacemos clic en Releases. para ingresar a la página de todas las releases que vamos a haciendo.

En esta página hacemos clic en “draf a new release“

Esto nos abre el formulario para crear nuevas releases, acá debemos seleccionar el tag correspondiente con la release en “Choose a tag“ y hacer clic en “Generate release notes“, esto genera una descripción usando los commits y los Pull Request.

Por último, revisa la descripción ajusta si lo necesitas y dale clic a “Publish release“.

✅ Verificar el resultado de la publicación

Cada vez que crees una nueva release, se publicará una nueva versión de tu paquete en PyPI. En la tab “Actions“ de nuestro repositorio vamos a ver cómo se ejecuta el workflow que lo publica.

🧠 Conclusión

Automatizar la publicación con GitHub Actions no solo te ahorra tiempo, también reduce errores y hace que todo el proceso sea mucho más limpio y profesional. Una vez configurado, solo tienes que enfocarte en mejorar tu librería y dejar que la publicación se maneje sola ✨

🔍Referencias

🔗 Documentación oficial GitHub Actions

• https://docs.github.com/en/actions/about-github-actions/understanding-github-actions

🔗 Documentación oficial PyPI usando GitHub Actions

• https://packaging.python.org/en/latest/guides/publishing-package-distribution-releases-using-github-actions-ci-cd-workflows

🔗 Documentacion del GitHub Actions PyPI Publish

• https://github.com/pypa/gh-action-pypi-publish

El objetivo de este tutorial es guiarte paso a paso en el proceso de creación y publicación de tu propia librería en Python. Aunque Python ofrece una biblioteca estándar muy completa, aprovechar las contribuciones de la comunidad en PyPI te permite extender sus capacidades y crear soluciones personalizadas que se adapten a tus necesidades.

La motivación detrás de este proyecto es doble: por un lado, adquirir un conocimiento profundo sobre el proceso de preparación, versionado, construcción y despliegue de paquetes; y por el otro, consolidar un repositorio centralizado de herramientas que funcione como una tarjeta de presentación profesional en el mundo del desarrollo.

🧭 Introducción y primeros pasos

El primer paso es comprender el ecosistema de paquetes en Python, especialmente el rol fundamental que juega PyPI (Python Packaging Index). Este es el repositorio oficial de paquetes de Python, y alberga una vasta colección de librerías, desde implementaciones simples hasta complejas soluciones en áreas como ciencia de datos, inteligencia artificial y desarrollo web.

Al entender cómo se organizan y distribuyen los paquetes en PyPI, puedes orientar el desarrollo de tu librería para que cumpla con los estándares que facilitan su instalación y uso por parte de otros desarrolladores. Además, al prepararla para su publicación, te adentras en prácticas modernas como el versionado semántico y la automatización del despliegue.

Nuestro inicio en el mundo de las librerías lo vamos a tener en la próxima sección donde ya iniciaremos el código fuente que usaremos como base para todo el proceso de tener nuestra propia librería en PyPI.

https://pypi.org/project/rafnixg/

🏗️ Crear la base de tu librería en Python

En esta sección crearemos el código base que usaremos para subir a PyPI, tú puedes usar este código como ejemplo o ser libre de usar el código de tu preferencia, y saltar a la siguiente sección.

Si te quedaste acá el paquete que vamos a crear se llama rafnixg y muestra por consola tus datos personales y por otro lado podrá ser usado en tu propio código para descargar post de tu blog de HashNode usando GraphQL. Este es básicamente mi caso de uso de ejemplo, pero tu librería puede tener las funciones que tu consideres necesarias.

Para lograr obtener este diseño de card vamos a hacer uso de la librería rich que nos ayuda a crear diseños de tablas para la terminal de forma fácil, los invito a revisar el potencial de rich, puede agregar iconos, gestionar paleta de colores, Markdown.

🧪Preparación del entorno de desarrollo

Para este caso hare uso de VSCode pero puedes usar el editor que prefieras, acá lo importante es crear un entorno virtual de Python para aislar las dependencias y no tener problemas en el futuro.

$ python -m venv env
$ source env/bin/activate  # Para Linux
$ env\Scripts\activate    # Para Windows
(env) $ pip install rich

Lo segundo será crear un archivo .gitignore que nos ayudará a indicar que no queremos que se suba a nuestro repositorio, podemos hacer uso de la siguiente web para generar uno con la configuración para Python.

Create Useful .gitignore Files For Your Project

# Created by https://www.toptal.com/developers/gitignore/api/python
# Edit at https://www.toptal.com/developers/gitignore?templates=python

### Python ###
# Byte-compiled / optimized / DLL files
__pycache__/
*.py[cod]
*$py.class

env
.env
/venv
venv

# End of https://www.toptal.com/developers/gitignore/api/python

Debemos recordar que es importante evitar subir archivos con contenido sensibles como API Keys, Claves o algún tipo de información que permita acceso no autorizado.

Luego de esto inicializamos nuestro repositorio de git y creamos nuestra estructura de archivos.

(env) $ git init

📁 Estructura del proyecto

Toda librería de Python inicia dentro de una carpeta, así que para esto cree el directorio rafnixg-lib y dentro creo la siguiente estructura de archivos:

rafnixg-lib/
│
├── src/
│   └── rafnixg/
│       ├── __init__.py
│       ├── __main__.py
│       └── rafnixg.py
│
├── LICENSE
├── README.md
└── pyproject.toml

Todo el código fuente se encuentra de src/ esto no es obligatorio, pero es una buena práctica. Si estas usando tu propio código, dentro de src/ es donde debería ir para mantener la mejor estructura.

En esta sección nos enfocaremos en los archivos de Python y en las siguientes secciones veremos estos archivos especiales LICENSE, README.md, pyproject.toml.

🧾 Crear el archivo principal src/rafnixg/rafnixg.py

"""src/rafnixg/rafnixg.py
RafnixG - Personal Card
"""

from rich.console import Console
from rich.table import Table


class RafnixG:
    """RafnixG - Personal Card"""

    def __init__(self):
        self.username = "rafnixg"
        self.name = "Rafnix Guzmán"
        self.position = "Python Software Developer"
        self.links = "https://links.rafnixg.dev"
        self.web = "https://rafnixg.dev"
        self.blog = "https://blog.rafnixg.dev"
        self.cv = "https://resume.rafnixg.dev"
        self.github = "https://github.com/rafnixg"
        self.twitter = "@rafnixg"
        self.about = "Experienced software developer with 10+ years of expertise in designing, developing and implementing web systems across various sectors. Backend specialist skilled in Python, Linux, and Git. Passionate about continuous learning and open-source technology."

    def __str__(self):
        return f"{self.name} (@{self.username}) - {self.position}"

    def display(self):
        """Display personal card"""
        # Crea un objeto Console para imprimir en la consola
        console = Console()
        table = Table(
            show_header=False, # No mostrar encabezados
            title=str(self), # Título de la tabla
            highlight=True, # Resaltar la tabla
            title_style="bold magenta", # Estilo del título
        )
        # Agrega columnas a la tabla
        table.add_column("Attribute", style="bold", width=16)
        table.add_column("Value")
        # Agrega filas a la tabla con los atributos y valores de la clase
        # Itera sobre los atributos de la clase y los agrega a la tabla
        for key, value in self.__dict__.items():
            if isinstance(value, dict):
                for sub_key, sub_value in value.items():
                    table.add_row(sub_key, ", ".join(sub_value))
            elif isinstance(value, list):
                table.add_row(key, ", ".join(value))
            else:
                table.add_row(key, value)
        # Imprime la tabla en la consola
        console.print(table)

🧩 Inicializar el paquete con src/rafnixg/__init__.py

"""src/rafnixg/__init__.py
RafnixG - Personal Card
"""
from rafnixg.rafnixg import RafnixG

__version__ = "1.0.0"

🧩 Ejecutar como modulo con src/rafnixg/__main__.py

"""src/rafnixg/__main__.py
RafnixG - Personal Card
"""
from rafnixg import RafnixG


def main():
    """Main function."""
    me = RafnixG()
    me.display()

if __name__ == '__main__':
    main()

🖥️ Ejecutar y probar tu código localmente

Para probar nuestro código debemos movernos a la carpeta src/ y luego correr el paquete como un módulo de Python:

(env) $ cd src
(env) $ ls
  rafnixg/
(env) $ python -m rafnixg

Recuerda que si estas usando tu código aquí debes colocar el nombre la carpeta que contiene tu código fuente.

📦 Preparar la librería para ser publicada

📘Documentando nuestra librería

Un README es esencial para cualquier proyecto ya que aquí es donde otros desarrolladores y usuarios obtendrán información sobre tu librería, en este archivo no solo se explica que es y lo que hace tu proyecto, sino que también contiene información de como instalarlo, utilizarlo y contribuir. En una próxima publicación profundizaremos más sobre el README y que debería contener, por los momentos creamos el archivo README.md con el siguiente contenido:

# Rafnix Guzmán - Personal Card (README.md)

## Hi there 👋

This is my personal card [rafnixg.dev](https://rafnixg.dev)

![image](https://github.com/user-attachments/assets/4c1c368b-83ca-4ff7-89d0-c131efe60c9f)


## How to use it? 🤔

Install using pip:

```bash
pip install rafnixg
```

Then run it:

```bash
rafnixg
```

🛠️Configurar el sistema de construcción (build system)

Para preparar nuestra librería para ser publicada en PyPI necesitamos configurar algunas secciones en el archivo pyproject.toml primero debemos indicar el build system que es la parte responsable de crear los archivos que se suben a PyPI, usualmente se usa el formato wheel o sdist.

Nosotros usaremos el setuptools como build system.

# pyproject.toml

[build-system]
requires = ["setuptools>=61.0.0", "wheel"]
build-backend = "setuptools.build_meta"

🗂️ Organizar el archivo pyproject.toml

Ahora agregaremos una sección para configurar información del proyecto, acá es donde indicaremos el nombre de nuestro paquete, recordemos que debemos verificar que el nombre no este usado por ningún otro paquete dentro del ecosistema PyPI.

# pyproject.toml
...

[project]
name = "rafnixg"
version = "1.0.0"
description = "Rafnix Guzman Personal Card"
readme = "README.md"
authors = [{ name = "Rafnix Guzman", email = "rafnixg@gmail.com" }]
license = { file = "LICENSE" }
classifiers = [
    "License :: OSI Approved :: MIT License",
    "Programming Language :: Python",
    "Programming Language :: Python :: 3",
]
keywords = ["personal card", "console"]
dependencies = [
    "rich",
]
requires-python = ">=3.9"

[project.optional-dependencies]
dev = ["black", "bumpver", "isort", "pip-tools", "pytest"]

[project.urls]
Homepage = "https://github.com/rafnixg/rafnixg-lib"

[project.scripts]
rafnixg = "rafnixg.__main__:main"

No toda esta información es obligatoria, pero es importante dar la mayor cantidad de información posible sobre nuestra librería, la información mínima que podemos ingresar es name y version .

Las siguientes secciones son importantes por la información que le proporcionan a PyPI:

• classifiers: Lista de classifiers de PyPI que ayudan a la búsqueda.

• keywords: Lista de etiquetas que seran usadas para identicar y categorizar la libreria.

• dependencies: Lista de dependencias que tu librería necesita, en nuestro caso rich.

• project.optional-dependencies: Lista de las dependencias de desarrollo.

• project.urls: Links que relacione a tu proyecto en github o alguna página web.

• project.scripts: Punto de entrada para tu librería. en este caso el comando será rafnixg y el punto de entrada será rafnixg.__main__:main

Toda esta información hace que en PyPI tu librería se vea mucho mejor y cuando se haga una búsqueda también sea más fácil de encontrar. acá un ejemplo de la información que se muestra en PyPI:

Vemos como también usa el archivo README.md para mostrar del lado derecho la documentación de la librería en PyPI, y los datos del archivo pyproject.toml también se muestran a la izquierda.

Para saber más sobre este archivo de configuración acá esta la documentación.

🔢 Usar versionamiento semántico

Toda librería debe tener un versionamiento para poder tener un control de lo que se publica, existen diferentes esquemas de versionamiento, en nuestro caso usaremos Semantic Versioning que es una forma simple de gestionar el versionamiento formado por 3 grupo de números, ejemplo: MAJOR.MINOR.PATCH las recomendaciones para cambiar estos números son:

• MAJOR: Cuando tus cambios son tan grandes que rompen tu API anterior.

• MINOR: Cuando agregas nuevas funciones y todo se mantiene compatible, Vuelve a 0 cuando MAJOR cambia.

• PATCH: Cuando agregas bug fixes, vuelve a 0 cuando MINOR cambia.

Para gestionar esto en Python haremos uso de una librería llamada bumpver esto modifica directamente los archivos y así mantiene sincronizado en todos lados la versión.

(venv) $ python -m pip install bumpver
(venv) $ bumpver init
WARNING - Couldn't parse pyproject.toml: Missing version_pattern
Updated pyproject.toml

Este comando inicializa en pyproject.toml la gestión de las versiones, si vemos agrego una nueva sección:

[tool.bumpver]
current_version = "1.0.0"
version_pattern = "MAJOR.MINOR.PATCH"
commit_message = "bump version {old_version} -> {new_version}"
commit = true
tag = true
push = false

[tool.bumpver.file_patterns]
"pyproject.toml" = [
    'current_version = "{version}"',
    'version = "{version}"'
]
"src/rafnixg/__init__.py" = ["{version}"]

Si no se parece a esta ajustar el version_pattern para que sean iguales, después de configurar esto, tú puedes cambiar la versión usando los comandos de bumpver:

(venv) $ bumpver update --minor
INFO    - Old Version: 1.0.0
INFO    - New Version: 1.1.0
INFO    - git commit --message 'bump version 1.0.0 -> 1.1.0'
INFO    - git tag --annotate 1.1.0 --message '1.1.0'

📜 Elegir una licencia adecuada

Cuando creamos una librería debemos elegir que permisos queremos que los demás tengan sobre nuestro código, así se podrá saber qué es lo que quiere que se haga o no con tu librería. Una licencia muy usada para compartir código es la Licencia MIT con esta licencia simple y bastante permisiva.

Lo que debemos hacer es crear un archivo de texto llamado LICENSE que contenga el texto de nuestra licencia, si no sabes que licencia escoger existe esta web que permite ver cuál es la más conveniente según tus necesidades: Choose an open source license

📥 Instalar tu librería localmente

Para este punto ya tenemos nuestra librería lista para ser publicada, ahora lo que vamos a necesitar hacer es probar nuestra librería instalándola directamente en nuestro entorno virtual, para esto haremos uso de los siguientes comandos:

(env) $ python -m pip install -e .

Con el flag -e se instala tu librería en modo editable y con . indicamos donde se encuentra el archivo pyproject.toml esto ya deja disponible nuestro comando rafnixg que está definido en la sección project.scripts indicando el punto de entrada.

(env) $ rafnixg
                            Rafnix Guzmán Garcia (@rafnixg) - Python Software Developer                             
┌──────────────────┬───────────────────────────────────────────────────────────────────────────────────────────────┐
│ username         │ rafnixg                                                                                       │
│ name             │ Rafnix Guzmán Garcia                                                                          │
│ position         │ Python Software Developer                                                                     │
│ links            │ https://links.rafnixg.dev                                                                     │
│ web              │ https://rafnixg.dev                                                                           │
│ blog             │ https://blog.rafnixg.dev                                                                      │
│ cv               │ https://resume.rafnixg.dev                                                                    │
│ github           │ https://github.com/rafnixg                                                                    │
│ twitter          │ @rafnixg                                                                                      │
│ about            │ Experienced software developer with 10+ years of expertise in designing, developing and       │
│                  │ implementing web systems across various sectors. Backend specialist skilled in Python, Linux, │
│                  │ and Git. Passionate about continuous learning and open-source technology.                     │
└──────────────────┴───────────────────────────────────────────────────────────────────────────────────────────────┘

🚀 Publica tu librería a PyPI

Ya nuestra librería se encuentra lista y a la espera de conocer el mundo, en esta sección haremos el empaquetado y despliegue a PyPI.

🧑‍💻 Crear cuentas en PyPI y TestPyPI

Lo primero que debemos tener es una cuenta en PyPI, así que si no la tienes este es tu momento de registrarte: https://pypi.org/account/register/

También deberíamos crear una cuenta en el ambiente de pruebas de PyPI, así siempre podemos verificar que todo va bien antes de lanzar algo a producción: https://test.pypi.org/account/register/

Recuerden crear sus API Key porque en el proceso de publicación mas adelante serán necesarias.

🔐 Generar una API Key

Para esto ingresamos a Configuracion de la cuenta bajamos y buscamos la opción Fichas de API, hacemos clic en el botón Añadir ficha de API

Luego le ponen algún nombre descriptivo a esta Key, seleccionamos el Alcance y por último clic al botón Create Token

Con esto nos mostrara nuestra API Key que siempre empieza por pypy- como se muestra en la imagen de abajo:

Hacemos clic en Copiar Ficha y guardamos nuestra API Key en algún lugar seguro**.** Siempre van a tener la posibilidad de borrar la key y generar otra si es necesario la pierden.

Luego de todo esto debemos instalar 2 librerías que nos ayudaran a construir y publicar nuestro paquete:

(env) $ python -m pip install build twine

🛠️ Construir el paquete con build

Ahora que tenemos nuestra librería lista, ya podemos hacer la distribución del código a PyPI, para esto primero debemos empaquetar nuestra librería en formato wheels, un formato que consiste en empaquetar en un archivo tar todo el código fuente de la librería. Para crear este archivo haremos uso de la librería build:

(env) $ python -m build
[...]
Successfully built rafnixg-1.0.0.tar.gz and rafnixg-1.0.0-py3-none-any.whl

Esto nos crea una nueva carpeta llamada dist/ que contiene el archivo .tar.gz con el código de nuestra librería y el archivo .whl que es nuestro archivo wheels, esto es todo lo que necesitamos para subir a PyPI.

✅ Verificar el paquete con twine check

Para validar que todo fue empaquetado correctamente podemos usar twine:

(env) $ twine check dist/*
Checking dist/rafnixg-1.0.0-py3-none-any.whl: PASSED
Checking dist/rafnixg-1.0.0.tar.gz: PASSED

☁️ Subir el paquete a PyPI

Ahora que tenemos todo listo y verificado, podemos subir a TestPyPI para ver que todo va con normalidad y no tenemos ningún error en nuestra librería:

(env) $ twine upload -r testpypi dist/*

Nos pedirá nuestra API Key. Ya con esto podemos probar nuestra librería usando el siguiente comando:

(env) $ pip install -i https://test.pypi.org/simple/ rafnixg

Si todo salió con normalidad, podemos subir a él repositorio principal de PyPI:

(env) $ twine upload dist/*

Con esto tendríamos nuestro proyecto ya disponible para usar con pip, podemos a PyPI y buscar nuestra librería.

📥 Instalar tu paquete desde PyPI

Ya con nuestra librería publicada en PyPI podemos usarla con el siguiente comando:

(env) $ python -m pip install rafnixg
(env) $ rafnixg

🧠 Conclusiones

Crear y publicar tu propio paquete en Python es una experiencia enriquecedora que va más allá de compartir código: es una oportunidad para aprender sobre la estructuración de proyectos, el versionado semántico y las buenas prácticas de la comunidad. A lo largo de este tutorial, hemos recorrido desde la configuración del entorno de desarrollo hasta la publicación en PyPI, enfatizando la importancia de una documentación clara y una estructura ordenada. Con estos conocimientos, no solo mejoras tus habilidades técnicas, sino que también das un paso significativo hacia la consolidación de tu perfil profesional en el mundo del desarrollo. ¡Atrévete a experimentar, optimizar tu paquete y contribuir al ecosistema open source!

El propósito de este post es proporcionar una guía completa para los desarrolladores de Odoo que deseen llevar sus habilidades al siguiente nivel y dominar el uso de la shell en sus proyectos. A lo largo del artículo, cubriremos temas como acceso avanzado, operaciones avanzadas, integración de librerías externas, automatización de tareas y seguridad en la shell de Odoo.

Acceso avanzado a la shell de Odoo

La shell de Odoo es una herramienta poderosa que nos permite interactuar con el sistema Odoo y ejecutar tareas de desarrollo y administración. En esta sección, profundizaremos en algunas técnicas avanzadas para acceder y utilizar la shell de Odoo de manera más efectiva.

Uso de diferentes archivos de configuración

En ocasiones, puede ser útil tener diferentes archivos de configuración para distintos entornos o propósitos. Por ejemplo, podrías querer tener un archivo de configuración específico para trabajar con la shell de Odoo, que incluya parámetros ajustados para este propósito, como el número de workers, los límites de memoria y los puertos XML-RPC y Longpolling.

Para utilizar un archivo de configuración específico al acceder a la shell de Odoo, simplemente especifica la ruta del archivo con el parámetro -c al ejecutar el comando odoo-bin shell. Por ejemplo:

./odoo-bin shell -c /path/to/your/custom/odoo.conf

Asegúrate de que tu archivo de configuración personalizado incluye todos los parámetros necesarios para que la shell de Odoo funcione correctamente.

Acceso remoto a la shell de Odoo

En algunos casos, es posible que desees acceder a la shell de Odoo en un servidor remoto, en lugar de ejecutarla localmente. Para hacer esto, puedes utilizar una herramienta como ssh para establecer una conexión segura con el servidor remoto y acceder a la shell de Odoo desde allí.

Primero, asegúrate de tener ssh instalado en tu máquina local y que tienes acceso al servidor remoto con las credenciales adecuadas. Luego, ejecuta el siguiente comando para establecer una conexión ssh con el servidor remoto:

ssh user@remote-server-ip

Una vez que hayas iniciado sesión en el servidor remoto, navega hasta el directorio de instalación de Odoo y sigue los pasos habituales para acceder a la shell de Odoo utilizando el comando odoo-bin shell y el archivo de configuración deseado.

Al utilizar el acceso remoto a la shell de Odoo, ten en cuenta las implicaciones de seguridad y sigue las mejores prácticas para proteger tus datos y evitar accesos no autorizados.

Operaciones avanzadas en la shell de Odoo

La shell de Odoo ofrece muchas posibilidades para realizar tareas de desarrollo y administración de manera eficiente. En esta sección, abordaremos algunas operaciones avanzadas que puedes realizar en la shell de Odoo, lo que te permitirá aprovechar aún más esta herramienta.

Actualización de módulos desde la shell

Es posible actualizar módulos directamente desde la shell de Odoo. Para actualizar un módulo existente, utiliza el método button_upgrade() en el módulo que deseas actualizar:

module = env['ir.module.module'].search([('name', '=', 'my_module')])
module.button_upgrade()

Donde 'my_module' es el nombre del modulo que deseo actualizar.

Importación y exportación de datos en formatos CSV

La shell de Odoo también facilita la importación y exportación de datos en formatos CSV y XML. Para importar datos desde un archivo CSV, sigue estos pasos:

1. Instala la librería csv en tu entorno de Odoo.

2. Utiliza la siguiente estructura para leer y procesar el archivo CSV:

import csv

with open('data.csv', 'r') as csvfile:
    reader = csv.DictReader(csvfile)
    for row in reader:
        # Procesa cada fila del archivo CSV

Para exportar datos a un archivo CSV, puedes utilizar un enfoque similar:

import csv

with open('data.csv', 'w') as csvfile:
    fieldnames = ['field1', 'field2', 'field3']
    writer = csv.DictWriter(csvfile, fieldnames=fieldnames)

    writer.writeheader()
    for record in records:
        # Escribe cada registro en el archivo CSV

Para trabajar con datos en formato XML, puedes utilizar librerías como lxml o xml.etree.ElementTree.

Trabajo con registros y campos relacionales

La shell de Odoo facilita el trabajo con registros y campos relacionales. Para acceder a un campo relacional (por ejemplo, un campo Many2one), simplemente utiliza la notación de punto:

record = env['res.partner'].browse(1)
print(record.parent_id)
print(record.company_id.name)

Para acceder a campos relacionales inversos (por ejemplo, campos One2many o Many2many), utiliza la misma notación de punto:

record = env['res.partner'].browse(1)
print(record.child_ids)
for child in record.child_ids:
    print(child.id)

Búsqueda y manipulación de registros con filtros y operadores avanzados

La shell de Odoo te permite buscar y manipular registros utilizando filtros y operadores avanzados usando la notacion de domains de Odoo. Por ejemplo, puedes utilizar el operador like para buscar registros que coincidan con un patrón específico:

records = env['res.partner'].search([('name', 'like', 'R%')])

También puedes combinar múltiples criterios de búsqueda utilizando operadores lógicos como & (AND) y | (OR):

records = env['res.partner'].search(['&', ('name', 'like', 'R%'), ('country_id.code', '=', 'PE')])

Uso de contextos

Los contextos en Odoo son una herramienta útil para personalizar el comportamiento de las operaciones en función de ciertos parámetros, como el idioma o el usuario. Puedes utilizar contextos para realizar consultas en diferentes idiomas o para aplicar filtros específicos a nivel de usuario.

Por ejemplo, para buscar registros en un idioma específico, puedes pasar el código de idioma en el contexto:

records = env['res.partner'].with_context(lang='es_ES').search([])

Esto retornará los registros traducidos al idioma especificado en el contexto (en este caso, español).

También puedes utilizar contextos para aplicar filtros específicos a nivel de usuario. Por ejemplo, si deseas buscar registros que solo sean visibles para un usuario específico, puedes hacer lo siguiente:

user_id = 2  # ID del usuario específico
user = env['res.users'].browse(user_id)
records = env['res.partner'].with_context(user=user).search([])

Esto retornará los registros de socios comerciales que solo son visibles para el usuario con ID 2.

Integración de librerías externas en la shell de Odoo

La shell de Odoo es un entorno interactivo de Python, lo que significa que puedes importar y utilizar librerías externas de Python para mejorar y ampliar la funcionalidad de la shell. En esta sección, exploraremos cómo utilizar algunas librerías útiles para el análisis y tratamiento de datos y también mencionaremos otras librerías que podrían resultar de interés.

Uso de Pandas para el análisis y tratamiento de datos

Pandas es una biblioteca de Python popular y poderosa que ofrece estructuras de datos y herramientas de análisis de datos. Su integración en la shell de Odoo puede ser útil para realizar análisis de datos y para trabajar con grandes conjuntos de registros.

Para utilizar Pandas en la shell de Odoo, primero debes instalarla en tu entorno de Python:

pip install pandas

Una vez instalada, puedes importar Pandas en la shell de Odoo y empezar a utilizar sus funciones. Por ejemplo, puedes utilizar la función DataFrame de Pandas para convertir un conjunto de registros de Odoo en un DataFrame de Pandas:

import pandas as pd

partners = env['res.partner'].search([])
data = []

for partner in partners:
    data.append({
        'id': partner.id,
        'name': partner.name,
        'email': partner.email,
        'country': partner.country_id.name,
    })

df = pd.DataFrame(data)

Ahora que tienes un DataFrame de Pandas, puedes utilizar todas las funciones y herramientas de análisis de datos que ofrece Pandas. Por ejemplo, puedes realizar agrupaciones, filtrados, ordenamientos y mucho más.

Otras librerías útiles para mejorar el trabajo en la shell

Además de Pandas, hay muchas otras librerías de Python que pueden ser útiles en la shell de Odoo. A continuación, se mencionan algunas de ellas:

1. NumPy: Esta biblioteca es muy útil para realizar cálculos matemáticos y estadísticos en conjuntos de datos. Puedes utilizar NumPy junto con Pandas para llevar a cabo análisis avanzados en tus datos de Odoo.

2. Requests: Requests es una biblioteca popular para realizar solicitudes HTTP en Python. Puedes utilizarla en la shell de Odoo para interactuar con servicios web y APIs externas.

3. OpenPyXL: OpenPyXL es una biblioteca de Python para leer y escribir archivos Excel. Puedes utilizarla en la shell de Odoo para importar y exportar datos en formato Excel.

Estas son solo algunas de las muchas librerías disponibles para Python que pueden mejorar tu experiencia de trabajo en la shell de Odoo. No dudes en explorar otras librerías y adaptarlas a tus necesidades específicas.

Automatización de tareas con la shell de Odoo

Una de las ventajas de trabajar con la shell de Odoo es la posibilidad de automatizar tareas y procesos. En esta sección, exploraremos cómo ejecutar scripts y comandos desde archivos externos y cómo programar tareas automatizadas y cron jobs desde la shell.

Ejecución de scripts y comandos desde archivos externos

En lugar de ejecutar comandos individualmente en la shell de Odoo, puedes crear un archivo de script de Python que contenga una serie de comandos y ejecutar ese archivo. Esto facilita la automatización y la reutilización de código.

Para ejecutar un script de Python usando el entorno de Odoo, debemos crear primero un script wrapper que nos permita ejecutar nuestros scripts inyectando el entorno de odoo. sigue estos pasos:

1. Crea un archivo llamado odoo_wrapper.py con el siguiente contenido:

   https://gist.github.com/rafnixg/8be94e4b5226b19a465f5a36935828c7

2. https://gist.github.com/rafnixg/8be94e4b5226b19a465f5a36935828c7

3. Crea un archivo de script de Python (por ejemplo, mi_script.py) con una función llamada run que reciba un argumento env:

def run(env):
    # Tus comandos aqui, utilizando la variable 'env' para acceder a la API de Odoo
    # Este archivo puede ser todo lo complejo que tu quieras
    # Para probar usemos esto de ejemplo:
    partners = env['res.partner'].search([])
    print("Numero de contactos:", len(partners))

1. Desde la línea de comandos, navega hasta el directorio donde se encuentra el archivo odoo_wrapper.py.

2. Ejecuta el siguiente comando para ejecutar el archivo odoo_wrapper.py y que a su vez ejecute tu archivo mi_script.py:

python3 odoo_wrapper.py /path/to/mi_script.py

El archivo odoo_wrapper.py se encargará de ejecutar el archivo mi_script.py utilizando la API de Odoo y la base de datos especificada en el archivo de configuración. La función run en tu archivo mi_script.py se ejecutará con el entorno de Odoo proporcionado.

Programación de tareas automatizadas y cron jobs desde la shell

La shell de Odoo también te permite programar tareas automatizadas y cron jobs directamente desde la shell. Estas tareas se ejecutarán en intervalos específicos y pueden ser útiles para automatizar procesos como copias de seguridad, actualizaciones, sincronizaciones y más.

Para programar una tarea automatizada o un cron job desde la shell de Odoo, sigue estos pasos:

1. En la shell de Odoo, accede al modelo ir.cron:

    ir_cron = env['ir.cron']
   

2. Crea un nuevo registro de cron job utilizando el método create() y proporciona los detalles necesarios, como el nombre, el modelo, el método y el intervalo de tiempo:

ir_cron.create({
    'name': 'Mi Cron Job',
    'model_id': env.ref('base.model_res_partner').id,
    'state': 'code',
    'code': "model.my_custom_method()",
    'interval_number': 1,
    'interval_type': 'days',
    'numbercall': -1,
    'doall': False,
    'active': True,
})

En este ejemplo, hemos creado un cron job que ejecutará el método my_custom_method() en el modelo res.partner cada día. Puedes personalizar los parámetros según tus necesidades.

Una vez creada la tarea, se ejecutará automáticamente según el intervalo de tiempo especificado. Puedes verificar y administrar las tareas automatizadas y los cron jobs en la interfaz web de Odoo, bajo Configuración > Técnico > Automatización > Tareas programadas.

Seguridad y buenas prácticas en el uso de la shell de Odoo

Recomendaciones para proteger la información y evitar accesos no autorizados

Cuando trabajamos con la shell de Odoo, es importante tener en cuenta la seguridad y garantizar que la información y los datos estén protegidos. A continuación, se presentan algunas recomendaciones para proteger la información y evitar accesos no autorizados:

1. Controlar el acceso a la shell de Odoo: Limita el acceso a la shell de Odoo a los usuarios que realmente necesitan usarla. Asegúrate de que las credenciales de inicio de sesión y los permisos estén configurados correctamente para restringir el acceso solo a los usuarios autorizados.

2. Proteger el archivo de configuración: El archivo de configuración de Odoo puede contener información sensible, como contraseñas de base de datos y otros datos de configuración. Asegúrate de proteger este archivo mediante permisos de lectura y escritura adecuados y almacenarlo en una ubicación segura.

3. Hacer copias de seguridad de los datos: Realiza copias de seguridad periódicas de la base de datos de Odoo y almacena estas copias de seguridad en un lugar seguro y protegido. Esto te permitirá restaurar los datos en caso de un problema de seguridad o una pérdida de datos accidental.

Uso responsable de la shell en entornos de producción

Es importante utilizar la shell de Odoo de manera responsable en entornos de producción para evitar problemas y garantizar la estabilidad del sistema. Aquí hay algunas pautas para usar la shell de Odoo de manera responsable:

1. Evitar cambios en tiempo real en entornos de producción: Aunque la shell de Odoo permite realizar cambios en tiempo real en la base de datos y el sistema, estos cambios pueden tener consecuencias imprevistas. Siempre es mejor realizar cambios en un entorno de desarrollo o prueba antes de aplicarlos en un entorno de producción.

2. Limitar el uso de la shell en entornos de producción: Utiliza la shell de Odoo en entornos de producción solo cuando sea necesario y por el tiempo estrictamente necesario. Evita dejar sesiones de shell abiertas innecesariamente.

3. Registrar y auditar el uso de la shell: Mantén un registro de quién accede a la shell de Odoo y qué acciones se realizan en la shell. Estos registros pueden ser útiles para identificar problemas de seguridad y realizar auditorías.

4. Seguir las mejores prácticas de desarrollo: Al utilizar la shell de Odoo para desarrollar módulos y realizar cambios en la plataforma, sigue las mejores prácticas de desarrollo de Odoo para garantizar un código seguro, eficiente y fácil de mantener.

Conclusión

En este artículo, se profundizado en el uso y la configuración de la shell de Odoo para aprovechar su potencial y mejorar nuestras habilidades en el desarrollo y la gestión de Odoo. Hemos cubierto temas esenciales como el acceso avanzado a la shell, la realización de operaciones avanzadas, la integración de librerías externas, la automatización de tareas y la implementación de medidas de seguridad y buenas prácticas.

Espero que este artículo te haya proporcionado una comprensión más profunda del potencial de la shell de Odoo y te haya equipado con el conocimiento necesario para aprovechar sus capacidades en tus proyectos. Te invitos a aplicar y experimentar con lo aprendido, y a compartir tus experiencias y conocimientos con otros miembros de la comunidad Odoo.

En este post, te guiaré a través de cómo acceder a la shell de Odoo y cómo configurarla para trabajar con IPython.

Cómo ejecutar una shell usando la CLI de Odoo

Para acceder a la shell de Odoo, primero debemos asegurarnos de que Odoo esté instalado en nuestro sistema. Si aún no lo has hecho, te recomiendo seguir los pasos de instalación de Odoo para tu sistema operativo o Creando un entorno de desarrollo para Odoo 14.0 con VSCode. Una vez instalado, sigue estos pasos para acceder a la shell de Odoo:

1. Abre la línea de comandos o terminal.

2. Navega hasta el directorio de instalación de Odoo. Normalmente, esto se encuentra en "/usr/lib/odoo" o "/opt/odoo".

3. Ejecuta el siguiente comando si tienes una instalacion desde codigo fuente:

./odoo-bin shell -c /path/to/odoo.conf --xmlrpc-port 8888 --longpolling-port 8899

Si es desde una instalcion usando los paquetes del sistema operativo

odoo shell -c /path/to/odoo.conf --xmlrpc-port 8888 --longpolling-port 8899

• -c /path/to/odoo.conf: especifica la ruta al archivo de configuración de Odoo que deseas utilizar.

• --xmlrpc-port 8888: establece el puerto XML-RPC que utiliza Odoo para comunicarse con otras aplicaciones.

• --longpolling-port 8899: establece el puerto de long polling que utiliza Odoo para notificaciones en tiempo real.

Cambiamos los puertos para que no choque con los puertos de nuestra instancia de Odoo que se esta ejecutando.

Si todo funciona correctamente, deberías ver la siguiente línea en la terminal:

env: <odoo.api.Environment object at 0x7efc89670ef0>
odoo: <module 'odoo' from '/usr/lib/python3/dist-packages/odoo/__init__.py'>
openerp: <module 'odoo' from '/usr/lib/python3/dist-packages/odoo/__init__.py'>
self: res.users(1,)
Python 3.x.x (default, MMM DD YYYY, HH:MM:SS)

Ahora estás en la shell de Odoo. Puedes empezar a ejecutar comandos de Odoo y explorar la plataforma ERP. Por ejemplo, puedes ejecutar el siguiente comando para el usuario que se ejecuta en esta shell Odoo:

print(self.name)

También puedes interactuar con la base de datos de Odoo utilizando la sintaxis de ORM de Odoo. Por ejemplo, el siguiente comando cuenta todos los modelos de datos que tiene esta instancia de Odoo:

print(env['ir.model'].search_count([]))

Cómo configurar la interfaz de la shell para usar IPython como REPL

IPython es un shell interactivo de Python que proporciona funciones avanzadas como autocompletado, resaltado de sintaxis, historial de comandos y más. Utilizar IPython como REPL (Read-Eval-Print Loop) en lugar del shell estándar de Python puede mejorar nuestra experiencia de programación en Odoo.

Para configurar la shell de Odoo para usar IPython como REPL, sigue estos pasos:

1. Instala IPython en tu sistema. En la mayoría de los sistemas operativos, puedes instalarlo ejecutando el siguiente comando:

pip install ipython

1. Ahora que IPython está instalado, debes modificar el comando que usamos anteriormente para acceder a la shell de Odoo, incluyendo la opción --shell-interface ipython. El comando modificado se verá así:

# Desde codigo fuente
./odoo-bin shell -c /path/to/odoo.conf --xmlrpc-port 8888 --longpolling-port 8899 --shell-interface ipython

# Binario instalado
odoo shell -c /path/to/odoo.conf --xmlrpc-port 8888 --longpolling-port 8899 --shell-interface ipython

Al ejecutar este comando, accederás a la shell de Odoo con IPython como REPL,como vemos en la imagen, lo que te permitirá aprovechar sus funciones avanzadas mientras trabajas con Odoo, para salir del modo shell con IPython debes usar ctrl+D

Recomendaciones para el uso de la shell de Odoo

Configuración separada para la shell de Odoo

Es altamente recomendable tener un archivo de configuración separado para la shell de Odoo. Esto nos permite ajustar los parámetros específicos para la shell sin afectar la configuración de nuestra instancia de Odoo en producción o desarrollo. Algunos de los parámetros que podrías considerar ajustar en este archivo de configuración separado incluyen:

• --xmlrpc-port 8888: Establecer un puerto XML-RPC diferente para evitar conflictos con la instancia principal de Odoo.

• --longpolling-port 8899: Establecer un puerto de Long Polling diferente para evitar conflictos con la instancia principal de Odoo.

• Cambiar los valores de límite de memoria (soft y hard memory limit) para asignar más o menos recursos a la shell.

• Ajustar el número de workers para adaptarlo a tus necesidades específicas.

Para crear un archivo de configuración separado, simplemente copia tu archivo de configuración principal y modifica los parámetros mencionados anteriormente. Luego, al ejecutar la shell de Odoo, usa la opción -c para especificar la ruta a este nuevo archivo de configuración. Por ejemplo:

./odoo-bin shell -c /path/to/shell-odoo.conf --shell-interface ipython

odoo- shell -c /path/to/shell-odoo.conf --shell-interface ipython

Uso de librerías externas

Al trabajar con la shell de Odoo, no estás limitado a utilizar solo las funcionalidades integradas en Odoo. Puedes aprovechar también las ventajas de librerías externas de Python para mejorar tu productividad y facilitar el análisis y procesamiento de datos. Una de estas librerías es Pandas, una herramienta popular y potente para el análisis y manipulación de datos en Python.

Puedes importar Pandas en la shell de Odoo e interactuar con los datos utilizando sus estructuras de datos como DataFrames y Series. Por ejemplo, puedes convertir los registros de un modelo de Odoo en un DataFrame de Pandas y luego realizar análisis y manipulación de datos avanzados. Esto puede ser especialmente útil cuando necesitas generar informes o analizar datos de forma rápida y eficiente.

Recuerda que al usar librerías externas como Pandas, es importante garantizar que estén correctamente instaladas y configuradas en tu entorno de desarrollo y, si es necesario, en el entorno de producción.

Conclusión

En resumen, la shell de la CLI de Odoo es una herramienta muy útil para los desarrolladores de Odoo que desean profundizar en la programación del ERP. A través de la CLI, podemos interactuar con Odoo de una manera más avanzada y personalizada. Además, al configurar la interfaz de la shell para usar IPython como REPL, podemos aprovechar las funciones avanzadas de IPython y mejorar nuestra experiencia de programación en Odoo.

Espero que este post te haya sido útil y te haya brindado una mejor comprensión de cómo trabajar con la shell de Odoo y configurarla con IPython. Si te ha gustado este post y crees que puede ser útil para otros desarrolladores de Odoo, no dudes en compartirlo en tus redes sociales. Nos vemos en un proximo post donde profundizaremos en el uso de la shell de Odoo.

Si quieren saber mas sobre IPython y la CLI de Odoo, aca les dejo los enlaces a su documentación.

• Documentación Oficial de IPython

• Documentación Oficial de Odoo CLI

Introducción

Antes de empezar, debemos entender qué es la API de OpenAI y Gradio.

OpenAI es una organización de investigación en inteligencia artificial. Ofrecen una API que permite acceder a modelos de inteligencia artificial avanzados para realizar diversas tareas, como responder preguntas, traducir oraciones, resumir noticias y más.

Por otro lado, Gradio es una herramienta de código abierto para crear interfaces de usuario interactivas para modelos de inteligencia artificial. Ofrece una manera fácil y rápida de crear una interfaz de usuario para cualquier modelo de aprendizaje automático.

Ahora que tenemos una comprensión básica de ambas herramientas, comencemos con el tutorial.

Conectando a la API de OpenAI

Para usar la API de OpenAI, necesitamos generar una clave API. Siga estos pasos para obtener su clave API:

1. Visite el sitio web de OpenAI y regístrese para obtener una cuenta gratuita.

2. Inicie sesión en su cuenta y vaya a la página de la API.

3. Cree una nueva clave API y cópiela porque la usaremos mas adelante.

   

Instalación de dependencias

En este tutorial, crearemos una aplicación de Chatbot utilizando la API de OpenAI y Gradio. Para empezar, necesitamos ubicarnos en la carpeta donde vamos a trabajar nuestro proyecto e instalar ambos paquetes en nuestra máquina. Como un paso previo a la instalación de las dependecias se puede crear un entorno virtual de python para que las librerias no tengan colision con las del sistema:

python3 -m venv venv
source venv/bin/activate

Luego de activar el entorno virtual, procedemos a instalar las dependencias:

pip install openai
pip install gradio

Configuración de la clave API de OpenAI

Una vez que tengamos ambos paquetes instalados, podemos comenzar a escribir nuestro código.

Primero, debemos configurar la API de OpenAI para poder acceder a sus servicios. Una vez que tengamos la clave API, podemos configurarla en nuestro código de Python creando un archivo llamado chatbot.py utilizando el siguiente código.

import openai
import os

# Obtener la clave API de OpenAI de la variable de entorno
openai.api_key = os.environ.get("OPENAI_API_KEY", None)

Asegúrate de configurar la variable de entorno OPENAI_API_KEY con tu clave API real antes de ejecutar el código, sino en la ultima sección te explico como hacerlo.

Ahora que tenemos la clave API configurada, podemos comenzar a interactuar con la API de OpenAI. En este tutorial, crearemos un chatbot que puede responder a las preguntas de los usuarios.

Configuración del mensaje por defecto

Para crear un chatbot utilizando la API de OpenAI, necesitamos proporcionar una serie de mensajes como entrada a la API. Cada mensaje es una cadena de texto que representa el mensaje enviado por un usuario o el chatbot. Usaremos un mensaje por defecto para configurar y condicionar las respuesta GPT:

messages = [
    {
        "role": "system",
        "content": "Act like a personal assistant. You can respond to questions, translate sentences, summarize news, and give recommendations."
    }
]

En este ejemplo, el chatbot comienza presentándose como un asistente personal y proporcionando una lista de tareas que puede realizar.

Función de llamada a la API de OpenAI

Una vez que tenemos los mensajes de entrada preparados, podemos enviarlos a la API de OpenAI para generar una respuesta utilizando el siguiente código.

def openai_process_message(user_message):
    # Set the prompt for OpenAI Api
    messages = [
        {
            "role": "system",
            "content": "Act like a personal assistant. You can respond to questions, translate sentences, summarize news, and give recommendations."
        }
    ]
    messages.append({"role": "user", "content": user_message})
    # Call the OpenAI Api to process our prompt
    openai_response = openai.ChatCompletion.create(model="gpt-3.5-turbo", messages=messages, max_tokens=2000)
    # Parse the response to get the response text for our prompt
    response_text = openai_response.choices[0].message.content
    return response_text

La función openai_process_message toma como entrada el mensaje del usuario y lo agrega a la lista de mensajes como un mensaje de usuario. A continuación, llama a la API de OpenAI para procesar los mensajes y generar una respuesta. Por último, la función devuelve la respuesta generada por la API de OpenAI.

Creación de la UI con Gradio

A continuación, crearemos una lista de ejemplos que se utilizarán para mostrar ejemplos en la interfaz de usuario. En este caso, utilizaremos preguntas sobre la inteligencia artificial.

examples = [
    "Que es la IA?",
    "Como funciona una red neuronal?",
    "pueden las maquinas aprender?",
]

Luego, creamos una instancia de la clase Interface de Gradio y le pasamos la función openai_process_message() como argumento. A continuación, definimos el tipo de entrada y salida que deseamos para nuestra interfaz. En este caso, utilizaremos una caja de texto para la entrada del usuario y otra para mostrar la respuesta del chatbot.

# Create a Gradio interface instance
demo = gr.Interface(
    fn=openai_process_message,
    inputs=gr.Textbox(lines=5, label='Pregunta',    placeholder='Escribe tu pregunta aquí...'),
    outputs=gr.Textbox(label='Respuesta'),
    examples=examples,
    title="Chatbot OpenAI API",
)

Finalmente, lanzamos la interfaz de usuario utilizando el método launch().

if __name__ == "__main__":
    demo.launch()

Corriendo nuestra aplicación

Recuerda que antes de lanzar la aplicación, debes configurar la variable de entorno "OPENAI_API_KEY" con tu clave de API de OpenAI. Puedes hacerlo de la siguiente manera en tu terminal:

export OPENAI_API_KEY=<tu_clave_de_api>

Donde <tu_clave_de_api> debe ser reemplazada con tu clave de API real de OpenAI.

Para lanzar la aplicación, puedes simplemente ejecutar el archivo Python en tu terminal o IDE de Python:

python chatbot.py

Con esto ya tenemos nuestra app corriendo sobre https://127.0.0.1:7860 y con la siguiente UI de forma facil y rapida:

Conclusiones

Ahora tenemos una aplicación completa de preguntas y respuestas que utiliza la API de OpenAI para generar respuestas a cualquier pregunta que el usuario pueda tener. Esta aplicación es solo un ejemplo de lo que se puede hacer con la API de OpenAI y la biblioteca Gradio. Hay muchas otras aplicaciones de inteligencia artificial que se pueden crear utilizando estas herramientas.

En un proximo post voy a implementar otra UI usando el componente Chatbot de Gradio para darle un diseño mas acoorde al un chatbot y algunos otros tips a la hora de usar Gradio, por el momento es un buen punto de partida para practicar y probar estas tecnologias.

Código Fuente

Todo el codigo y los pasos para instalar la aplicación estan en mi cuenta de GitHub

Introducción

En mi camino como desarrollador y entusiasta de la tecnología, he construido un homelab server en mi casa para experimentar con nuevas tecnologías y aprender de forma autodidacta. Es un servidor casero donde puedo ejecutar diferentes servicios y herramientas en un ambiente controlado.

En este artículo, compartiré con ustedes los servicios que actualmente estoy corriendo en mi homelab server. Estos servicios incluyen virtualización con Proxmox, contenedores con LXC y Docker, una plataforma como servicio (PaaS) llamada Coolify, un backend as a service (BaaS) llamado Appwrite, Pi-hole para bloquear anuncios y rastreadores, Plausible para analizar las métricas de mi sitio, y mucho más. Si estás interesado en crear tu propio homelab server o simplemente deseas conocer qué servicios estoy usando, sigue leyendo para conocer más.

Proxmox VE

Proxmox VE es una plataforma de virtualización de código abierto que utilizo para virtualizar y administrar mis servidores. Proxmox me permite crear y gestionar contenedores Linux (LXC) y máquinas virtuales (VM), lo que me brinda una gran flexibilidad y ahorro de recursos en mi homelab server.

Los contenedores LXC son una forma ligera y eficiente de virtualización que me permiten ejecutar múltiples servicios en mi homelab server de manera aislada y segura. Por otro lado, las máquinas virtuales son una forma más tradicional de virtualización que me permiten ejecutar sistemas operativos completos en mi homelab server, lo que es útil para probar diferentes configuraciones y experimentar con nuevas tecnologías.

Proxmox tiene una interfaz web fácil de usar que me permite crear y gestionar mis contenedores LXC y máquinas virtuales de manera sencilla. También cuenta con una comunidad activa y una amplia documentación que me ha sido de gran ayuda a lo largo del tiempo.

Coolify

Coolify es una plataforma como servicio (PaaS) que utilizo para alojar mi sitio web. Es una alternativa a Heroku, pero self-hosted, lo que me brinda más control y flexibilidad. Dentro de Coolify, tengo desplegado mi sitio web. Además, utilizo Appwrite, un Backend as a Service (BaaS) del que hablare mas adelante y algunas aplicaciones desplegadas usando docker.

Appwrite

Appwrite es un Backend as a Service (BaaS) que utilizo para gestionar mi sitio web. Me ayuda a manejar fácilmente usuarios, bases de datos y autenticación en mi sitio web, lo que me ahorra mucho tiempo y esfuerzo. Appwrite es muy fácil de integrar con Coolify, y tiene una interfaz de usuario web muy intuitiva.

Plausible

Plausible es una herramienta de análisis web de código abierto que utilizo para analizar las métricas de mi sitio web. Es una alternativa a Google Analytics, pero más centrada en la privacidad. Plausible utiliza una arquitectura simple y ligera que no rastrea a los usuarios y no recopila información personal. Plausible me brinda información detallada sobre el tráfico de mi sitio web, como la cantidad de visitas, la ubicación geográfica de los visitantes y el tiempo promedio en el sitio.

Portainer

Portainer es una herramienta de gestión de contenedores de Docker que utilizo para administrar y supervisar mis contenedores. Portainer tiene una interfaz de usuario web que me permite ver fácilmente el estado de mis contenedores, administrar imágenes y supervisar logs. Utilizo Portainer para gestionar Pi-Hole y otros servicios como el speedtracker en mi homelab server.

Pi-Hole

Pi-hole es una aplicación de bloqueo de anuncios y rastreadores en Internet que utilizo para proteger mi navegación web y reducir la cantidad de anuncios. Pi-Hole utiliza una lista de bloqueo de anuncios actualizada regularmente para bloquear anuncios en todos mis dispositivos de red. Pi-hole funciona bloqueando las solicitudes de DNS de anuncios y rastreadores, lo que significa que la mayoría de los anuncios y rastreadores simplemente no se cargan.

En mi homelab server, utilizo Pi-hole como mi servidor de DNS local y bloqueador de anuncios y rastreadores. Pi-hole es fácil de configurar y puedo personalizar las listas de bloqueo de anuncios y rastreadores según mis necesidades. También puedo ver estadísticas detalladas sobre los dominios bloqueados y la cantidad de solicitudes de DNS procesadas por Pi-hole. Es una herramienta útil para mantener la privacidad y seguridad en mi red doméstica.

Speedtest Tracker

Speedtest Tracker es una herramienta de monitoreo de velocidad de internet que utilizo para supervisar la velocidad de mi conexión a internet. Speedtest Tracker se ejecuta en un contenedor de Docker y utiliza Speedtest CLI para realizar pruebas de velocidad en intervalos regulares. Speedtest Tracker me brinda información detallada sobre la velocidad de mi conexión a internet, como la velocidad de descarga, la velocidad de carga y la latencia. También puedo ver gráficas de tendencias y estadísticas de velocidad a lo largo del tiempo.

Cloudflare Tunnels

Cloudflare Tunnels es un servicio que utilizo para conectar mis contenedores y mi dominio. Con Cloudflare Tunnels, puedo acceder a mis servicios de forma segura desde cualquier lugar, sin tener que preocuparme por abrir puertos en mi firewall. Cloudflare Tunnels también me ayuda a ocultar la dirección IP de mi servidor, lo que aumenta mi privacidad y seguridad. Si quieres conocer más acerca de Cloudflare Tunnels, puedes visitar su sitio web.

Nginx Proxy Manager

Nginx Proxy Manager es una herramienta de gestión de proxies que utilizo para gestionar la redirección en dominios locales junto con Pi-Hole. Nginx Proxy Manager tiene una interfaz de usuario web sencilla que me permite configurar fácilmente proxies y redirecciones para mis servicios en contenedores. Además, Nginx Proxy Manager me ayuda a asegurar mis servicios al permitirme configurar SSL/TLS para mis dominios. Si estás interesado en conocer más sobre Nginx Proxy Manager, puedes visitar su sitio web.

Resumen

En mi homelab server, tengo configurados varios servicios para llevar a cabo diversas tareas. Proxmox me permite virtualizar y administrar mis servidores, y utilizo tanto contenedores LXC como máquinas virtuales para ejecutar diferentes servicios y experimentar con nuevas tecnologías.

Coolify es una plataforma como servicio que utilizo para alojar mi sitio web, con un backend as a service llamado Appwrite para manejar usuarios y bases de datos. Para analizar las métricas de mi sitio, utilizo Plausible, y para bloquear anuncios y rastreadores en mi red, utilizo Pi-hole.

Además, utilizo Cloudflare Tunnels para conectar mis contenedores dentro de mi servidor y mi dominio de forma segura, y Nginx Proxy Manager para gestionar la redirección en dominios locales junto con Pi-hole.

En resumen, estos son los servicios que tengo en mi homelab server y que me permiten experimentar con diferentes tecnologías y aplicaciones en un entorno seguro y controlado. Si estás interesado en crear tu propio homelab server, te recomiendo comenzar con algunos de estos servicios y experimentar para encontrar lo que mejor se adapte a tus necesidades. ¡Que disfrutes la creación de tu homelab server!

Antes de empezar con la configuración del entorno de desarrollo, asegúrate de tener instalado los siguientes requisitos previos: Python 3, Git, PostgreSQL y VSCode. Si aún no los tienes, puedes seguir los siguientes enlaces para instalarlos:

• Python 3: https://www.python.org/downloads/

• Git: https://git-scm.com/downloads

• PostgreSQL: https://www.postgresql.org/download/

• VSCode: https://code.visualstudio.com/download

Una vez que tengas estos requisitos previos instalados, estás listo para empezar a configurar tu entorno de desarrollo de Odoo. En este post, te enseñare cómo crear una estructura de carpetas adecuada para trabajar con Odoo y cómo configurar VSCode para poder debuggear el código.

Instalación de PostgreSQL

Para trabajar con Odoo, necesitarás tener instalado PostgreSQL. PostgreSQL es un sistema de gestión de bases de datos relacional de código abierto. Para instalar PostgreSQL en Ubuntu/Debian, puede seguir los siguientes pasos en la terminal:

sudo apt update
sudo apt upgrade
sudo apt install postgresql postgresql-client
sudo -u postgres createuser -s $USER
createdb odoo-dev-14.0

• sudo apt update: Este comando se utiliza para actualizar la lista de paquetes disponibles en los repositorios de Ubuntu/Debian. Es importante ejecutar este comando antes de instalar cualquier software nuevo en Ubuntu para asegurarse de que se están utilizando las versiones más recientes de los paquetes disponibles.

• sudo apt upgrade: Este comando se utiliza para actualizar los paquetes existentes en el sistema operativo. Al ejecutar este comando, se descargarán e instalarán las actualizaciones disponibles para todos los paquetes instalados en el sistema.

• sudo apt install postgresql postgresql-client: Estos comandos se utilizan para instalar PostgreSQL y su cliente en el sistema operativo. PostgreSQL es un sistema de gestión de bases de datos relacionales que se utiliza comúnmente como base de datos para Odoo.

• sudo -u postgres createuser -s $USER: Este comando se utiliza para crear un usuario en PostgreSQL con todos los privilegios necesarios para trabajar con Odoo. El comando se ejecuta como el usuario "postgres", que es el usuario por defecto de PostgreSQL. $USER es una variable de entorno que contiene el nombre de usuario actual.

• createdb odoo-dev-14.0: Este comando se utiliza para crear una nueva base de datos en PostgreSQL llamada "odoo-dev-14.0". Esta será la base de datos que se utilizará para desarrollar y probar Odoo en este entorno de desarrollo.

Es importante destacar que después de la instalación, es necesario realizar algunas configuraciones de seguridad adicionales para garantizar la protección de los datos de la empresa. Sin embargo, para fines de este tutorial y dado que nos encontramos en un ambiente de desarrollo, no profundizaremos en este aspecto

Instalación de dependencias

Antes de empezar a trabajar con Odoo, necesitamos instalar algunas dependencias en nuestro sistema operativo. Para hacerlo, podemos seguir las instrucciones oficiales que recomiendan utilizar los siguientes comandos en la terminal:

sudo apt update
sudo apt upgrade
sudo apt install python3-dev python3-pip python3-venv libxml2-dev \
libxslt1-dev libldap2-dev libsasl2-dev libtiff5-dev \
libjpeg8-dev libopenjp2-7-dev zlib1g-dev libfreetype6-dev \
liblcms2-dev libwebp-dev libharfbuzz-dev libfribidi-dev libxcb1-dev libpq-dev

Estos comandos nos permitirán instalar todas las dependencias necesarias para trabajar con Odoo en nuestro sistema Ubuntu 22.04. Es importante asegurarse de que todas las dependencias se instalen correctamente antes de continuar con la configuración de nuestro entorno de desarrollo.

Creación de la estructura de carpetas

Una vez instalado PostgreSQL y las dependencias necesarias, es hora de crear una estructura de carpetas para trabajar con Odoo. Para ello, ejecuta en la terminal el siguiente comando:

mkdir -p ~/Odoo/{src,workspaces,instances,instances/odoo-dev-14.0}

Esta una forma abreviada de crear varias carpetas a la vez utilizando llaves y una lista de nombres de carpeta separados por comas.

En este caso, el comando crea una estructura de carpetas dentro de la carpeta principal del usuario (representado por el símbolo "~" que se refiere al directorio de inicio del usuario) con los siguientes nombres de carpeta:

• src

• workspaces

• instances

• instances/odoo-dev-14.0

La opción "-p" indica que se crearán todas las carpetas necesarias en la ruta, incluso si algunas de ellas ya existen. De esta manera, se crea una estructura de carpetas adecuada para trabajar con Odoo y se asegura de que todas las carpetas necesarias estén disponibles en el directorio de inicio del usuario.

Instalación de Odoo 14.0

Ahora que hemos instalado PostgreSQL, Python y las dependencias necesarias, podemos proceder a instalar Odoo.

Descargar el código fuente de Odoo 14.0

Para descargar el código fuente de Odoo 14.0, ejecuta en la terminal el siguiente comando:

git clone https://github.com/odoo/odoo.git --single-branch --depth 1 --branch 14.0 ~/Odoo/src/14.0

Este comando descargará el código fuente de Odoo 14.0 en la carpeta ~/Odoo/src/14.0.

El parámetro --single-branch indica que solo se clonará la rama especificada en lugar de todas las ramas del repositorio. El parámetro --depth 1 indica que solo se clonará el historial más reciente del repositorio, lo que reduce el tiempo y espacio necesarios para la descarga.

Crear un entorno virtual

Para crear un entorno virtual de Python para Odoo, ejecute el siguiente comando:

python3 -m venv ~/Odoo/instances/odoo-dev-14.0/venv

Este comando creará un entorno virtual para Odoo en la carpeta ~/Odoo/instances/odoo-dev-14.0/venv.

Instalar las dependencias de Odoo

Para instalar las dependencias de python para Odoo, ejecute los siguientes comandos:

source ~/Odoo/instances/odoo-dev-14.0/venv/bin/activate
pip3 install setuptools wheel inotify psycopg2-binary
pip3 install -r ~/Odoo/src/14.0/requirements.txt
deactivate

Estos comandos activarán el entorno virtual de Odoo, instalarán las dependencias necesarias y desactivarán el entorno virtual.

1. source ~/Odoo/instances/odoo-dev-14.0/venv/bin/activate: este comando activa el entorno virtual de Odoo para que puedas instalar las dependencias necesarias sin afectar al sistema operativo.

2. pip3 install setuptools wheel inotify psycopg2-binary: estos son paquetes de Python necesarios para ejecutar Odoo. setuptools y wheel son herramientas de construcción de paquetes, inotify es una biblioteca para monitorear cambios en archivos y directorios, y psycopg2-binary es un controlador de base de datos PostgreSQL para Python.

3. pip3 install -r ~/Odoo/src/14.0/requirements.txt: este comando instala todas las dependencias adicionales requeridas por Odoo, que están enumeradas en el archivo requirements.txt. El prefijo -r significa "de un archivo de requisitos".

4. deactivate: este comando desactiva el entorno virtual de Odoo, lo que significa que ya no se están utilizando las dependencias instaladas en dicho entorno.

Con estos pasos, hemos instalado Odoo 14.0 en nuestro entorno de desarrollo de Ubuntu 22.04. Ahora podemos empezar a trabajar con Odoo y personalizarlo según nuestras necesidades.

Crear el archivo de configuración de Odoo

Después de haber creado el entorno virtual de Python y haber instalado las dependencias necesarias, el siguiente paso es configurar Odoo para que se ejecute correctamente en el entorno virtual. Para esto, es necesario crear un archivo de configuración específico para su instancia de Odoo.

Para crear el archivo de configuración, ejecute los siguientes comandos:

cp ~/Odoo/src/14.0/debian/odoo.conf ~/Odoo/instances/odoo-dev-14.0 
sed -i 's/db_user = odoo/db_user = '$USER'/' ~/Odoo/instances/odoo-dev-14.0/odoo.conf

El primer comando copia el archivo de configuración predeterminado de Odoo a la carpeta de su instancia de Odoo. El segundo comando utiliza el comando "sed" para reemplazar el usuario de la base de datos predeterminado de "odoo" por el usuario actual. Esto es necesario para que Odoo pueda acceder a la base de datos en el entorno virtual.

Una vez que haya creado el archivo de configuración de Odoo, podrá personalizarlo para adaptarlo a sus necesidades específicas. Puede configurar la dirección IP, el puerto, la base de datos y otras opciones para su instancia de Odoo si ya tenia una instalación de PostgreSQL.

Inicializar la base de datos de Odoo

Una vez que se han instalado las dependencias de Odoo y se ha creado el archivo de configuración, el siguiente paso es inicializar la base de datos de Odoo. Para hacer esto, se utilizará el comando:

~/Odoo/instances/odoo-dev-14.0/venv/bin/python3 ~/Odoo/src/14.0/odoo-bin -c ~/Odoo/instances/odoo-dev-14.0/odoo.conf -d odoo-dev-14.0 -i base --stop-after-init

Este comando ejecuta el archivo odoo-bin que se encuentra en la carpeta src/14.0 del directorio raíz de Odoo. El parámetro -c especifica la ruta del archivo de configuración de Odoo que se creó anteriormente. El parámetro -d especifica el nombre de la base de datos que se creará e inicializará. En este caso, se está utilizando odoo-dev-14.0.

El parámetro -i indica los módulos de Odoo que se instalarán. En este caso, solo se está instalando el módulo base de Odoo. Sin embargo, es posible agregar más módulos separándolos por comas.

Finalmente, el parámetro --stop-after-init detiene el servidor de Odoo después de inicializar la base de datos. Esto es útil si solo se desea inicializar la base de datos y no ejecutar el servidor completo de Odoo.

Una vez que se ejecuta este comando, se creará y se inicializará la base de datos de Odoo. Este proceso puede tardar unos minutos, dependiendo de la velocidad de su computadora.

Configuración del debugger de VSCode para Odoo 14.0

Una herramienta útil para desarrollar en Odoo es el debugger de Visual Studio Code (VSCode), que permite depurar código en tiempo real. A continuación, se muestra cómo configurar el debugger de VSCode para trabajar con Odoo 14.0.

1. Abre Visual Studio Code en la carpta de la instancia ~/Odoo/instances/odoo-dev-14.0/ y haz clic en la pestaña "Debug" en la barra lateral izquierda.

   

2. Haz clic en el botón "cree un archivo launch.json" en la parte inferior de la pestaña "Debug".

   

3. Copia y pega el siguiente código en el archivo "launch.json" que se ha creado:

{
    "version": "0.2.0",
    "configurations": [
        {
            "name": "odoo-dev-14.0",
            "type": "python",
            "request": "launch",
            "program": "~/Odoo/src/14.0/odoo-bin",
            "console": "integratedTerminal",
            "args": [
                "-c","~/Odoo/instances/odoo-dev-14.0/odoo.conf",
                "--limit-time-real", "99999",
                "-d", "odoo-dev-14.0"
            ]
        },
        {
            "name": "odoo-dev-14.0-install-addons",
            "type": "python",
            "request": "launch",
            "program": "~/Odoo/src/14.0/odoo-bin",
            "console": "integratedTerminal",
            "args": [
                "-c","~/Odoo/instances/odoo-dev-14.0/odoo.conf",
                "--limit-time-real", "99999",
                "-d", "odoo-dev-14.0",
                "-i","",
                "--stop-after-init"
            ]
        },
        {
            "name": "odoo-dev-14.0-update-addons",
            "type": "python",
            "request": "launch",
            "program": "~/Odoo/src/14.0/odoo-bin",
            "console": "integratedTerminal",
            "args": [
                "-c","~/Odoo/instances/odoo-dev-14.0/odoo.conf",
                "--limit-time-real", "99999",
                "-d", "odoo-dev-14.0",
                "-u","",
                "--stop-after-init"
            ]
        },
        {
            "name": "odoo-dev-14.0-repl",
            "type": "python",
            "request": "launch",
            "program": "~/Odoo/src/14.0/odoo-bin",
            "console": "integratedTerminal",
            "args": [
                "shell",
                "-c","~/Odoo/instances/odoo-dev-14.0/odoo.conf",
                "--limit-time-real", "99999",
                "--xmlrpc-port","8888",
                "--longpolling-port","8899",
                "-d", "odoo-dev-14.0",
                "--shell-interface", "ipython"
            ]
        }
    ]
}

1. Ahora, puedes elegir una de las siguientes opciones de configuración del debugger:

• odoo-dev-14.0: esta opción inicia Odoo en modo de desarrollo con la base de datos "odoo-dev-14.0".

• odoo-dev-14.0-install-addons: esta opción instala los módulos de Odoo que agregemos al parametro "-i", en la base de datos "odoo-dev-14.0".

• odoo-dev-14.0-update-addons: esta opción actualiza los módulos de Odoo que agregemos al parametro "-u", en la base de datos "odoo-dev-14.0".

• odoo-dev-14.0-repl: esta opcion inicia Odoo en modo de consola interactiva (REPL) donde puedes ejecutar comandos del ORM

El parametro "--limit-time-real" establece el tiempo máximo permitido para la ejecución de una solicitud de servidor en Odoo, con un valor de "99999" establece este límite en un tiempo muy alto, prácticamente ilimitado. Esto es útil durante el desarrollo, ya que nos permite depurar el código sin interrupciones debido a la expiración del tiempo límite de Odoo

Con la configuración adecuada, podemos utilizar el debugger de VSCode para solucionar problemas en el código de Odoo y mejorar la calidad del software. Además, al tener un debugger integrado en su entorno de desarrollo, pueden ahorrar tiempo y mejorar la eficiencia de su trabajo.

Espero que este tutorial haya sido útil para aquellos que buscan configurar el debugger de VSCode para trabajar con Odoo 14.0. Si tienes alguna pregunta o comentario, no dudes en escribirme.

Por qué tener un homelab es importante

Un homelab es una infraestructura de tecnología personal que te permite experimentar y aprender de una manera práctica cómo funcionan diferentes sistemas operativos, aplicaciones y servicios. Además, tener tu propio homelab te da la libertad de tener el control total sobre tus aplicaciones, datos y recursos. También te permite realizar pruebas en un ambiente controlado y seguro sin afectar los sistemas de producción en una empresa.

No es necesario hardware empresarial

A menudo, la gente piensa que es necesario tener hardware empresarial costoso para crear un homelab server. Sin embargo, esto no es cierto. Para proyectos personales o pequeñas empresas, no es necesario tener un servidor costoso y de alta gama. Un equipo de escritorio potente puede ser suficiente para comenzar, siempre y cuando se planifique cuidadosamente la configuración de hardware.

Cómo planificar el armado de tu homelab server

Antes de planificar la configuración de hardware para tu homelab server, debes tener claro el objetivo de tu homelab y los proyectos que deseas ejecutar. Esto te permitirá determinar los requerimientos de hardware que vas a necesitar. A continuación, algunos factores clave que debes considerar:

Procesador

El procesador es uno de los componentes más importantes de cualquier servidor. Se recomienda tener al menos un procesador de multiples nucleos, minimo 2. Para un mejor rendimiento, se recomienda optar por procesadores de la serie i7 de Intel o la serie Ryzen 7 de AMD estos proporcionará suficiente potencia de procesamiento para ejecutar varias aplicaciones y servicios simultáneamente.

RAM

La memoria RAM es otro componente crítico en la construcción de un homelab server, especialmente si planeas ejecutar varias máquinas virtuales al mismo tiempo. Se recomienda tener al menos 16 GB o 32 GB de RAM para asegurar un rendimiento óptimo. Si tienes un presupuesto ajustado, puedes empezar con 8 GB de RAM y luego actualizar a medida que sea necesario.

Almacenamiento

En cuanto al almacenamiento, hay varias opciones disponibles. Aunque los SSD son más rápidos y fiables que los discos duros tradicionales (HDD), también son más caros. Para proyectos personales o pequeñas empresas, un disco duro HDD de alta capacidad puede ser una opción más económica. Un disco duro de 1 TB o más es suficiente para la mayoría de las necesidades de almacenamiento.

Conexión a red

La conexión a red es crucial para el rendimiento del servidor. Asegúrate de tener una tarjeta de red Gigabit Ethernet para un rendimiento óptimo. Si planeas configurar tu servidor como un router o firewall, considera utilizar una tarjeta de red con múltiples puertos.

Equipos pre-armados de bajo consumo

Existen diversas opciones de equipos pre-armados de poco consumo que pueden ser utilizados como servidores para proyectos personales o pequeñas empresas:

• Raspberry Pi: La Raspberry Pi es una pequeña computadora de bajo costo que consume muy poca energía. Es perfecta para ejecutar aplicaciones de servidor livianas.

• Odroid: Odroid es otra pequeña computadora similar a la Raspberry Pi. También consume muy poca energía y es capaz de ejecutar aplicaciones de servidor.

Crear tu propio servidor homelab puede ser una experiencia emocionante y valiosa. Te permite aprender y experimentar en un entorno controlado, lo que te ayuda a desarrollar habilidades útiles en el mundo de la tecnología e informática.

• Crear nuestro README en GitHub

• Escribir un script en python para crear nuestro README dinámico

En esta tercera entrega vamos a automatizar mediante GitHub Actions la generación de nuestro archivo README.md ejecutando de forma programada nuestro script de Python que creamos en la publicación anterior.

GitHub Actions es una funcionalidad de GitHub que nos permite automatizar flujos de desarrollo directamente en nuestro repositorio de código, lo que nos da la ventaja de poder crear nuestros propios flujos y trabajos a ejecutar.

Al estar integrado con nuestro repositorio de código, tenemos la ventaja de poder crear nuestros flujos de trabajo de CI/CD, en esta publicación no profundizaremos en este tipo de implementaciones, pero si haremos uso de GitGub Actions para ejecutar nuestro propio flujo que consiste en ejecutar un script de Python y realizar un PUSH a nuestro repositorio de datos cuando exista un cambio en el archivo README.md.

Creando nuestro primer GitHub Actions

Para poder activar esta funcionalidad solo debemos crear un directorio en la raíz de nuestro proyecto llamado .github dentro de este directorio creamos otro directorio llamado workflows*.*

mkdir .github 
cd .github 
mkdir workflows

Ya con esto podemos comenzara crear nuestro workflow usando un archivo YAML, para este caso mi archivo se va a llamar python-app.yml pero puede tener el nombre que ustedes quieran.

Si hacemos un push al repositorio y revisamos el tab de "Actions" veremos nuestro workflow y estará en un estado de falla ya que aun no hemos agregado ningún trabajo ni los pasos a seguir.

# Raíz del proyecto 
git add .github/workflows/python-app.yml 
git commit -m "[ADD] new workflow for GitHub Actions" 
git push origin master

Para editar nuestro archivo lo haremos directamente desde GitHub para aprovechar el auto completado y otras herramientas que tiene GitHub para la creación de Actions, al abrir nuestro archivo escribimos lo siguiente:

Acá podemos ver del lado derecho un panel que nos puede ayudar a buscar Actions creadas por la comunidad y también nos muestra la documentación de GitHub Actions.

name: Python workflow # Nombre del workflow
on: # llave que indica que se realizara una acción sobre algun evento 
  schedule: # El evento que ejecutara la acción
    - cron: "0 */6 * * *" # configuración del intervalo de ejecución

Pudimos haber hecho que esta acción se ejecutara con otros eventos como un push o un pull request, pero de esto hablare en una siguiente publicación, para profundizar les recomiendo estas dos lecturas:

https://docs.github.com/en/actions/reference/workflow-syntax-for-github-actions#onschedule

https://docs.github.com/en/actions/reference/events-that-trigger-workflows#scheduled-events

Hasta este momento solo hemos indicado, el nombre de nuestro workflow y que sera una acción que se ejecutara de forma programada cada 6 horas, pero aun no hemos definido el job y la secuencia de pasos que se van a ejecutar, para esto debemos editar nuestro archivo y nos debe quedar de la siguiente manera:

name: Python workflow # Nombre del workflow
on: # llave que indica que se realizara una acción sobre algun evento 
  schedule: # El evento que ejecutara la acción
    - cron: "0 */6 * * *" # configuración del intervalo de ejecución

jobs:
  build:

    runs-on: ubuntu-latest

    steps:
      - uses: actions/checkout@v2
      - name: Set up Python 3.8
        uses: actions/setup-python@v2
        with:
          python-version: 3.8
      - name: Install dependencies
        run: |
          python -m pip install --upgrade pip
          pip install -r requirements.txt
      - name: Run script
        run: |
          python app.py
          git config user.name rafnixg
          git config user.email rafnixg@gmail.com
          git add README.md
          git diff --quiet && git diff --staged --quiet || git commit -m "[BOT] Update README with latest info"
          git push origin master

https://github.com/rafnixg/rafnixg/blob/master/.github/workflows/python-app.yml

Al guardar los cambios en nuestro archivo tenemos ya definido un job de nombre build con el key run-on donde indicamos que el sistema operativo que va a correr es un ubuntu-latest, si han trabajado con este tipo de archivos YAML en docker, se les hará fácil comprender este archivo, sino no hay problema acá explico que hace nuestro archivo.

Después de la definición del jobs tenemos que definir los steps, que son esos pasos que va a seguir nuestro job, aqui usamos dos actions que están disponibles en el marketplace, esta creo es una de las cosas mas interesantes de GitHub Actions, ya que podemos crear actions y compartirlas con la comunidad para que otras personas las puedan implementar, yo estaré usando en esta oportunidad "action/checkout@v2" que nos ayuda a configurar git en nuestro workspace y poder tener acceso desde el Workflow que estamos definiendo hacia nuestro repositorio y "action/setup-python@v2" que nos ayuda a configurar python en el workspace para poder correr nuestro script.

Lo siguiente sera actualizar pip e instalar las dependencias de nuestro script y ejecutar nuestro script, ya en este punto tenemos nuestro archivo READM.md actualizado en nuestro workspace, solo nos resta crear un commit con este cambio y hacer push a nuestro repositorio.

Con este push ya tenemos nuestro README.md actualizado en nuestro repositorio, ahora cada 6 horas va a correr este Workflow en donde definimos un jobs que se encarga de correr nuestro script y hacer un commit cuando exista un cambio en el archivo README.md

En próximas publicaciones hablara un poco mas sobre las GitHubs Actions y de como crear nuestras propias actions y publicarlas para que puedan ser reutilizadas, si te gusto el contenido espero tu comentario.

Sígueme en twitter @rafnixg

Ya teniendo nuestro archivo README.md creado en el post Actualiza tu perfil de GitHub con README y Github Actions - Parte 1 , nos ubicamos en la carpeta de nuestro proyecto y empezaremos creamos una copia de nuestro archivo pero con extensión .template, quedándonos algo como esto: README.md.template, este sera el archivo que usaremos como base para generar nuestro README.md

Luego editamos la sección de "Latest post (Spanish)" sustituyendo nuestros post estáticos con este código en Jinja2, que nos ayuda a iterar sobre una lista de post.

## Latest Posts (Spanish)

{% for post in latest_post %} - {{post.title}} {% endfor %}

En esta plantilla indico que le voy a pasar latest_post y que debo recorrer sus post e imprimirlos dentro de un link en markdown.

Ahora necesitamos el endpoint a el que consultaremos para obtener nuestras lista de posts, para esto haré uso de las RSS que tiene mi blog y con el siguiente servicio lo convertiré de XML a JSON

https://rss2json.com

Acá pudimos haberlo hecho de muchas maneras distintas, se pudo haber hecho el cambio de XML a JSON usando Python, mi idea era hacerlo lo mas simple posible, si tienes una idea mejor la espero en los comentarios o un Pull Request, ya con esto aclarado podemos continuar xD.

Teniendo nuestro endpoint listo procederemos a crear nuestro script en Python, por lo que primero debemos preparar, es nuestro entorno virtual que nos ayude a aislar nuestras dependencias para este proyecto, podemos hacer uso de Pipenv del cual tengo un tutorial por acá (Entornos virtuales en python usando Pipenv), pero en este caso lo haremos de la siguiente manera ya que es la mas comun.

python3 -m venv env 
source env/bin/activate 
touch app.py

Lo que creara una carpeta env en el root de nuestro proyecto, activara nuestro entorno virtual y crea nuestro archivo app.py

Para poder usar nuestras librerías debemos instalarlas, en este caso haré uso de PIP que es nuestro gestor de paquetes en python y las librería a instalar son:

• urllib3: Para realizar las consultas HTTP

• json: para parsear la información recibida en la respuesta HTTP

• jinja2: para renderizar nuestro archivo README con la potencia de esta librería de plantillas

pip install urllib3 json jinja2 
pip freeze > requirements.txt

Ya tenemos nuestras dependencias instaladas nuestras dependencias, así que procederemos a crear nuestro script, quedándonos algo como esto:

import json
import urllib3
from jinja2 import Environment, FileSystemLoader

# Cantidad maxima de posts a mostrar
MAX_POSTS = 5

# Setup
env = Environment(loader=FileSystemLoader('.'))
http = urllib3.PoolManager()

def get_latest_posts(max_posts=5):
    r = http.request('GET', 'https://api.rss2json.com/v1/api.json?rss_url=https://blog.rafnixg.dev/rss.xml')
    data = json.loads(r.data.decode('utf-8'))['items']
    return data[0:max_posts]

def render_readme(data):
    template = env.get_template('README.template')
    render = template.render(**data)
    with open("README.md", "w") as f:
        f.write(render)

def main():

    latest_posts = get_latest_posts(MAX_POSTS)
    data = {
        'latest_post': latest_posts
    }
    render_readme(data)

if __name__ == " __main__":
    main()

Las primeras 3 lineas de nuestro código son básicamente la importación de las librerías y utilidades que vamos a usar, luego definimos una constante para el numero máximo de post que vamos a escribir en nuestro archivo README.

El setup es donde indicamos a jinja en que fichero debe buscar los templates y creamos una instancia que llamaremos http para nuestras consultas HTTP

Como ven en la función get_latest_posts() es un simple petición GET a el enpoint, como parámetro le podemos limitar el numero de items que retornara

En la función render_readme() indicamos el archivo a usar como template, cargamos la data obtenida de los últimos post y lo renderizamos en nuestro template para luego escribirlo en el archivo final README.md

Con esto ya podemos correr nuestro script y ver como nos genera de forma dinámica nuestro archivo README.md

ptyhon3 app.py

Nuestro script ya genere de forma dinámica nuestro archivo README.md, con este mismo enfoque se pueden agregar muchísimas mas funciones consultando a diferentes servicios y editar desde el template como se va a renderizar esta información.

En la tercera y ultima parte veremos como automatizar la ejecución de nuestro script y actualizar README.md en nuestro repositorio de GitHub, gracias a las GitHub Actions.

Gracias por leerme, los espero por twitter @rafnixg y por mi GitHub rafnixg

Siguiente publicación de esta serie: Actualiza tu perfil de GitHub con README y GitHub Actions - Parte 3

• Crear nuestro README en GitHub

• Escribir un script en python para crear nuestro README dinámico

• Implementar GitHub Actions para automatizar nuestro README

Acá te dejo una mirada de como quedo mi perfil, espero me dejes una estrella :D

Preparando nuestro repositorio

Para iniciar, debemos crear un repositorio en GitHub con nuestro nombre de usuario, en mi caso "rafnixg", tiene que ser publico y estar inicializado con un archivo README.

Ingresando a https://github.com/new podemos crear nuestro repositorio

En mi caso ya me indica que tengo este repositorio creado, pero ademas se ve un mensaje que nos indica que activamos esta funcionalidad "secreta"

Creando nuestro README

En esta parte del proceso tendremos que empezar clonando nuestro repositorio y editar nuestro archivo README con la información que quisiéramos mostrar, para esto usaremos el siguiente comando de Git:

git clone https://github.com/tu_username/tu_username.git

Luego de clonar nuestro repositorio procedemos a crear nuestro archivo README usando Markdown, yo en esta parte del proceso use varias referencias para tomar ideas y armar algo que me gustara, les dejo por acá los enlaces para que las visiten y tomen ideas.

• https://github.com/kautukkundan/Awesome-Profile-README-templates

• https://github.com/abhisheknaiidu/awesome-github-profile-readme

Ya con una idea de lo que queremos hacer, escribimos nuestro archivo y subimos estos cambios a GitHub

git add README.md
git commit -m "[IMP] Mejora de nuestro README"
git push -u origin master

Con esto ya tendremos nuestro archivo README desplegado en nuestro perfil de GitHub.

En la segunda entrega veremos como poder obtener datos de un RSS de servicios como Ghost, Dev.to o https://hashnode.com/ y actualizar nuestro archivo README usando Python.

Siguiente de esta serie: Escribir un script en python para crear nuestro README dinámico

Gracias por leerme! los espero por mi twitter @rafnixg

¿Qué es Pelican?

Pelican es un generador de sitios estáticos desarrollado en python que nos permite escribir los post en archivos escritos en reStructuredText, Markdown, o AsciiDoc, y estos serán luego procesados para generar un sitio web estático como este blog, por lo que no necesitaremos una base de datos ni un servidor web que soporte un lenguaje de Backend como lo es GitHub Pages.

¿Qué es GitHub Pages?

GitHub Pages es un hosting de sitios estáticos y como su pagina web lo indica, esta diseñado para hostear directamente en un repositorio de GitHub la pagina web de nuestros proyecto, paginas personales o de organizaciones, ademas de ser un servicio gratuito.

Gracias a estas características, podemos fácilmente crear nuestros sitios estáticos y subirlos a un repositorio de GitHub que debe tener la siguiente estructura username.github.io mas adelante indicare como crear y configurar el repositorio para que pueda servir nuestro sitio web.

GitHub recomienda el uso de Jekyll para generar nuestros sitios estáticos, pero este esta hecho en Ruby, lo que no es un problema si usas Ruby pero yo al ser un #PythonLover decidí usar Pelican que esta desarrollado en Python.

Creando nuestro repositorio en GitHub

Esta parte es la mas sencilla de post, ya que solo debemos entrar a nuestra cuenta de GitHub y crear un nuevo repositorio publico, que tenga el siguiente nombre.

tu_username.github.io, en mi caso el repositorio donde se aloja este blog se llama rafnixg.github.io

Solo con esto ya tendremos nuestro Github Pages listo para comenzar a subir nuestro contenido estático.

Instalando y configurando Pelican

Instalar y tener Pelican funcionando es super sencillo. Pero si les quiero recomendar que toda la instalación se haga en un entorno virtual usando Pipenv, para mantener separado esta instalación de los demás paquetes de Python que tengan instalados en sus sistema, si no saben como usar Pipenv acá les dejo un post que tengo sobre este tema, Entornos virtuales en Python usando Pipenv.

Antes de iniciar con la instalación de pelican, debemos clonar nuestro repositorio donde esta hosteada nuestro blog, para esto solo debemos ubicarnos sonde queramos tener nuestro proyecto, en este caso yo lo haré en la raíz de mi sistema.

cd ~
git clone https://github.com/tu_username/tu_username.github.io.git
cd tu_username.github.io

Luego de esto, procedemos a instalar nuestro Pelican, lo primero que debemos hacer es crear un nuevo branch llamado source donde ira todo nuestro código fuente y librerías, ya que para GitHub todo lo que este en la rama master es lo que sera servido, para nuestro interés solo debemos subir a master lo que pelican genera en su carpeta output, pero mas adelante nos preocuparemos de esto.

git checkout -b source
pipenv shell

Con esto ya tendremos nuestro entorno virtual para nuestra instalación de pelican, ahora procedemos a instalar pelican que es nuestro generador de sitios estáticos, markdown que nos ayudara para escribir nuestros post usando este lenguaje y ghp-import que nos ayuda a publicar nuestro sitio a GitHub.

pipenv install pelican markdown ghp-import
Installing pelican… Adding pelican to Pipfile's [packages]… 
✔ Installation Succeeded Installing markdown… 
Adding markdown to Pipfile's [packages]… 
✔ Installation Succeeded Installing ghp-import… 
Adding ghp-import to Pipfile's [packages]… 
✔ Installation Succeeded Pipfile.lock not found, creating… 
Locking [dev-packages] dependencies… 
Locking [packages] dependencies… 
✔ Success! Updated Pipfile.lock (b0c318)! 
Installing dependencies from Pipfile.lock (b0c318)… 
🐍 ▉▉▉▉▉▉▉▉▉▉▉▉▉▉▉▉▉▉▉▉▉▉▉▉▉▉▉▉▉▉▉▉ 13/13 —

Ya con esto tenemos todo listo para empezar a usar Pelican así que creemos nuestro primer blog usándolo.

pelican-quickstart
Welcome to pelican-quickstart v4.0.1.
This script will help you create a new Pelican-based website.
Please answer the following questions so this script can generate the files needed by Pelican.
Using project associated with current virtual environment.Will save to: /home/username/blog/pelican
> What will be the title of this web site? prueba pelican 
> Who will be the author of this web site? rafnix guzman 
> What will be the default language of this web site? [es] es 
> Do you want to specify a URL prefix? e.g., https://example.com (Y/n) n 
> Do you want to enable article pagination? (Y/n) y 
> How many articles per page do you want? [10] 
> What is your time zone? [Europe/Paris] America/Lima 
> Do you want to generate a tasks.py/Makefile to automate generation and publishing? (Y/n) Y # Responder Y, esto nos ayuda mucho! 
> Do you want to upload your website using FTP? (y/N) n 
> Do you want to upload your website using SSH? (y/N) n 
> Do you want to upload your website using Dropbox? (y/N) n 
> Do you want to upload your website using S3? (y/N) n 
> Do you want to upload your website using Rackspace Cloud Files? (y/N) n 
> Do you want to upload your website using GitHub Pages? (y/N) y 
> Is this your personal page (username.github.io)? (y/N) y 
Done. Your new project is available at /home/username/blog/pelican

Si tienen alguna duda respecto a la zona horaria acá les dejo una lista con todas las zonas horarias

> Do you want to generate a tasks.py/Makefile to automate generation and publishing? (Y/n)

A esta pregunta deben responder (Y), ya que este Makefile nos ayudara a generar nuestro sitio de forma mas fácil, como podemos ver ya con esto se nos ha generado nuestro proyecto de pelican con el que podemos empezar a trabajar.

Escribiendo nuestro primer post

Vamos a crear nuestro primer post, para esto nos debemos ubicar en la carpeta content y con nuestro editor de texto favorito procedemos a crear un archivo llamado hola-mundo.md (si, lo se, la imaginación esta a la orden del día), este archivo luego puede ser borrado es solo para pruebas.

Title: Hola Mundo 
Date: 2019-05-18 10:30 
Modified: 2019-05-18 11:30 
Category: blog Tags: principal, otros 
Slug: hola-mundo Authors: Rafnix Guzmán 
Summary: Mi primer post usando Pelican y GitHub Pages

Aca pueden empezar a escribir todo lo que quieran pueden agregar todas las sintaxis de Markdown que deseen.

## Título 
### Subtítulo 
Este es un ejemplo de texto que da entrada a una lista genérica de elementos:
- Elemento 1 
- Elemento 2 
- Elemento 3
Este es un ejemplo de texto que da entrada a una lista numerada:
1. Elemento 1 
2. Elemento 2 
3. Elemento 3
Al texto en Markdown puedes añadirle formato como negrita o cursiva de una manera muy sencilla.

Todo esto fue extraído de este [Post sobre markdown](https://markdown.es/sintaxis-markdown/)

Probando nuestro blog en local

Luego de escribir y guardar su primer post, procedemos a generar un servidor de pruebas para ver nuestro resultado antes de subir nuestra web a GitHub, estando en la raíz de nuestro proyecto ejecutamos el siguiente comando.

make devserver pelican \
-lr /home/username/blog/pelican/content \
-o /home/username/blog/pelican/output \
-s /home/username/blog/pelican/pelicanconf.py

-> Modified: content, theme, settings. re-generating... 
Done: Processed 1 article, 0 drafts, 0 pages, 0 hidden pages and 0 draft pages in 0.15 seconds.

Se usa "\" para indicar que el comando tiene varias lineas

Para entrar a nuestro servidor local de pruebas debemos ingresar a la siguiente URL http://localhost:8000 con nuestro explorador favorito/

Hola mundo pelican

Subir nuestro blog a GitHub Pages

Ya con esto procederemos a preparar todo para subir lo a github, este primer comando sube nuestro código fuente.

git add -A && git commit -a -m 'post hola-mundo.md' && git push --all

Ahora subimos todo a la rama master, recuerdan que les dije que no se preocuparan por esto, es debido a que este comando hace toda esta preparación de subir todo lo que se encuentra en la carpeta output a nuestra rama master

make github

Acá se les preguntaran sus credenciales de github, para poder subir a su repositorio todo el sitio estático ya generado, con esto su blog estará funcionando en https://su_username.github.io/

Para el próximo post veremos como configurar un Thema y algunos Plugins para potenciar el funcionamiento de Pelican, ademas de unas configuraciones extra que nos ayudaran a tener mejor SEO.

Nos vemos en el proximo post, muchas gracias por leerme y cualquier duda, comentario, o lo que sea, lo pueden dejar por aca o por mi cuenta de Twitter @rafnixg.

Esta herramienta básicamente nos ayuda a optimizar nuestro flujo de desarrollo unificando pip y virtualenv en una sola herramienta que funciona por linea de comandos (Terminal), lo que nos daria un entorno aislado en el cual instalar nuestras dependencia y luego replicar este mismo entorno en otra maquina gracias a el archivo que se genera Pipfile, que viene a ser el sustituto del archivo que genera pip requirements.txt

Instalando Pipenv

El proceso de instalación de Pipenv es muy sencillo, en esta ocasión voy a detallar 2 formas de instalar usando lo indicado en la documentación oficial.

Si estas usando Ubuntu 16.04:

sudo apt install software-properties-common python-software-properties
sudo add-apt-repository ppa:pypa/ppa
sudo apt update
sudo apt install pipenv

Esta otra opción es por si ya tienes instalado pip:

pip install pipenv

Como acabamos de ver la instalación es muy sencilla, de igual manera si tienen algún problema con la instalación me pueden escribir.

Usando Pipenv

Para efectos de este ejemplo vamos a generar una aplicación sencilla usando Flask y haremos el típico Hola Mundo, ya que este post no se trata de desarrollo de apps usando Flask

Primero creamos nuestro entorno virtual para aislar nuestra aplicación:

pipenv shell

Creating a virtualenv for this project… Pipfile: /home/usuario/nombre_del_proyecto/Pipfile Using /usr/bin/python3 (3.6.7) to create virtualenv…

Con la ejecución de este comando se crea un entorno virtual si no existe, ademas de crear 2 archivos: Pipfile y Pipfile.lock.

Si se instala en un proyecto preexistente Pipenv convierte tu archivo requirements.txt en Pipfile.

Para este proyecto se ha creado un entorno con una versión de python 3, si necesitas instalar una versión de python 2 solo debes agregar el argumento --two, también funciona para python 3 el argumento --three.

pipenv shell --two #Genera entorno en Python2
pipenv shell --three #Genera entorno en Python3

Ahora procedemos a instalar los paquetes que necesitamos, en nuestro caso Flask, pero supondremos que necesitamos una versión especifica para este ejemplo usaremos la versión 1.0, para el momento de escribir este post la versión latest de Flask es la 1.0.2

pipenv install flask==1.0
Installing flask==1.0… Adding flask to Pipfile's [packages]… 
✔ Installation Succeeded Pipfile.lock not found, creating… 
Locking [dev-packages] dependencies… 
Locking [packages] dependencies… 
✔ Success! 
Updated Pipfile.lock (db0e09)! 
Installing dependencies from Pipfile.lock (db0e09)… 
🐍 ▉▉▉▉▉▉▉▉▉▉▉▉▉▉▉▉▉▉▉▉▉▉▉▉▉▉▉▉▉▉▉▉ 6/6 —

Con esto ya tendremos Flask instalado en nuestro entorno virtual, y procedemos a realizar nuestro desarrollo.

Crean un archivo llamado apps.py con este contenido dentro:

from flask import Flask app = Flask(name)

@app.route("/")
def hello():
    return "Hello World!"

Por ultimo iniciamos nuestro servidor Flask

FLASK_APP=apps.py flask run

* Serving Flask app "apps.py" * Environment: production WARNING: Do not use the development server in a production environment. Use a production WSGI server instead.
* Debug mode: off
* Running on http://127.0.0.1:5000/ (Press CTRL+C to quit)

Con esto tendremos nuestro server Flask corriendo nuestro archivo apps.py.

Consideraciones finales

A lo largo de este post hemos visto como el flujo de trabajo se puede optimizar con el uso de esta herramienta, ya que no debemos generar los entornos virtuales por separado usando algo como virtualenv con el que como yo muchas personas no han estado conformes, también hemos visto como instalar paquetes usando pipenv tan fácil como si usáramos pip, queda de parte de cada quien darle una probada a esta herramienta y ver si le ayuda a optimizar su flujo de desarrollo y mantener un poco más homogéneo los ambientes de desarrollo.

Si deseas que siga publicando contenido sobre entornos virtuales, pip, o explique más a fondo los ficheros Pipfileo Pipfile.lock, que otros comandos puede ejecutar Pipenv, solo házmelo saber en un comentario o a través de mi cuenta twitter @rafnixg

Referencias

Documentación Pipenv

Introducción

Cuando queremos desplegar nuestros proyectos webs en estos servicios de bajo costo o gratuitos, nos encontramos con una limitante de que no tenemos acceso por SSH, sino que nos colocan a disposición una cuenta FTP.

Para muchos que no han usado o trabajado con el control de versiones esto no es un problema, pero si queremos mantener un buen flujo de trabajo y llevar el seguimiento de nuestro proyecto usar git es tarea fundamental y a la hora del despliegue es una herramienta que nos facilita la vida, a diferencia de FTP que hace el proceso de despliegue muy tedioso y con mucha perdida de tiempo, ya que debemos saber que archivos fueron modificados para subir al servidor.

Git-FTP

Esa herramienta nos viene a solucionar ese problema de no subir todos los archivos o seleccionar de forma manual los archivos que deseamos subir al servidor, sino que el se encarga de revisar que archivos fueron modificados desde la ultima actualización y solo sube estos archivos.

Que belleza y que hermosura fue lo que yo pensé cuando di con esta herramienta, ya que obviamente hace que nuestro flujo de trabajo sea mas optimo que usando solamente FTP, pero no todo es así de bello existe una limitación al usar este cliente FTP y es que las modificaciones hechas directamente sobre el servidor no serán vista desde nuestra área local, por lo que aconsejo mantener esto en cuenta.

Instalacion de Git-FTP

La instalación es muy sencilla para los que usamos GNU/Linux yo en especial uso Debian es muy sencillo de instalar usando la terminal, para los que usen otro sistema operativo acá les dejo el Manual de Instalación Oficial donde encontraran la instalación para los siguientes Sistemas operativos:

• Linux/Unix usando make

• Debian, Ubuntu y otros usando apt

• ArchLinux

• Mac OS X

• Windows

Para los que usamos Debian o Ubuntu solo debemos teclear esto en la terminal

sudo apt-get install git-ftp

Con esto ya tendríamos Git-FTP instalado

Configuración

La configuración es muy sencilla desde nuestro terminal usamos los siguientes comandos:

git config git-ftp.url ftp.example.net
git config git-ftp.user ftp-user
git config git-ftp.password secr3t

Ya con esto tendríamos configurada la conexión a nuestro servidor por FTP, solo resta ubicarnos en la carpeta de nuestro proyecto y dependiendo las siguientes 2 opciones ejecutar el comando que sea conveniente:

• Subir todos los archivos (inicializacion)
  git ftp init

• Indicar que los archivos ya se encuentran en el servidor.
  git ftp catchup

Haciendo Deploy

Para hacer deploy seguimos nuestro flujo de trabajo normal usando git, en el momento que necesitemos subir los archivos modificados al servidor solo debemos ejecutar este comando en la terminal:

git ftp push

Con esto ya tendremos nuestros archivos en el servidor.

Recomendación

Mantener siempre el mismo flujo de trabajo y no modificar archivos directamente al servidor.

Leer la documentación Oficial de Git-FTP - Pagina Oficial de Git-FTP

Para resolver este problema existen muchos camino, el que yo propongo aquí es el que mas se adapto a mis necesidades y espero que pueda ayudar en las suyas, para todos esos que usan Sublime Text y mantiene este flujo de trabajo de crear código en sublime y luego pasarlo a un explorador y depurar en la consola del explorador doy este pequeño pero para mi poderoso tip.

Inicialmente debemos tener instalado Sublime Text, es muy sencillo de instalar y en su sitio web existe mucha documentación al respecto, y lo segundo que tendremos que tener instalado es Node.js,

Si aun no tienes instalado Node.js acá te dejo la documentación oficial donde encontrás la guiá de como instalarlo en cualquier sistema operativo que uses, Manual de Instalación

Configurando Sublime

Luego de tener Sublime Text y Node.js instalados y funcionando, vamos a proceder a hacer una pequeña configuración en sublime Text, para esto debemos ingresar en “Tools > Build System > New Build System”, se abrirá un documento nuevo con el siguiente contenido:

{
    "cmd": ["make"]
}

Este contenido debe ser sustituido por el siguiente:

{
"cmd": ["node", "$file"],
"selector": "source.js"
}

Hecho esto procedemos a guardar el archivo en la ruta sugerida por Sublime Text, para poder probar que esta funcionando solo debemos crear un nuevo archivo JS con el código JavaScript que deseen, recomiendo solo a modo de prueba el siguiente:

console.log("JavaScript funcionando desde Sublime Text")

Guardan el archivo nuevo con el nombre que deseen en mi caso “prueba.js” y para poder ejecutarlo deben ir a “Tools > Build” o ejecutando la siguiente combinación de teclas “Control + B”.

Recomendaciones

Para los que se están iniciando en el mundo de JavaScript los recomiendo leer un poco sobre Node.js y lo potente que puede llegar a ser, ya que en este post no se aprecia la potencia de este.

Instalar Snippets y verificadores de código para Sublime Text, para aumentar su productividad y saber donde puedan tener posibles errores.