Comandos Git para Data Science

Versionamento, controle de códigos e desenvolvimento paralelo.

Controle de versionamento

O Git é uma ferramenta de colaboração e controle de versão distribuída de código aberto para desenvolvedores. À medida que as operações de ciência de dados, engenharia de dados e aprendizado de máquina se tornam mais complexas, o git vem se tornando uma das ferramentas mais integrais e indispensáveis ​​para os profissionais dessas áreas, útil para controle de versão de código e dados.

O git não apenas permite que você e outros membros da equipe trabalhem na mesma base de código e tenham alterações integradas perfeitamente, como também facilita o rastreamento de alterações no código ao longo do tempo. Além de fornecer um mecanismo para testar ideias de desenvolvimento em ramificações de desenvolvimento separadas, cujos resultados podem ser integrados ao projeto principal se e quando desejado.

Para iniciar na utilização do git vamos criar um repositório no github e simular algumas operações importantes.

Repo GitHub

Instalando Git

A primeira tarefa é verificar se temos a instalação do git em nossa máquina. Para isso, caso seja usuário Windows basta ir até o terminal e digitar:

git --version

Caso não apareça uma mensagem contendo a versão do git (git version 2.34.0.windows.1), deve-se proceder para a instalação do mesmo: através deste link. Com o link também é possível realizar a instalação para outro sistema operacional.

No primeiro acesso é necessário informar as informações do usuário para conecção com o repositório remoto. Vamos utilizar o GitHub, para isso é necessário a criação de uma conta através deste link.

Trabalhando com repositórios Git

Inicialmente temos duas opções: criar um novo repositório ou clonar um repositório já existente. Para a primeira opção de criar um novo repositório devemos utilizar o comando:

git init <dir>

Com ele a configuração inicial é realizada. O parêmetro <dir> é o local onde a configuração será inicializada, não é obrigatorio o seu uso, podemos criar uma nova pasta e entrar nela com o terminal/git bash e então executar o comando.

Caso a opção seja clonar um repositório já existente, o comando a ser utilizado é:

git clone <repo>

Com ele o projeto é carregado. O parâmetro <repo> é utilizado para clonar um repositório remoto localizado em um servidor remoto usando uma URL via HTTP ou SSH.

Para o nosso caso, vamos criar uma pasta com nome estudo_git e entrar nela (cd estudo_git), em seguida vamos executar a configuração inicial do git (git init).

Adicionando arquivos

Com a pasta criada e o repositório inicializado vamos criar um arquivo, adicioná-lo ao git e envia-lo para o repositório remoto do GitHub.

O nome do arquivo será: README.md e inicialmente podemos escrever qualquer informação, com por exemplo: Tutorial do Git com GitHub. Recomendo a utilização da IDE Visual Studio Code por ser uma plataforma com muitas ferramentas que auxiliam o desenvolvimento.

Com o arquivo modificado é então possível iniciar o processo para o controle de versão que basicamente constitui de duas etapas: a primeira é adicionar as modificações para área de staging, que é um recurso muito útil para que você tenha mais controle de quais alterações quer commitar por vez, permitindo commits menores sem muito esforço extra para isto. E a segunda etapa é o commit que é usado para criar um instantâneo das alterações preparadas em um cronograma de um histórico de projetos do Git, ou seja, armazenamento das modificações feitas.

Para realiza o staging ou add das modificações devemos utilizar o comando:

git add <nome_arquivo>

Nele temos a opção de enviar apenas um arquivo para staging ou para enviar todos basta adicionar um . no lugar do nome do arquivo.

Um comando útil para verificar o staging é:

git status

Com ele é possível visualizar as mudanças adicionadas em staging e confirmar se está tudo certo para o commit.

Com as modificações em staging, estamos preparados para armazená-las através do comando:

git commit -m "descricao do commit"

Dessa forma, as modificações são armazenadas e uma mensagem é adicionada a título de informação. Caso realize novamente o git status será informado que não ha nada para ser commitado.

Resumo:

Resumo

Navegando em branch

Em geral, um branch de desenvolvimento é uma bifurcação do estado do código que cria um novo caminho para a evolução do mesmo.

Ele pode estar em paralelo com outras Git Branches que você pode gerar. É possível incorporar novas funcionalidades para o código de um jeito ordenado e preciso.

Usar Git Branches tem várias vantagens. Entretanto, as duas seguintes são as mais importantes:

• É possível desenvolver novos recursos para as aplicações sem impedir o desenvolvimento no branch principal.
• Com Git branches, é possível criar diferentes branches de desenvolvimento que podem convergir no mesmo repositório. Por exemplo, um branch estável, um branch teste e um branch instável.

Claro, cada desenvolvedor pode estabelecer seus próprios métodos com suas próprias vantagens usando suas experiências como um guia.

Os usos dos branches do Git são inicialmente simples, como você irá verificar nos comandos do Git branch.

Mas, como na maioria das coisas, quanto mais ramificações tiver, mais difícil será para gerenciar.

Em qualquer projeto Git, podemos visualizar todos os branches digitando o seguinte comando:

git branch

Se nenhum branch tiver sido criado, o terminal não vai mostrar nenhuma informação. Não se preocupe, criar um branch é realmente simples:

git branch [new_branch]

Então, precisamos mover para o recém-criado branch de desenvolvimento. para fazer isso, vamos executar o seguinte comando:

git checkout [new_branch]

A saída vai informar que trocamos para um novo branch. Chamaremos isso de “teste”, então:

Switched to branch "teste"

Agora, no novo branch de desenvolvimento, podemos criar quantas modificações no código quisermos sem ter que mudar nada na versão principal.

Como podemos ver, isso mantém o programa organizado para novas inclusões de código.

Se rodarmos o comando para listar novamente as ramificações, veremos que um novo branch foi adicionado e que estamos localizados nele.

git branch

Existe algo que precisamos manter em mente, se quisermos fazer um novo branch de desenvolvimento:

Primeiro, precisamos fazer o commit para o branch principal para o Git entender qual é o branch master (principal).

Se não fizermos isso, nós iremos ter um erro. Então, primeiro, faça o commit e então crie os branches de desenvolvimento.

Se quisermos remover um branch do Git, podemos fazer isso com o seguinte comando:

git branch -d [nome_branch]

Entretanto, para fazer isso, não devemos estar localizados no branch que queremos remover. Nesse caso, vamos ao branch principal e dele deletamos o branch que criamos:

git checkout main

git branch -d teste

Finalmente, chegamos a um ponto onde fizemos muitas modificações em um branch de desenvolvimento. E isso se torna estável, logo, queremos vinculá-lo com outro branch de desenvolvimento. Para isso, existe o comando merge.

Primeiro, localize o branch de desenvolvimento para qual o segundo branch deve ser anexado. Por exemplo, iremos anexar o branch teste no branch principal. Então, temos que nos situar no branch principal e juntá-los com o comando:

git merge [branch]

Como você pode ver, as funções básicas do Git branch são bem fáceis. Você apenas precisa saber do básico e tentar manter seu gerenciamento simples.

Resumo:

Resumo

Repositório remoto (GitHub)

Para colaborar com qualquer projeto Git, você precisará saber como gerenciar seus repositórios remotos. Repositórios remotos são versões de seu repositório hospedado na Internet ou em uma rede qualquer.

Aqui vamos utilizar o GitHub e nele vamos criar um novo projeto:

Criando um novo repositório no GitHub

Agora é so adicionar o repositório remoto ao projeto local, para isso basta utilizar o comando:

git remote add origin <URL do repositório remoto>

Onde o remote indica a criação de uma conexão entre o nosso repositório local e o remoto, add para adicionar, origin que é o apelido da referência do repositório remoto do GitHub, ou seja, git faça uma nova conexão do nosso repositório local com o repositório remoto que demos o nome de origin.

Ainda nenhum arquivo foi enviado para o repositório remoto, para enviar os dados podemos utilizar o comando:

git push -u origin main

Nele estamos empurrando push a branche main para o repositório remoto origin. O parâmetro -u só é necessário a primeira vez que o push é feito, ele informa que para cada branch que está atualizado ou que foi enviado com êxito, deve adicionar a referência de upstream (rastreamento).

Resumo:

Resumo

Modificações paralelas

Imagine que existam mais pessoas implementando com você e uma modificação foi feita em uma branch chamada de teste2 você foi requisitado para validar a implementação e realizar o merge.

Para isso a pessoa que fez a modificação deve fazer um pull request, que permite informar outras pessoas sobre as alterações feitas por push em uma ramificação de um repositório no GitHub. Após a abertura de uma solicitação de pull, é possível discutir e revisar as possíveis alterações com colaboradores e adicionar confirmações de acompanhamento antes que as alterações sejam mescladas na ramificação base (main).

Vamos utilizar o mesmo repositório e fazer um pull request para ele mesmo pelo GitHub. Isso normalmente é feito em outros repositórios com a intenção de apresentar as possíveis modificações.

Pull request

Em seguida é aberto uma página de requisição de abertura, nela devemos inserir um commit e uma descrição da modificação:

Requisição de abertura do pull request

Agora temos um pull request e para ver as solicitações, podemos ir até a aba: Pull requests em nosso repositório.

Para verificar e validar as modificações basta acessar a nova branch teste2 . Por fim se for conveniente realizar o merge com as novas funcionalidades ou fechar a solicitação indicando os motivos.

Aprovando ou fechando o pull request

Com isso temos então finalizado todas as etapas de um pull request. O codigo do GitHub utilizado esta nesse link.