Forem: Ivan Shcheklein

🤖 Learning GitHub Actions: Creating Beautiful PR Comments

Ivan Shcheklein — Tue, 11 Aug 2020 02:14:18 +0000

You've probably seen the services that automatically generate GitHub PR comments with tables, images, links? Something like these two:

🔎 Codecov report	🔎 Calibre report

Codecov and Calibre reports

Magic, right ✨? Let's see how it can be done. We won't even need to use command line or offline editors this time!. This post covers:

How to create a "Hello world!" GitHub action online
Use CML scripts to generate comments with a custom Markdown that includes a picture 🖼.

Read more about CML. Besides GitHub comments, it can do the same for GitLab. Also, it's important that it was built with Machine Learning workflow in mind and automates a lot of tedious tasks in ML. besides simple reports.

Step 1: Create Action File

You can do this using GitHub online UI! Add the file .github/workflows/cml.yaml to your repo like this:

Btw, I've forked the DVC example get started repo to play with actions in this tutorial - feel free to do the same 😊

Step 2: Add "Hello world!" Action

Feel free to copy-paste it from this gist:

Step 3: Add Images 🖼️

That's where the the magic ✨ happens! Let's update a few lines of code like this (copy-paste from this gist):

cml-publish prc.svg --md >> report.md
cml-send-comment report.md

That's pretty all you need if you use the CML docker to run the action!

We specifically don't focus on the other three lines of the action, those that generate the image. It's out of scope of this post and it's specific to the repository. We definitely recommend reading it and DVC docs if you are machine learning practitioner.

cml-publish - saves an image and creates an ![Image](link) entry in the Markdown file report.md

cml-send-comment - sends the comment to GitHub to get the result 👇

Step 4: Profit 💥

The result looks like this:

In this case it includes a precision-recall curve which is a fundamental and useful characteristic for a binary classifier. But you can include any images, any text using Markdown markup to create your own unique and useful report!

That's it for today 👌

We've just barely scratched the surface of the GitHub actions and CML capabilities! We definitely recommend taking a look at the actions marketplace.

And of course, read more about CML. Besides GitHub comments, it can do the same for GitLab. It was built with Machine Learning workflow in mind and automates a lot of tedious tasks in ML - like running training remotely.

✨ Shtab: Provide Autocomplete for your Python App

Ivan Shcheklein — Tue, 28 Jul 2020 01:23:44 +0000

I believe most folks have written a bash or Python app/tool that runs from the terminal command line to do some useful stuff. These programs usually accept some parameters and options. And it's really cool when you can press the TAB key and get the list of options the command expects:

$ git ch<TAB>
...
checkout         -- checkout branch or paths to working tree
checkout-index   -- copy files from index to working directory

🦾 It seems to be a minor thing but it boosts your productivity significantly! Enough for a search query productivity terminal autocomplete to generate almost a million results.

So, how can you do the same magic for your Python app?

The simplest answer is Shtab - a Python library that can analyze your code and generate necessary files for bash or zsh shell to give your tools the same powerful functionality💥 .

This tool was created by Casper to automate the maintenance of the DVC project:

😱 Every time a new feature is added, maintainers and contributors have to update tab completion scripts for multiple supported shells. At best, it's a pain, and at worst, error-prone.

Okay, enough talk, let's see it in action 🎥.

For Python CLI application using argparse, docopt, or argopt simply hand your parser object to shtab (either via the CLI or the Python API), and a tab completion script will be generated for your preferred shell. It's as easy as:

$ shtab --shell=bash myprogram.main.parser

or in Python:

import shtab
print(shtab.complete(parser, shell="bash"))

That's how Git for Data's in terminal looks like when completion is installed:

% dvc <TAB>
Completing dvc commands
add         -- Track data files or directories with DVC.
cache       -- Manage cache settings.
checkout    -- Checkout data files from cache.
commit      -- Save changed data to cache and update DVC-files.
completion  -- Prints out shell tab completion scripts.
At Top: Hit TAB for more, or the character to insert

I hope you'll find it useful and this lib will save you some time! As usual, give the project a ⭐️ to thank the author and welcome to the issue tracker or comments 👇 if you have any questions.

How to version large files with Git

Ivan Shcheklein — Sun, 19 Jul 2020 15:49:40 +0000

It's not a secret, Git doesn't handle large files well:

Indeed. The git architecture simply sucks for big objects. It was discussed somewhat during the early stages, but a lot of it really is pretty fundamental. (Linus Torvalds)

In this short post I'd like to:

See what tools are available there to handle large files with Git
Try one of those - DVC

Have you ever committed a few 100 MBs file to then realize it's part of the repo now and it would take quite an effort to carve it out and fix the repo:

Git clone takes hours, regular operations might take minutes instead of seconds - not the best idea indeed. And still, there are a lot of cases where we want to have a large file versioned in our repo - from game development to data science where we want to handle large datasets, videos, etc.

So, let's see what open-source and Git-compatible options do we have to deal with this:

Git-LFS - Github and Gitlab both support it and can store large files on their servers for you, with some limits
Git-annex - pretty powerful and sophisticated tool, but it makes it hard to learn and manage to my mind
DVC - Git for Data or Data Version Control - a tool made for ML and data projects, but on its fundamental level helps versioning large files

You can read (a somewhat outdated) overview of LFS and annex tools here, but this time I want to show you how the workflow looks like with DVC (yes! I'm one of the maintainers).

After DVC is installed all we need to do is to run dvc add and set a storage you'd like to use to store your large files.

Let's try it right here and there, first we need a dummy repo:

$ mkdir example
$ cd example
$ git init
$ dvc init
$ git commit -m "initialize"

Second, generate a large file:

$ head -c1000000 /dev/urandom > large-file 
# Windows: fsutil file large-file test.txt 1048576

The workflow is similar to Git, but instead of git add and git push we run dvc add and dvc push when we want to save a large file:

$ dvc add large-file

Now, let's save it somewhere (we use Google Drive here, but it can be AWS S3, Google Cloud, local directory, and many other storage options):

$ dvc remote add -d mystorage gdrive://root/Storage
$ dvc push

You'd need to create the Storage directory in your Google Drive UI first and dvc push will ask you to give it access to your storage. It is absolutely safe! - credentials are saved on your local machine in the .dvc/tmp/gdrive-user-credentials.json, no access given outside.

Now, we can do git commit to save DVC files instead of a large file itself (you can run dvc status to see that large-file is not handled and visible by Git anymore):

$ git add .
$ git status

On branch master
Changes to be committed:
  (use "git restore --staged <file>..." to unstage)
    modified:   .dvc/config
    new file:   .gitignore
    new file:   large-file.dvc

$ git commit -a -m "add large file"

That's it for today, next time we'll see how did it work, what does large-file.dvc mean, why does it create .gitignore and how can we get our file back!