Guia: Automatització de versions amb Git i Python

Lucas Simon

Dilluns, 20 de maig de 2024 a les 8:59:22

Creació d'un sistema de versions amb Git i Python

Automatitzar la versió dels fitxers del vostre projecte és crucial per mantenir un flux de treball de desenvolupament organitzat i eficient. Mitjançant l'ús de Git i Python, podeu crear un sistema que actualitzi un fitxer version.py amb cada commit. Això garanteix que la versió del vostre projecte sigui sempre precisa i reflecteixi els darrers canvis fets a la vostra base de codi.

En aquesta guia, explorarem un mètode per actualitzar automàticament un fitxer version.py amb cada empenta al dipòsit de Git. Parlarem de la implementació d'un script que captura detalls de confirmació, augmenta el número de versió i s'integra perfectament amb el vostre flux de treball de Git.

Automatització de versions a Python mitjançant Git Hooks

Script de Python per a ganxo pre-push

#!/usr/bin/env /usr/bin/python
import os
import subprocess
import re
import sys

commit_msg_file = sys.argv[1]
with open(commit_msg_file, 'r') as file:
    commit_msg = file.read().strip()

version_file = os.path.abspath('version.py')
hashed_code = subprocess.check_output(['git', 'rev-parse', 'HEAD']).strip().decode('utf-8')

if os.path.exists(version_file):
    print(f'Reading previous {version_file}')
    with open(version_file, 'r') as f:
        content = f.read()
        major, minor, patch = map(int, re.search(r'version = "(\d+)\.(\d+)\.(\d+)"', content).groups())
    patch += 1
else:
    print(f'Creating new {version_file}')
    major, minor, patch = 0, 0, 1

print(f'Writing contents of {version_file} with "{commit_msg}"')
with open(version_file, 'w') as f:
    f.write(f'''# This file is created by the pre-push script
class Version:
    comment = "{commit_msg}"
    hash = "{hashed_code}"
    version = "{major}.{minor}.{patch}"

if __name__ == "__main__":
    print(Version.version)
''')

subprocess.call(['git', 'add', version_file])

Configuració de Git Hook per a l'increment de versió

Script Git Hook a Shell

#!/bin/sh

VERSION_PY="version.py"

# Get the commit message file from the arguments
COMMIT_MSG_FILE=$1

# Extract the commit message
COMMIT_MSG=$(cat $COMMIT_MSG_FILE)

# Get the latest commit hash
GIT_HASH=$(git rev-parse HEAD)

if [ -f "$VERSION_PY" ]; then
  VERSION=$(grep -oP '(?<=version = ")(\d+\.\d+\.\d+)' $VERSION_PY)
  IFS='.' read -r -a VERSION_PARTS <<< "$VERSION"
  VERSION_PARTS[2]=$((VERSION_PARTS[2] + 1))
  NEW_VERSION="${VERSION_PARTS[0]}.${VERSION_PARTS[1]}.${VERSION_PARTS[2]}"
else
  NEW_VERSION="0.0.1"
fi

echo "# This file is created by the pre-push script" > $VERSION_PY
echo "class Version:" >> $VERSION_PY
echo "    comment = \"$COMMIT_MSG\"" >> $VERSION_PY
echo "    hash = \"$GIT_HASH\"" >> $VERSION_PY
echo "    version = \"$NEW_VERSION\"" >> $VERSION_PY

git add $VERSION_PY

Millora del flux de treball de Git amb versions automatitzades

L'automatització de versions dins d'un flux de treball de Git no només garanteix la coherència sinó que també millora la traçabilitat dels projectes de programari. En integrar la gestió de versions directament als ganxos de Git, els desenvolupadors poden mantenir un procés perfecte i eficient. Un enfocament és utilitzar el ganxo pre-push de Git per actualitzar automàticament un fitxer de versió amb cada commit. Aquest mètode implica capturar missatges de confirmació i valors hash, que són essencials per fer un seguiment dels canvis i mantenir un registre històric de la base de codi.

Un altre aspecte crucial és la capacitat de revertir els canvis amb precisió. Amb un fitxer de versió actualitzat, els desenvolupadors poden identificar l'estat exacte del projecte en qualsevol versió determinada. Això és especialment útil en entorns d'integració i desplegament continus (CI/CD), on l'automatització és clau. Assegurar que el fitxer de versió s'actualitza de manera fiable amb cada commit ajuda a mantenir una canalització de desplegament sòlida, reduint els errors manuals i racionalitzant les versions.

Com puc automatitzar el control de versions al meu repositori Git?
Podeu automatitzar el control de versions utilitzant ganxos Git, com ara el ganxo pre-push, i scripts per actualitzar un fitxer de versió a cada commit.
Què és un ganxo previ?
Un ganxo pre-push és un ganxo Git que executa scripts abans que els canvis s'enviïn a un dipòsit remot. Es pot utilitzar per automatitzar tasques com ara actualitzar un fitxer de versió.
Com puc accedir al missatge de confirmació en un script Git hook?
Podeu accedir al missatge de confirmació llegint el fitxer passat com a argument a l'script, normalment utilitzant en Python o en un script de shell.
Quina ordre recupera l'últim hash de commit de Git?
La comanda recupera l'últim hash de commit en un dipòsit de Git.
Com augmento el número de versió en un script?
Utilitzeu expressions regulars per extreure la versió actual, augmentar el número de pedaç i reescriure el fitxer de versió amb el nou número de versió.
Puc utilitzar aquest mètode amb eines d'integració contínua?
Sí, l'automatització de versions amb ganxos Git es pot integrar a les canalitzacions CI/CD per garantir la coherència de la versió entre les compilacions i els desplegaments.
Quins avantatges té el control de versions automatitzat?
El control de versions automatitzat redueix els errors manuals, garanteix un seguiment coherent de versions i racionalitza el procés de desenvolupament i desplegament.
Com m'asseguro que el fitxer de versió s'inclou a la següent confirmació?
Ús per organitzar el fitxer de versió després que l'script hagi actualitzat.
Què passa si el fitxer de versió no existeix?
Si el fitxer de versió no existeix, l'script el pot crear amb un número de versió inicial, com ara 0.0.1.
És possible utilitzar altres llenguatges de programació per a ganxos Git?
Sí, podeu escriure scripts Git hook en diversos llenguatges de programació, com ara Python, Bash o Perl, depenent de les vostres preferències i els requisits del projecte.

Consideracions finals sobre versions automatitzades

Automatitzar l'actualització d'un fitxer version.py amb cada push de Git és una solució pràctica per mantenir un control de versions precís als vostres projectes. Els scripts proporcionats aprofiten els ganxos de Git i Python per automatitzar aquest procés, assegurant-se que cada commit es fa un seguiment amb un número de versió actualitzat, missatge de confirmació i hash. La implementació d'aquest mètode pot millorar molt el vostre flux de treball, fent-lo més eficient i reduint les possibilitats d'error humà. Seguint les directrius i els exemples proporcionats, podeu integrar fàcilment la versió automatitzada a les vostres pràctiques de desenvolupament.