Experiencias del módulo Python Git? [cerrado]

¿Cuáles son las experiencias de las personas con cualquiera de los módulos Git para Python? (Sé de GitPython, PyGit y Dulwich, siéntete libre de mencionar a otros si los conoces).

Estoy escribiendo un programa que tendrá que interactuar (agregar, eliminar, confirmar) con un repositorio de Git, pero no tengo experiencia con Git, por lo que una de las cosas que estoy buscando es la facilidad de uso / comprensión con respecto a Git.

Las otras cosas que me interesan principalmente son la madurez y la integridad de la biblioteca, la falta razonable de errores, el desarrollo continuo y la utilidad de la documentación y los desarrolladores.

Si piensa en otra cosa que tal vez quiera / necesite saber, no dude en mencionarlo.

Si bien esta pregunta se hizo hace un tiempo y no conozco el estado de las bibliotecas en ese momento, vale la pena mencionar para los buscadores que GitPython hace un buen trabajo al abstraer las herramientas de línea de comandos para que no necesite usar subproceso Hay algunas abstracciones útiles incorporadas que puedes usar, pero para todo lo demás puedes hacer cosas como:

import git
repo = git.Repo( '/home/me/repodir' )
print repo.git.status()
# checkout and track a remote branch
print repo.git.checkout( 'origin/somebranch', b='somebranch' )
# add a file
print repo.git.add( 'somefile' )
# commit
print repo.git.commit( m='my commit message' )
# now we are one commit ahead
print repo.git.status()

Todo lo demás en GitPython solo facilita la navegación. Estoy bastante satisfecho con esta biblioteca y aprecio que sea un contenedor de las herramientas git subyacentes.

ACTUALIZACIÓN : He cambiado a usar el módulo sh no solo para git sino para la mayoría de las utilidades de línea de comandos que necesito en python. Para replicar lo anterior, haría esto en su lugar:

import sh
git = sh.git.bake(_cwd='/home/me/repodir')
print git.status()
# checkout and track a remote branch
print git.checkout('-b', 'somebranch')
# add a file
print git.add('somefile')
# commit
print git.commit(m='my commit message')
# now we are one commit ahead
print git.status()

Pensé que respondería a mi propia pregunta, ya que estoy tomando un camino diferente al sugerido en las respuestas. Sin embargo, gracias a quienes respondieron.

Primero, una breve sinopsis de mis experiencias con GitPython, PyGit y Dulwich:

• GitPython : Después de descargar, importé esto y se inicializó el objeto apropiado. Sin embargo, tratar de hacer lo que se sugirió en el tutorial condujo a errores. Al carecer de más documentación, recurrí a otro lado.
• PyGit : Esto ni siquiera importaría, y no pude encontrar documentación.
• Dulwich : Parece ser el más prometedor (al menos para lo que quería y vi). Hice algunos progresos con él, más que con GitPython, ya que su huevo viene con la fuente Python. Sin embargo, después de un tiempo, decidí que podría ser más fácil probar lo que hice.

Además, StGit parece interesante, pero necesitaría la funcionalidad extraída en un módulo separado y no quiero esperar a que eso suceda en este momento.

En (mucho) menos tiempo del que pasé tratando de hacer que los tres módulos anteriores funcionen, logré que los comandos git funcionen a través del módulo de subproceso, por ejemplo

def gitAdd(fileName, repoDir):
    cmd = ['git', 'add', fileName]
    p = subprocess.Popen(cmd, cwd=repoDir)
    p.wait()

gitAdd('exampleFile.txt', '/usr/local/example_git_repo_dir')

Esto aún no está completamente incorporado a mi programa, pero no estoy anticipando un problema, excepto tal vez la velocidad (ya que a veces estaré procesando cientos o incluso miles de archivos).

Tal vez simplemente no tuve la paciencia para poner las cosas en marcha con Dulwich o GitPython. Dicho esto, espero que los módulos tengan más desarrollo y sean más útiles pronto.

Recomiendo pygit2 : utiliza los excelentes enlaces libgit2

Esta es una pregunta bastante antigua, y mientras buscaba bibliotecas de Git, encontré una que se hizo este año (2013) llamada Gittle .

Funcionó muy bien para mí (donde los otros que probé eran escamosos), y parece cubrir la mayoría de las acciones comunes.

Algunos ejemplos de README:

from gittle import Gittle

# Clone a repository
repo_path = '/tmp/gittle_bare'
repo_url = 'git://github.com/FriendCode/gittle.git'
repo = Gittle.clone(repo_url, repo_path)

# Stage multiple files
repo.stage(['other1.txt', 'other2.txt'])

# Do the commit
repo.commit(name="Samy Pesse", email="samy@friendco.de", message="This is a commit")

# Authentication with RSA private key
key_file = open('/Users/Me/keys/rsa/private_rsa')
repo.auth(pkey=key_file)

# Do push
repo.push()

Quizás ayude, pero Bazaar y Mercurial están usando dulwich para su interoperabilidad Git.

Dulwich es probablemente diferente al otro en el sentido de que es una reimplementación de git en python. El otro podría ser un envoltorio alrededor de los comandos de Git (por lo que podría ser más simple de usar desde un punto de vista de alto nivel: commit / add / delete), probablemente significa que su API está muy cerca de la línea de comandos de git, por lo que necesitará para ganar experiencia con Git.

En aras de la integridad, http://github.com/alex/pyvcs/ es una capa de abstracción para todos los dvcs. Utiliza dulwich, pero proporciona interoperabilidad con los otros dvcs.

Una respuesta actualizada que refleja los tiempos cambiados:

GitPython actualmente es el más fácil de usar. Admite la envoltura de muchos comandos de fontanería git y tiene una base de datos de objetos conectables (dulwich es uno de ellos), y si no se implementa un comando, proporciona una API fácil para desviarse a la línea de comando. Por ejemplo:

repo = Repo('.')
repo.checkout(b='new_branch')

Esto llama:

bash$ git checkout -b new_branch

Dulwich también es bueno pero de nivel mucho más bajo. Es un poco difícil de usar porque requiere operar con objetos de git a nivel de plomería y no tiene una buena porcelana que normalmente querría hacer. Sin embargo, si planea modificar alguna parte de git, o usa git-recibir-paquete y git-upload-pack, debe usar dulwich.

Aquí hay una implementación realmente rápida del "estado de git":

import os
import string
from subprocess import *

repoDir = '/Users/foo/project'

def command(x):
    return str(Popen(x.split(' '), stdout=PIPE).communicate()[0])

def rm_empty(L): return [l for l in L if (l and l!="")]

def getUntracked():
    os.chdir(repoDir)
    status = command("git status")
    if "# Untracked files:" in status:
        untf = status.split("# Untracked files:")[1][1:].split("\n")
        return rm_empty([x[2:] for x in untf if string.strip(x) != "#" and x.startswith("#\t")])
    else:
        return []

def getNew():
    os.chdir(repoDir)
    status = command("git status").split("\n")
    return [x[14:] for x in status if x.startswith("#\tnew file:   ")]

def getModified():
    os.chdir(repoDir)
    status = command("git status").split("\n")
    return [x[14:] for x in status if x.startswith("#\tmodified:   ")]

print("Untracked:")
print( getUntracked() )
print("New:")
print( getNew() )
print("Modified:")
print( getModified() )

La respuesta de PTBNL es bastante perfecta para mí. Hago un poco más para el usuario de Windows.

import time
import subprocess
def gitAdd(fileName, repoDir):
    cmd = 'git add ' + fileName
    pipe = subprocess.Popen(cmd, shell=True, cwd=repoDir,stdout = subprocess.PIPE,stderr = subprocess.PIPE )
    (out, error) = pipe.communicate()
    print out,error
    pipe.wait()
    return 

def gitCommit(commitMessage, repoDir):
    cmd = 'git commit -am "%s"'%commitMessage
    pipe = subprocess.Popen(cmd, shell=True, cwd=repoDir,stdout = subprocess.PIPE,stderr = subprocess.PIPE )
    (out, error) = pipe.communicate()
    print out,error
    pipe.wait()
    return 
def gitPush(repoDir):
    cmd = 'git push '
    pipe = subprocess.Popen(cmd, shell=True, cwd=repoDir,stdout = subprocess.PIPE,stderr = subprocess.PIPE )
    (out, error) = pipe.communicate()
    pipe.wait()
    return 

temp=time.localtime(time.time())
uploaddate= str(temp[0])+'_'+str(temp[1])+'_'+str(temp[2])+'_'+str(temp[3])+'_'+str(temp[4])

repoDir='d:\\c_Billy\\vfat\\Programming\\Projector\\billyccm' # your git repository , windows your need to use double backslash for right directory.
gitAdd('.',repoDir )
gitCommit(uploaddate, repoDir)
gitPush(repoDir)

La parte de la biblioteca de interacción git de StGit es bastante buena. Sin embargo, no se desglosa como un paquete separado, pero si hay suficiente interés, estoy seguro de que se puede solucionar.

Tiene muy buenas abstracciones para representar commits, árboles, etc., y para crear nuevos commits y árboles.

Para el registro, ninguna de las bibliotecas de Git Python mencionadas parece contener un equivalente de "estado de git", que es realmente lo único que desearía, ya que tratar con el resto de los comandos de git a través de un subproceso es tan fácil.