Pedro Gomez

PKM_definitivo_v20_final_2

2026-09-02T00:00:00+02:00

*Disclaimer
Estamos trabajando ello...

TLDR: Obsidian + Git + Quilden

Desktop: La Aplicación de notas definitiva

Se han escrito ríos de tinta sobre el tema del PKM (Personal Knowledge Manager). Vaya por delante que no soy ningún experto en la materia. Soy el cuñado en el bar diciendo “tienen que jugar más por la banda”.

Qué es un PKM?

Se supone que es el “Jardín de tu conocimiento”, dónde lo vas a apuntar todo. Cosas que has aprendido, cosas que quieres aprender, reflexiones profundas que no le importan a nadie y son demasiado largas para una taza… - Pero Pedro, yo lo que no sé, lo busco en Google (update: le pregunto a una IA random) - Perfecto, toma, un Sugus. Yo primero lo busco en mis apuntes, si no lo encuentro, lo busco y lo apunto para la siguiente. ¿Por que? No sé, se me hace más rápido de buscar, está escrito a mi manera, me hace ilusión tenerlo, mientras lo escribo aprendo. Pero que si a ti no te funciona, no lo hagas eh! Es más, te diría que es una pérdida de tiempo.

Aplicaciones

Recuerdo los inicios con Evernote y el método de organización GTD (Getting Things Done). Cambié de sistema en el momento en que Evernote empezó a ponerse pesado con el sistema de pago. Aquí salté a Org-mode y Emacs, más adelante incorporé org-roam. El sistema tenía básicamente 2 problemas; la complejidad de la configuración, y su uso des del móvil. Cansado, decidí buscar alternativas, pasé por Joplin, Logseq, y Obsidian. De momento he decidido quedarme con Obsidian por 2 motivos; la facilidad de la configuración y el ecosistema de plugins. ¿Se acabó el viaje?. Obviamente, no. Obsidian NO es open-source. En cualquier momento puede volver a pasar lo de Evernote. La verdad es que voy mirando de reojo a Logseq, es probable que en algún momento acabe allí.

Plugins

Por el momento hay un montón de plugins que me hacen quedarme en Obsidian. Alguno de ellos son: - Readeck: Tengo una instancia de Readeck donde guardo artículos que me han gustado o que me interesan. - Highlights: Cuando leo en mi Kindle Paperwhite me gusta ir subrayando todo lo que me parezca interesante. Cuando conecto el kindle al PC puedo importar todo lo que he subrayado. - Git: Pieza esencial para configuración. Las notas se suben a un repositorio “privado” de Github.

Sync

Las notas se encuentran en una carpeta en mi instancia de Nextcloud. Sincronizo la carpeta entre mis ordenadores, y eso me permite acceder a mis notas des de diferentes ordenadores.

Cada cliente de obsidian tiene una configuración separada. Al tener diferentes sistemas operativos, no quiero que la configuración sea la misma en todos. Esto es muy útil para tener todas las configuraciones sincronizadas sin que interfieran entre ellas.

OK y el móvil?

Obsidian dispone de aplicación oficial para Android. Estaría muy bien si la aplicación pudiera conectarse a un servidor Webdav, como no es posible, utilizo Github para sincronizar las notas. GitSync sincroniza un repositorio de Github con una carpeta local de Android. Esto me permite tener las notas en local y acceder con Obsidian. Todavía tengo que investigar el manual, pero parece que esto podria hacerse de manera automáitca cada vez que se abra la aplicación de Obsidian. Acutalmente lo hago manualmente antes de abrir la aplicación.

Aja… yo quiero una PWA

Escribir notas des del móbil es una auténtica pérdida de tiempo (humilde opinión). Cuando quiero escribir una nota y no tengo ninguno de mis portátiles a mano, puedo acceder a Quilden.com. Es un frontend muy simplificado de Obsidian que te permite acceder a tu repositorio de Github.

Conclusión

¿Me gusta la configuración actual?. NO. ¿La voy a utilizar hasta que me canse, hasta que Github u Obsidian pertuben mi paz? AFIRMATIVO.

En algún momento se romperá todo, y no me procupa. No me va la vida en esto. Cuando se rompa, me preocuparé. Ahora, no. Enjoy the process.

GL&HF

Usando zsh en la terminal

2023-03-26T00:00:00+01:00

*Disclaimer: No te fies de este blog

TLDR: Utilizando el shell de zsh. Plugins que he añadido.

Intro

Necesitaba facilitarme la vida en la terminal, sobretodo algún auto completar y seleccionado con el tabulador. He decidido utilizar el shell de zsh, y ohmyzsh para la instalación de plugins.

Plugins utilizados

zsh-autocomplete

Según su repositorio debería de tener múltiples funciones. En mi caso, la única función que me permite es el auto-complete. Pulsando la flecha derecha auto completa el comando sugerido.

Copypath

El comando copypath copia la ruta del directorio actual, copypath <file_or_directory> copia la ruta del directorio del archivo .

Copybuffer

ctrl-o copia el texto actual de la linea de comando.

The Silver Searcher

ag busca recursivamente en el directorio actual y en todos los subdirectorios.

Tema

Gallois

Extra

Si alguien necesita información extra, a mi ha ido muy bien este blog de Tim James

Muchos dockers, poca diversión

2023-02-14T00:00:00+01:00

*Disclaimer: Esto me funciona a mí, puede que a tí no.

TLDR: LOOPS EN BASH!!

Estructura

La estructura de las carpetas, dónde se encuentran los dockers-compose.yaml es la siguiente:

DockerFolder/
|-> AplicaciónLegal_1/
    |-> docker-compose.yaml
    |-> config folders and files
|-> AplicaciónLegal_2/
    |-> docker-compose.yaml
    |-> config folders and files
.env

La carpeta DockerFolder solo contiene otras carpetas y un archivo .env. Las carpetas interiores contienen el docker-compose.yaml y otras carpetas de configuración para la cada aplicación. El arhcivo .env contiene variables necesarias para ejecutar los docker-compose. Por ejemplo:

SECURE_PASSWORD=123456
MOVIES_DIR=/srv/dev-externalfiles/Movies

En los archivos docker-compose nos podemos referir a estas variables de la siguiente manera:

    volumes:
      - ./config:/config
      - ${MOVIES_DIR}:/movies

Magia

Si queremos parar todos los dockers nos situamos dentro de la carpeta DockerFolder/ y ejecutamos;

for dir in */; do docker-compose --env-file .env -f "$dir"/docker-compose.yaml down; done

Si queremos iniciar todos los dockers nos situamos dentro de la carpeta DockerFolder/ y ejecutamos;

for dir in */; do docker-compose --env-file .env -f "$dir"/docker-compose.yaml up -d; done

También podríamos incluir up -d --force-recreate si fuera necesario.

Tmux; un pasito más

En mi caso los dockers están en un servidor al cual me conecto por ssh. Cuando hay muchos dockers estas operaciones pueden tardar un poco, por eso utilizo Tmux.

Una vez tenemos instalado Tmux, abrimos la terminal y ejecutamos Tmux. Des de Tmux accedemos al servidor por ssh y ejecutamos el comando que queramos. Mientras se ejecuta, presionamos Ctrl+b d. Esto deja la sesión en un segundo plano (deattach). En este punto ya podemos cerrar la terminal y esperar tranquilamente a que pase el tiempo.

Cuando queramos comprobar el estado del comando, abrimos la terminal y ejecutamos tmux attach, esto nos llevarà a la sesión anterior y podremos ver si ha finalizado.

Esto se puede aplicar a muchas otras tareas, copias de seguridad, aplicaciones..

Nextcloud background cronjob

2022-01-30T00:00:00+01:00

Nextcloud cronjob

Determinadas tareas se realizan automáticamente en segundo plano. Según la documentación de Nextcloud hay 3 formas de realizar estas tareas:

AJAX
WEBCRON
CRON

En la documentación ofical, la forma recomendada es “Cron”.

Cron hace referencia a crontab. Un archivo que ejecuta las tareas indicadas en él, en el intervalo de tiempo indicado. El script a ejecutar es “cron.php” y debería ejecutarlo el usuario www-data cada 5 min.

En mi caso uso Nextcloud en un docker denominado (container_name) “nextcloud”, por lo tanto tengo que hacer lo siguiente:

Editamos crontab usando el siguiente comando:

crontab -e

Añadimos la siguiente linea al documento:

*/5 * * * * docker exec -d --user www-data nextcloud php -f /var/www/html/cron.ph

Dentro del docker nextcloud ejecuta el script cron.php como el usuario www-data cada 5 minutos.

SqlAlchemy Intro (1): Engine.

2021-11-03T00:00:00+01:00

*Disclaimer: No tengo la carrera de ingeniería informática, soy un aficionado!

TLDR: Para trabajar con SQLAlchemy necesitamos crear el objeto Engine.

¿Qué es esto?

En algún momento necesitaré interactuar con bases de datos. Quizá aprender SQLAlchemy haga el trabajo un poco menos pesado, así que esto van a ser un poco mis apuntes y notas.

Pasamos a 2.0.

Parece que en la versión 1.4 hay un cambio de paradigma y se convertirá en la 2.0.

Utilizaremos la guía oficial.

Como síntesis parece que la gran diferencia entre la 1.3 y la 1.4 es:

The ORM now uses Core-style querying with the select() construct, and transactional semantics between Core connections and ORM sessions are equivalent.

En cuanto al resto nos vamos a olvidar de las diferencias entre 1.3 y 1.4 ya que no sabíamos nada de la 1.3. XD. Vamos directamente a la 2.0.

API’s.

SQLAlchemy Tiene dos API’s para interactuar con las bases de datos: CORE y ORM.

ORM: The ORM provides an additional configuration layer allowing user-defined Python classes to be mapped to database tables and other constructs, as well as an object persistence mechanism known as the Session.

CORE: The library provides tools for managing connectivity to a database, interacting with database queries and results, and programmatic construction of SQL statements.

Estableciendo conexión - The Engine:

Engine és el objeto que actúa como fuente central de todas las conexiones a la base de datos. Es lo primero que hay que definir.

Se crea con la función create_engine(url, **kwargs). El argumento principal es un string que contiene la dirección de la base de datos además de otros argumentos necesarios para la conexión. Profundizaré más adelante acerca de este string.

Es importante que uno de los argumentos sea future=True, esto nos permitirá hacer uso del estilo de la versión 2.0.

>>> from sqlalchemy import create_engine
>>> engine = create_engine("sqlite+pysqlite:///:memory:", echo=True, future=True)

SqlAlchemy Intro (3): Metadata.

2021-07-27T00:00:00+02:00

*Disclaimer: Hoy es lunes, y mañana será martes. “Deal with it!”

TLDR: Diferentes maneras de crear tablas en una base de datos. Mi intención es utilizar la metodologia ORM. Las tablas se crean extendiendo una clase Base.

Siguiendo con la guía de introducción a SQLAlchemy.

Componentes de la base de datos: Metadata

Los cimientos de las interacciones de SQLAlchemy con la base de datos son un conjuto de objetos Python que representan conceptos de la base de datos, el conjunto de estos objetos se denomina “database metadata”. Algunos de estos objetos son; tablas, columnas…

Una base de datos puede tener diferentes conjutos de metadatos, pero habitualmente si usamos tablas relacionadas entre ellas es mejor usar un solo objeto de metadatos.

>>> from sqlalchemy import MetaData
>>> metadata = MetaData()

Estructura básica: “Table”.

Las tablas (“Table”), son la unidad básica del conjunto de metadatos. Hay dos formas de crear una tabla reflejarla o declararla.

Declarar tablas.

Declarar una tabla significa definir una tabla para añadirla al conjunto de metadatos. Hay tres formas de declarar:

Usando Core.

Creamos la tabla como una instancia de la clase “Table”.

>>> from sqlalchemy import Table, Column, Integer, String
>>> from sqlalchemy import ForeignKey
>>> user_table = Table(
...     "user_account",
...     metadata,
...     Column('id', Integer, primary_key=True),
...     Column('name', String(30)),
...     Column('fullname', String)
... )
>>> address_table = Table(
...     "address",
...     metadata,
...     Column('id', Integer, primary_key=True),
...     Column('user_id', ForeignKey('user_account.id'), nullable=False),
...     Column('email_address', String, nullable=False)
... )

De esta forma las tabla se agregan a la metadata. “Column” es una clase que representa una columna de la tabla. “Integer” o “String” los tipos de datos que contendrá la columna (“Column and Data Types”).

También se puden crear relaciones y restricciones entre tablas. En la tabla denominada “user_account” se crea una clave primaria con el atributo de la columna primary_key=True. Como contraparte, en la tabla “address” se crea una columna denominada “user_id” que mediante la función ForeignKey()hace referencia a la clave primaria antes mencionada. Al utilizar ForeignKey() no es necesario definir el tipo de dato de la columna, ya que heredará el tipo de dato de la clave primaria.

Además del tipo de dato y de la restricción de clave externa, también se pueden crear restricciones de obligatoriedad. Al indicar nullable=False restingimos la columna a NO estar vacía.

Para crear las tablas en la base de datos utilizaremos la función “MetaData.create_all()”.

metadata.create_all(engine)

Usando ORM.

Para crear tablas usando la metodología ORM utilizaremos una clase base, y a partir de esa clase crearemos otras clases que representarán las diferentes tablas.

Para crear la clase base utilizaremos la función “declarative_base()”.

from sqlalchemy.orm import declarative_base
Base = declarative_base()

Esta función además de crear una clase base, también crea un registro (“registry”), y éste crea la metadata.

Una vez definida la clae Base, podemos definir las tablas.

>>> from sqlalchemy.orm import relationship
>>> class User(Base):
...     __tablename__ = 'user_account'
...
...     id = Column(Integer, primary_key=True)
...     name = Column(String(30))
...     fullname = Column(String)
...
...     addresses = relationship("Address", back_populates="user")
...
...     def __repr__(self):
...        return f"User(id={self.id!r}, name={self.name!r}, fullname={self.fullname!r})"

>>> class Address(Base):
...     __tablename__ = 'address'
...
...     id = Column(Integer, primary_key=True)
...     email_address = Column(String, nullable=False)
...     user_id = Column(Integer, ForeignKey('user_account.id'))
...
...     user = relationship("User", back_populates="addresses")
...
...     def __repr__(self):
...         return f"Address(id={self.id!r}, email_address={self.email_address!r})"

Estas clases creadas también incluyen objetos tipo tabla como los creados en la sección del uso de la metodologia “Core”. Se puede acceder a éstos objetos con el atributo .__table__. Este objeto se crea graicas al atributo de la clase Base denominado .__tablename__.

En este ejemplo también se ha utilizado la restricción de clave primaria y clave externa. Para crear esta relación se utiliza la función “relationship()”.

Para crear las tablas en la base de datos utilizaremos “Metadata.create_all()”.

Base.metadata.create_all(engine)

Usando un método híbrido.

En el método híbrido crearemos la tabla como si utilizaramos el método “Core”, y posteriormente la integraremos en la clase “Base” del método “ORM”.

class User(Base):
    __table__ = user_table

     addresses = relationship("Address", back_populates="user")

     def __repr__(self):
        return f"User({self.name!r}, {self.fullname!r})"

class Address(Base):
    __table__ = address_table

     user = relationship("User", back_populates="addresses")

     def __repr__(self):
         return f"Address({self.email_address!r})"

En este caso en vez de utilizar el atributo .__tablename__ para crear el objeto “table”, directamente usamos el atributo .__table__ y le asignamos el objeto creador mediate el método “Core”.

Reflejar tablas.

Este método de creación de tablas no me acaba de quedar del todo claro. Parece que en vez de crear una tabla en la metadata, lo que hace es copiar la estructura de una tabla creada previamente. No creo que vaya a usar este sistema, para más información aquí y aquí.

SqlAlchemy Intro (2): Conectando.

2021-07-26T00:00:00+02:00

*Disclaimer: Si quieres aprender, no leas, escribe.

TLDR: Creamos el objeto de conexion al engine con engine.connect() o con Session(engine), dependiendo si trabajamos con Core o con ORM. Si realizamos consultas se nos retornará el objeto Result.

Siguiendo con la guía de introducción a SQLAlchemy.

Transacciones: trabajando con el engine.

Conexiones `engine.connect()`:

Esta función se usa para crear un objeto que permite interactuar con la base de datos. Habitualmente se usa dentro de un “context manager”. De esta manera que podríamos ejecutar una consulta a la base de datos de la siguiente forma:

from sqlalchemy import text

with engine.connect() as conn:
    result = conn.execute(text("select 'hello world'"))
    print(result.all())

Los cambios ejecutados no se efectúan hasta no hacer un “commit” al objeto.

Hay un modo “autocommit”, que explicaremos más adelante.

Cambios persistentes:

Para que los cambios realizados en una consulta sean persistentes utilizaremos la función commit() del objeto de conexión.

with engine.connect() as conn:
    conn.execute(text("CREATE TABLE some_table (x int, y int)"))
    conn.execute(
        text("INSERT INTO some_table (x, y) VALUES (:x, :y)"),
        [{"x": 1, "y": 1}, {"x": 2, "y": 4}]
    )
    conn.commit()

De esta manera cuando queremos realizar un cambio permanente simplemente ejecutamos la función Commit() para hacerlo permanente. A esto se le llama “commit as you go”.

El otro sistema para hacer cambios permanentes se denomina “begin once”. Con este sistema en vez de utilizar engine.connect(), utilizaremos “engine.begin()”. Este método creará la conexión y hará “commit” una vez finalizado el bucle.

with engine.begin() as conn:
    conn.execute(
        text("INSERT INTO some_table (x, y) VALUES (:x, :y)"),
        [{"x": 6, "y": 10}, {"x": 9, "y": 10}]
    )

Instrucciones básicas.

El objeto que retorna una consulta, tanto las consultas Conection.execute() como las consultas Session.execute() (de las que hablaremos más adelante), se denomina Result. Éste es un objeto iterable compuesto por filas de resultados (Row). Las filas se componen de “named tuples”,

Obtención de valores de las filas.

Tuple Assignment:

result = conn.execute(text("select x, y from some_table"))

for x, y in result:
    # ...

Integer Index:

result = conn.execute(text("select x, y from some_table"))

  for row in result:
      x = row[0]

Attribute Name:

result = conn.execute(text("select x, y from some_table"))

for row in result:
    y = row.y

    # illustrate use with Python f-strings
    print(f"Row: {row.x} {row.y}")

Mapping Access:

Mediante la función “Result.mappings()”, transformamos el resultado en un generador de diccionarios. De esta manera cada fila es un diccionario compuesto del nombre de la columna y su valor.

result = conn.execute(text("select x, y from some_table"))

for dict_row in result.mappings():
    x = dict_row['x']
    y = dict_row['y']

Envío de parámetros.

Hasta el momento hemos ejecutado declaración SQL utilizando la funicón Connection.execute(), ésta también permite incluir parámetros en ella llamados “bound parameters”.

>>> with engine.connect() as conn:
...     result = conn.execute(
...         text("SELECT x, y FROM some_table WHERE y > :y"),
...         {"y": 2}
...     )
...     for row in result:
...        print(f"x: {row.x}  y: {row.y}")

El parámetro se presenta dentro de la función text() como “:y”. En el siguiente argumento de la función Conection.execute() incluimos los “bound parameters”, en este caso un diccionario que contiene el nombre del parámetro presentado anteriormente “:y” y su valor.

Cuando se trata de enviar un único parámetro se puede integrar en la declración SQL mediente el método “TextClause.bindparams()”.

>>> stmt = text("SELECT x, y FROM some_table WHERE y > :y ORDER BY x, y").bindparams(y=6)
>>> with engine.connect() as conn:
...     result = conn.execute(stmt)
...     for row in result:
...        print(f"x: {row.x}  y: {row.y}")

Envío de múltiples parámetros:

En el caso de declaraciones SQL que no retornan un resultado (p.ej. “INSERT”), podemos enviar múltiples parámetros de la misma manera que en el ejemplo anterior, pero en vez de incluir un diccionario como “bound parameters” incluimos una lista de diccionarios.

>>> with engine.connect() as conn:
...     conn.execute(
...         text("INSERT INTO some_table (x, y) VALUES (:x, :y)"),
...         [{"x": 11, "y": 12}, {"x": 13, "y": 14}]
...     )
...     conn.commit()

Ejecutando con ORM: “Session”.

Podríamos decir que el equivalente ORM de la “Connection” usada en “Core” es “Session”.

>>> from sqlalchemy.orm import Session

>>> stmt = text("SELECT x, y FROM some_table WHERE y > :y ORDER BY x, y").bindparams(y=6)
>>> with Session(engine) as session:
...     result = session.execute(stmt)
...     for row in result:
...        print(f"x: {row.x}  y: {row.y}")

El objeto “Session” también permite el uso de “Commit as you go” y el envío de múltiples parámetros con “bound parmeters”.

>>> with Session(engine) as session:
...     result = session.execute(
...         text("UPDATE some_table SET y=:y WHERE x=:x"),
...         [{"x": 9, "y":11}, {"x": 13, "y": 15}]
...     )
...     session.commit()

Atajos de teclado Doom-Emacs.

2021-07-13T00:00:00+02:00

Creo que lo mejor para adaptarse a una aplicación es escribir sobre ella. Voy a ir poniendo, poco a poco los atajos que voy usando en la aplicación. No me apetecía mucho ponerme a configurar Emacs desde cero, así que utilizaré Doom-Emacs.

Emacs functions:

(org-narrow-to-subtree) SPC-m-s-n: Cuando estas trabajando en un archivo muy grande y quieres centrarte solo en un “subtree”, utilizamos (org-narrow-to-subtree) para restringir la información a esa rama.
(widen) SPC-m-s-N: Para remover la restricción.
(doom/toggle-line-numbers) SPC-t-l: Recorre la secuencia de opciones para mostrar los números de línea.
(query-replace) M-%: Entrar en el modo reemplazar texto. Indicar la palabra a reemplazar y la palabra con la que se quiere reemplazar. Después apretar “!”, para reemplazarlas todas o “y” para reemplazar de una a una.
(link-hint-open-link SPC-s-l: Resalta todos los enlaces visibles, puedes abrir cualquiera seleccionando las letras.
(ffap-menu &optional RESCAN)SPC-s-L: Abre un buffer con todos los enlaces del buffer.
(org-next-link) ]-l: Se dirige al siguiente enlace del documento. Se puede presionar enter para abrir el enlace.
(org-previous-link) [-l: Se dirige al enlace previo a la posición del cursor. Se puede presionar enter para abrir el enlace.
(counsel-grep-or-swiper) SPC-s-b: Realiza una búsqueda en el buffer actual del término que le indiques. Es muy visual y bastante rápido.

Help functions:

(describe-function) SPC-h-f: Al ejecutar esta función puedes introducir el nombre de otra función y te indicará la documentación de la misma.
(describe-key) SPC-h-k: Al ejecutar esta función puedes introducir otra combinación de teclas y te indicará que función corresponde a esa combinación.

Vim text movement.

i: Insert mode. Tan solo para escribir.
ESC: Volver al modo normal.
t: Moverte hacia adelante hasta un espacio antes del caràcter indicado a posteriori. ,: Moverte a la siguiente coincidencia. ;: Moverte a la coincidencia anterior.
T: Moverte hacia atrás hasta un espacio antes del caràcter indicado a posteriori. ,: Moverte a la siguiente coincidencia. ;: Moverte a la coincidencia anterior.
f: Moverte hacia adelante hasta el caràcter indicado a posteriori. ,: Moverte a la siguiente coincidencia. ;: Moverte a la coincidencia anterior.
F: Moverte hacia atrás hasta el caràcter indicado a posteriori. ,: Moverte a la siguiente coincidencia. ;: Moverte a la coincidencia anterior.
Ctrl+d: Scroll media pantalla hacia abajo.
Ctrl+u: Scroll media pantalla hacia arriba.
Ctrl+f: Scroll pantalla completa hacia abajo.
Ctrl+b: Scroll pantalla completa hacia arriba.

Keybindings Insert Mode:

Cuando se utiliza el modo “insert mode” las combinaciones de teclas cambian.

Para pegar texto podemos utilizar las siguientes combinaciones: info

Distrohopping! Me voy a Manjaro.

2021-02-28T00:00:00+01:00

De Ubuntu a Manjaro.

He decido cambiar de distro por 2 motivos:

En Ubuntu me resultaba más complicado mantener todos los paquetes actualizados “a la última”.
Habían ciertas cosas que no acaban de funcionar como el Bluetooth de mi portátil.

Primeros problemas: El Trackpad no funciona como me gustaría.

Linux cada vez es más sencillo de configurar y dejarlo todo a tu gusto. Por defecto el desplazamiento del trackpad estaba invertido y el click táctil no funcionaba.

La solución la encontré rápidamente en este blog. También hay bastantes referencias en el manual de arch Linux.

Programas a instalar:

Gestor de ventanas: i3-gaps.
Barra de información: polybar.
Cambiar fondo: feh.
Gestión de opacidad: picom.
Lanzador de aplicaciones: rofi.
Gestor de archivos: ranger.
Editor: neovim.
Gestor de notas: emacs.
Terminal: kitty.
Nube personal: nextcloud
Mensajería: telegram.

Ahora a la parte divertida! A configurar todas las aplicaciones!

Docker-compse en crontab.

2021-01-20T00:00:00+01:00

Este blog funciona gracias a Pelican, un generador de páginas web, y se reconstruye cada 30 minutos gracias a Docker (docker-compose) y crontab.

En mi caso el docker-compose levanta un Dockerfile de python que regenera el blog.

Para reconstruir el blog cada 30 min. deberemos añadir lo siguiente a crontab. Editamos crontab con:

crontab -e

Para reconstruir el blog cada 30 min añadimos la siguiente linea a crontab:

*/30 * * * * $(which docker-compose) -f $PATH_DOCKER_COMPOSE_YAML_FILE up -d

Donde “$PATH_DOCKER_COMPOSE_YAML_FILE” es la ruta absoluta donde se encuentra el archivo docker-compose.yaml. Importante que sea la ruta absoluta no la relativa.

No sé si es necesario, pero reiniciamos crontab con el siguiente comando:

sudo service cron reload

Nextcloud desde el terminal

2020-05-25T00:00:00+02:00

NextCloud en el Terminal.

Debido al uso que le doy a Linux (cacharrear), necesito un cliente que pueda quedar configurado en el primer arranque del sistema o utilizando dotfiles (dotdrop).

Veo dos alternativas:

Nextcloudcmd
RClone: Sincronizar con webdav.

Cambios en la configuración de Regolith.

2020-05-21T00:00:00+02:00

i3 Config.

Para guardar la configuración a nivel de usuario, es recomendable seguir los pasos que indican en su documentación.

Una vez copiado el archivo en el directorio de usuario ya podemos realizar las modificaciones que queramos.

Focused window.

Lo primero que quería personalizar es la indicación de la pantalla activa, tal y como también comentan es su github, no se aprecia mucho el cambio de una ventana a otra.

La solución la encontré en el mismo hilo un poco más abajo.

Otra opción es jugar con la opacidad de las ventanas inactivas y la aplicación compon. Visto en Reddit

Config ST (terminal)

En el github de Regolith encontraremos información para personalizar ST.

En principio el archivo de configuración debería encontrarse en el siguiente directorio.

! -- Applications
! These files map values defined above into specific app settings.
#include "/etc/regolith/styles/st-term"

Aquí dejo una configuración de ST de ejemplo, sacada del usuario de github ctjhoa, y otro ejemplo de la configuración oficial del ArchWiki.w

Configuraciones de emacs

2020-02-26T00:00:00+01:00

Emacs:

Emacs es un editor de texto. No seré yo quien describa su funcionamiento y sus bondades. Pero aseguro que es muy rápido, muy eficiente, y extremadamente adaptable.

Diferentes configuraciones de Emacs.

Algunos ejemplos de configuraciones son las siguientes:

En castellano:

Notxor.
UGeek
Sackra
Lázaro y su configuración de emacs.

En inglés:

Para buscar otros ejemplos de configuraciones podemos buscarlos en GitHub. Para buscar muchas configuraciones de Emacs, podemos buscar en google: site:github.com emacs.d

Doom emacs.

Después de mucho tiempo con Emacs, he decidido probar doom emacs.

Doom Emacs tiene una forma de configuración diferente respecto a emacs, y diferentes atajos de teclado.

Más adelante iré añadiendo configuración y problemas que me he ido encontrando.