### <a id=OperacionesAritPythonTag></a> Operaciones aritméticas con Python desde la terminal
Se asigna a `x` el resultado de la operación aritmética del ejemplo y luego se imprime `x` con 3 decimales, en este caso especificados con `format`, que es un formateo de la versión 3 de Python:
Si ya se tiene una carpeta con contenido también se puede inicializar para darle seguimiento desde Git.
2. Inicializar creando el repositorio local
```
$ git init
```
3. Crear el archivo para colocar los nombres de archivos que no llevarán seguimiento en Git. Esto es importante porque puede haber archivos locales que por cierta conveniencia no deben ir en el repositorio, en especial si se planea ponerlo en un repositorio remoto.
```
$ touch .gitignore
```
En este archivo se colocan los nombres junto con las carpetas que los contienen. Por ejemplo, si dentro de la carpeta `nombreProyecto` existe una de nombre `bin` y dentro de ésta un archivo de nombre `a.out` que no llevará seguimiento en Git, el nombre de archivo que se agrega en `.gitignore` es:
```
bin/a.out
```
NOTA: Las carpetas vacías no llevan seguimiento de Git por defecto. Si se quiere mantenerlas se les agrega al menos un archivo vacío.
Una de las ventajas de trabajar con Git es la posibilidad de colocar repositorios en una nube y poder acceder a ésta desde cualquier lugar. Para ello es necesario establecer un canal de comunicación entre la versión del repositorio en forma local y la versión de la nube para que se puedan actualizar a través de comandos. Esto se hace mediante el protocolo SSH (Secure SHell de FreeBSD) y se automatiza con el uso de un par de llaves RSA, privada y pública, para que la comunicación sea directa sin necesidad de estar poniendo passwords. Estas llaves sirven para cualquier comunicación mediante SSH, aquí se describe su uso para comunicar el repo local con el repo ubicado en la nube de GitLab y los pasos son los siguientes:
1. La generación del par de llaves RSA se logra con el siguiente comando:
```
$ ssh-keygen -t rsa
```
2. Ambas llaves se guardan en el directorio `$HOME/.ssh`, una es pública y la otra privada y se pueden identificar por el nombre de archivo. Por defecto tienen los nombres `id_rsa` e `id_rsa.pub`, aunque se le puede cambiar (manteniendo la extensión `.pub` a la que le corresponde) para identificar a qué computadora pertenecen esas llaves. La llave privada no debe compartirse con nadie o mandarla a otras computadoras. La llave pública es la que se comparte, y en este caso es la que se va a usar para establecer el vínculo SSH entre la computadora local y GitLab. Copiar el contenido de la llave pública visualizando su contenido de la siguiente manera, seleccionándolo y copiándolo.
```
$ cat id_rsa.pub
```
2. Si ya se tiene cuenta en GitLab se abre la página y se ingresa a ella. Arriba a la derecha (al momento de escribir esta parte, abril de 2023) se encuentra la foto de perfil de usuario. Hacer clic allí, desplegar el menú y seleccionar `Preferences`. En la columna de la izquierda seleccionar `SSH Keys`. Pegar allí el contenido de la llave `id_rsa.pub` y rellenar los demás campos como se decida. En `Title` se pone el nombre de la computadora a la que pertenece la llave, en `Usage type` puede quedar como `Authentication & Signing` y en `Expiration date` se puede seleccionar una fecha. Se da clic en `Add key`.
3. Completado lo anterior se puede ingresar a GitLab desde la terminal mediante SSH.
Aun cuando se puede crear un repositorio en GitLab y modificar contenido desde allí, lo normal es que el proyecto se desarrolle de forma local y se suban los cambios al repositorio en GitLab, que es lo que se describe a continuación.
1. Se ingresa a la página principal de la cuenta propia en GitLab. Es conveniente crear diferentes grupos, dentro de los cuales se alojen los proyectos. Ingresar al menú desde la parte de arriba y a la izquierda y seleccionar Grupos o Proyectos, dependiendo de lo que se vaya a hacer, en este caso, Proyectos. Seleccionar `New project` arriba a la derecha en la ventana principal.
2. Seleccionar `Create blank project` y enseguida se rellenan los campos. Notar que aquí hay opción de definir si el proyecto va a ser público o privado. Se puede optar por que se genere o no un archivo `README`. Enseguida se crea el proyecto.
3. Enseguida copiar el enlace de acceso al proyecto en el botón `Clone` ubicado a la derecha. Copiar la liga de la opción `Clone with SSH`.
4. Ingresar desde la terminal en la computadora local al proyecto que se ha creado y pegar allí el contenido del portapapeles como se muestra en el siguiente comando:
`tmux` es un programa de terminal para gestionar varias terminales.
Los siguientes comandos son para configurar `tmux` y los necesarios para sobrevivir con el programa. Primero se incluyen los esenciales y quizá se vayan incorporando algunos de menor frecuencia de uso.
1. Para introducir comandos se utiliza la combinación
`Ctrl+a <comando>`
la cual también se denota en los apuntes como
`C-a <comando>`.
Equivale a presionar la combinación de teclas `C-a`, soltar y enseguida la tecla del comando.
Por defecto es `C-b`, pero se puede mapear a `C-a` por ser más práctico. Ver abajo en el archivo de configuración para saber cómo hacerlo.
2. El comando `:` es para ingresar a la línea de comandos de `tmux`
3. Desde línea de comandos `C-a` es igual al comando `tmux` en la terminal, es decir
 En donde 118.11 px/cm = 300 dpi. Para PNG es posible que se tengan que usar unidades de px/cm para que funcione, dependiendo de la versión de ImageMagick.
 Si acepta directamente las unidades en pulgadas el comando es el siguiente.
Redimensionar una imagen a tamaño carta y especificar resolución a 300 dpi.
```
$ convert entrada.png \
-resize 2550x3300 \
-density 118.11x118.11 \
-units pixelspercentimeter \
salida.png
```
Colocar una imagen en un lienzo tamaño carta a 300 dpi. La imagen se redimensiona a un tamaño dado por `-resize` de manera que queda lo más grande posible en ese espacio sin deformarse. La resolución de la imagen está dada por `-density`. Agrega un fondo blanco mediante `-background` y coloca la imagen en un espacio tamaño carta definido por `-extent`.
```
$ convert entrada.png \
-resize 2550x3300 \
-density 118.11x118.11 \
-units pixelspercentimeter \
-background white \
-gravity center \
-extent 2550x3300 \
salida.png
```
Ajuste de niveles
```
$ convert entrada.png -level 5%,80% salida.png
```
Los niveles se usan también para intercambiar color. Cambia el White,Black por el par de colores dados por `colorA,colorB` en donde si se deja en blanco, como el primer valor del ejemplo, ese color se mantiene inalterado.
## <a id=OptimizacionPdfTag></a> Optimización de archivos PDF
### <a id=OptimizarPdfGSATag></a> Mediante la aplicación `ps2pdf` de Ghostscript
```
$ ps2pdf entrada.pdf salida.pdf
```
### <a id=OptimizarPdfGSATag></a> Mediante script explícito de Ghostscript
1. Se crea un script de bash con un nombre apropiado como `optimizarPdf.sh` que tenga el siguiente contenido:
```
#!/usr/bin/bash
# Para optimizar el pdf de nombre "archivo.pdf" se corre como:
#
# ./optimizarPdf.sh archivo 300
#
# en donde 300 es la resolución que también puede ser de 150 y 72
archivo=$1
res=$2
echo "Se seleccionó $res dpi"
archIn=$archivo.pdf
archOut=$archivo-${res}dpi.pdf
case $res in
300)
resTipo='/printer' # o usar /prepress
;;
150)
resTipo='/ebook'
;;
72)
resTipo='/screen'
;;
*)
echo "Resolucion no valida. Puede ser 300, 150 o 72"
exit 0
;;
esac
gs \
-sDEVICE=pdfwrite \
-dMaxSubsetPct=100 \
-dPDFSETTINGS=$resTipo \
-sOutputFile="$archOut" \
-dNOPAUSE \
-dBATCH \
-dAutoFilterColorImages=false \
-dColorImageFilter=/FlateEncode \
-dAutoFilterGrayImages=false \
-dGrayImageFilter=/FlateEncode \
-dMonoImageFilter=/FlateEncode \
"$archIn"
exit 0
```
2. Se le cambian los permisos para que pueda ser ejecutable y se mueve a un directorio que sea reconocido por el `$PATH`, por ejemplo, `/home/$USER/bin`.
```
$ chmod +x optimizarPdf.sh
$ mv optimizarPdf.sh /home/$USER/bin
```
3. El script optimiza las imágenes dentro del PDF para que queden a 72 dpi, 150 dpi o 300 dpi. Entonces, para optimizar un archivo PDF de nombre `archivo.pdf` a 300 dpi el script se ejecuta como:
```
$ optimizarPdf.sh archivo 300
```
en donde el nombre del archivo se indica sin la extensión. Los posibles valores de resolución en dpi son los indicados.
## <a id=CambiarRgbCmykTag></a> Cambiar un PDF de RGB a CMYK
1. Se crea un script de bash con un nombre apropiado como `pdfRgb2Cmyk.sh` que tenga el siguiente contenido:
```
#!/usr/bin/bash
# Para cambiar el pdf de nombre "archivo.pdf" de RGB a CMYK se corre como:
#
# ./pdfRgb2Cmyk.sh archivo
archivo=$1
archIn=$archivo.pdf
archOut=$archivo-cmyk.pdf
gs \
-sDEVICE=pdfwrite \
-dNOPAUSE \
-dNOCACHE \
-dBATCH \
-dSAFER \
-dAutoRotatePages=/None \
-sColorConversionStrategy=CMYK \
-dProcessColorModel=/DeviceCMYK \
-sOutputFile="$archOut" \
"$archIn"
exit 0
```
2. Se le cambian los permisos para que pueda ser ejecutable y se mueve a un directorio que sea reconocido por el `$PATH`, por ejemplo, `/home/$USER/bin`.
```
$ chmod +x pdfRgb2Cmyk.sh
$ mv pdfRgb2Cmyk.sh /home/$USER/bin
```
3. El script cambia a CMYK las imágenes de un archivo PDF que estén en RGB y se ejecuta como:
```
$ pdfRgb2Cmyk.sh archivo
```
en donde el nombre del archivo se indica sin la extensión.
## <a id=ConvertirACurvasTag></a> Convertir a curvas los textos contenidos en un archivo SVG
1. Se crea un script de bash con un nombre apropiado como `inkCurva.sh` que tenga el siguiente contenido:
```
#!/usr/bin/bash
# Para ejecutar
#
# $ inkCurva.sh archivo
#
# en donde 'archivo' es el archivo.svg. El resultado tiene por nombre archivocurvas.svg
2. Se le cambian los permisos para que pueda ser ejecutable y se mueve a un directorio que sea reconocido por el `$PATH`, por ejemplo, `/home/$USER/bin`.
```
$ chmod +x inkCurva.sh
$ mv inkCurva.sh /home/$USER/bin
```
3. El script convierte a curvas todos los textos contenidos en `archivo.svg` de Inkscape y se ejecuta como:
```
$ inkCurva.sh archivo
```
en donde el nombre del archivo se indica sin la extensión.
## <a id=CambiaTamanhoResImagenTag></a> Cambiar el tamaño y la resolución de una imagen
Supóngase que se tiene una imagen a la cual se le quiere cambiar su tamaño de manera proporcional, sea a una altura o una anchura y una resolución deseadas. Para esa tarea se puede utilizar el script [`tamanhoImagen.py`](https://git.cuates.net/braquistos/CosasCLI/src/branch/master/tamanhoImagen.py) incluido en este repositorio y su uso es de la siguiente forma:
```
$ ./tamanhoImagen.py nombreImagen.png H 12 300
```
en donde se va a modificar el archivo de imagen `nombreImagen.png`. La `H` significa que se va a especificar su altura, la cual es de `12` centímetros a una resolución de `300` dpi. La otra opción es indicarle que se especificará su anchura con `W` en vez de `H`. Tanto como la altura, como la anchura se han de dar en centímetros y la resolución se especifica considerando las unidades dpi.
Como resultado se generará un archivo de nombre `nombreImagen-modificada.png` y se desplegara información de la imagen original y de la de salida. Es importante notar que si el porcentaje indicado al final es mayor al 110 %, entonces es posible que la imagen comience a verse pixeleada, por lo que es recomendable partir de una imagen original de mejor calidad. Por el momento sólo soporta imágenes PNG y JPEG que son de las más comunes, aunque manchándose un poco las manos en el teclado se puede hacer la modificación en los dos condicionales del script y las pruebas pertinentes para que soporte más formatos. Es quizá obvio, pero necesario, decir que se requiere tener instalado ImageMagick y Python 3 para que funcione.
Este script, con los permisos de ejecución adecuados, puede colocarse en una ruta reconocida por la variable $PATH, por ejemplo, `/home/$USER/bin` y ser accesible desde cualquier directorio. Siendo así, se puede incorporar en scripts de bash para hacer redimensionamiento masivo de imágenes. Supongamos que estamos dentro de una carpeta y se requiere que todas las imágenes PNG contenidas allí midan 9 cm de ancho y estén a 200 dpi. El script de bash podría llamarse `cambiarTamagno.sh` e iría de la siguiente forma:
```
#!/usr/bin/bash
lado=W # Se indica que va a ser la anchura
longitud=9
resolucion=200
for i in `ls -1 *.png`
do
tamanhoImagen.py $i $lado $longitud $resolucion
done
exit 0
```
Para ejecutarlo una vez ajustados los permisos para que sea ejecutable puede ser:
```
$ ./cambiarTamagno.sh >& salida.out &
```
en donde el archivo `salida.out` contendrá toda la información de las imágenes originales y generadas.
## <a id=ModificacionMP3Tag></a> Modificación de etiquetas y metadatos de MP3
El programa para modificar etiquetas y metadatos de un archivo mp3 es `eyeD3` y se instala en Debian como:
```
# apt install eyed3
```
Para ver lo que trae el archivo:
```
$ eyeD3 "archivo.mp3"
```
Para borrarle todo (antes de agregar los nuevos metadatos)
```
$ eyeD3 --remove-all "archivo.mp3"
```
Contenido de un script en Bash para introducir etiquetas y metadatos a un archivo mp3.
```
# 01
eyeD3 --to-v2.4 \
--artist "Nombre del artista" \
--album "Nombre del Álbum" \
--title "Nombre de la rola" \
--track 1 \ # Número de rola en el Álbum
--release-year 2018 \
--add-image nombreImagen.jpg:FRONT_COVER \
--rename '$track:num - $title' \
"nombre de archivo previo.mp3"
```
El script modifica los metadatos del archivo `nombre de archivo previo.mp3`, introduce datos básicos como Artista, Álbum, Rola, número de rola en el álbum, el año en que se dio a conocer y le agrega una imagen de portada del álbum de nombre `nombreImagen.jpg`. Renombra el archivo al estilo `00 - Título.mp3` en donde 00 es el número de rola.
Para modificar varios archivos de un álbum dado se modifica el script en cuanto a las etiquetas `--artist`, `--album`, `--release-year`, `--add-image` se repite el bloque tanntas veces como haya rolas en el álbum y se ajustan de forma manual los datos particulares de cada rola.
La información introducida es la que se visualiza en cualquier reproductor de música en mp3.
Grace (`xmgrace`) es un programa para realizar gráficas 2D para sistemas tipo Unix como Linux y que utiliza X Windows System para el despliegue gráfico.
De forma predeterminada el lienzo de la gráfica visualizada es de mayor tamaño que la ventana de visualización, lo que hace necesario estar haciendo un poco más grande esa ventana para lograr ver el gráfico cada vez que se genera, situación que puede ser tediosa. En esta parte se detallan los pasos a seguir para modificar por defecto el tamaño de esa ventana.
1. Si no existe, crear en HOME el archivo .Xdefaults (checar que es oculto)
```
$ touch $HOME/.Xdefaults
```
2. Abrir el archivo (con VIM, por ejemplo) y poner la siguiente línea y ajustar los valores si es necesario.
`vim-instant-markdown` es un plugin que permite utilizar `vim` para editar textos con `markdown` visualizando la salida en un navegador en tiempo real.
La referencia principal es la siguiente: https://github.com/instant-markdown/vim-instant-markdown
Una forma de instalar el plugin en Debian se describe en los siguientes pasos:
1. Instalar javascript si no se tiene:
```
# apt install nodejs npm xdg-utils
```
2. Instalar el plugin
```
# npm -g install instant-markdown-d
```
3. Si no se tiene manejador de plugins en `vim` una posibilidad es instalar [`vim-plug`](https://github.com/junegunn/vim-plug) llevando a cabo los siguientes pasos:
* Ejecutar el siguiente comando que crea el directorio `~/.vim/autoload/` y descarga allí el script `plug.vim`.
* Agregar las siguientes líneas al `.vimrc` en las que se incluye la llamada al plugin `vim-instant-markdown`, que es el que se quiere instalar. Desde luego dentro del entorno se pueden incluir otros plugins.
4. Para la configuración de `vim-instant-markdown` se agregan las siguientes líneas al archivo `.vimrc`. Por defecto están todas comentadas a excepción de la única necesaria. Descomentar las que se requieran para activar funcionalidades.
