DEV Community: Ghislain LEVEQUE

Capturing a screencast, the command-line-nerd style

Ghislain LEVEQUE — Thu, 24 Oct 2019 17:53:05 +0000

Introduction

If you don't care about "why and how", just skip to the end of the article where the script is or go grab it on github.

I'm a bit pathologic when it comes to the tools I use on a day to day basis and I often want as much control as I can have.

I work as a full stack developer and lately, with my team, we decided that we wanted to demonstrate all the features we are releasing to other teams and screencasts can be a great medium for that purpose.

Tools already exist to capture screencasts and some of them are really close to what I wanted but I'm using i3 as a window manager, with multiple screens and no floating windows. Tools like peek for example don't work really well with that configuration.

So I decided to take the dirty path and take advantage of the first unix principle: "Make each program do one thing well".

In this case here is what I expect from this rule: each brick I need to build my wall probably already exists (spoiler: of course they do).

What I need:

a tool able to capture a video from part of my screen, given coordinates
a tool to designate coordinates
a tool to build interaction upon

The tools

FFmpeg, the swiss army knife of video
xdotool, a small program allowing to manipulate windows, mouse, and keyboard in a X environment
dmenu, a dynamic menu for X

I already used xdotool and dmenu in a lot of productivity scripts, I may present more about them in other articles.

The solution

On the first launch, the script uses dmenu to guide the user in selecting the coordinates for her capture, its output is not used, it just serves for talking with the user and inserting "breakpoints" in the script
xdotool is used to grab mouse coordinates (top left corner then bottom right corner)
Using that coordinates, the width and height are calculated
ffmpeg is launched with its x11grab input to capture the desktop. It is launched has a background job and its PID is saved in a file
When launched a second time, the script detects that the PIDFILE is there, verifies if the process is still running, kills it gently and displays the captured video.

I've bound the script to a keyboard shortcut in my i3 config file so the calls to echo in the script are just for debugging.

#!/bin/bash

PIDFILE=${HOME}/.screencast_pid

if [ -f ${PIDFILE} ]; then
    PID=$(cat ${PIDFILE})
    if [ -n "$(ps -p ${PID} -o pid=)" ]; then
        echo "Screencast in progress" | dmenu
        WD=$(readlink -f /proc/${PID}/cwd)
        OUTFILE=${WD}/output.mp4
        kill ${PID}
        rm ${PIDFILE}
        vlc ${OUTFILE}
        exit 1
    else
        echo "wrong pidfile"
        rm ${PIDFILE}
    fi
fi

get_mouse_location() {
    echo "Go to $1 then press Enter." | dmenu > /dev/null
    xdotool getmouselocation
}

tlc=$(get_mouse_location "top left corner")
brc=$(get_mouse_location "bottom right corner")

top=$(echo ${tlc} | sed -e "s/.*y:\([0-9]\+\).*/\1/")
lef=$(echo ${tlc} | sed -e "s/.*x:\([0-9]\+\).*/\1/")
bot=$(echo ${brc} | sed -e "s/.*y:\([0-9]\+\).*/\1/")
rig=$(echo ${brc} | sed -e "s/.*x:\([0-9]\+\).*/\1/")

width=$(expr ${rig} - ${lef})
height=$(expr ${bot} - ${top})
echo "Do screencast ${width}x${height} from top: ${top} left: ${lef} to bottom: ${bot} right: ${rig}"

ffmpeg -v 8 -video_size ${width}x${height} -framerate 10 -y -f x11grab -i :0.0+${lef},${top} output.mp4 &
FFMPEG_PID=$!
echo ${FFMPEG_PID} > ${PIDFILE}

Ideas for enhancement

Let the user decide what to do with the video (display it, move it in a specific folder, upload it, remove it...)
Allow capturing whole screen by giving more than one choice in the calls to dmenu (and even allow cancelling)

And you, do you like crafting your own walls with existing bricks? What is in your toolbox? Also, let me know if you find this kind of post useful.

PS: You'll find the tools I'm talking about here

Dynamic attribute, thanks to magic methods.

Ghislain LEVEQUE — Fri, 26 Jul 2019 07:32:26 +0000

Scenario

In order to optimize our application, I added an annotation on my QuerySet in order to be able to filter on this dynamic property and do bulk operations without needing to iterate over all the objects in a QuerySet:

So I could replace that (simplified example):

class MyModel(models.Model):
    attr1 = models.DateTimeField()
    attr2 = models.IntegerField()

    def attr3(self):
        return self.attr1 + timedelta(days=attr2 * 3)

def my_function():
    for instance in MyModel.objects.all():
        # do some work involving attr3

By that (incomplete example):

class MyManager(models.Manager):
    def get_queryset(self):
        return self.custom_annotation(super(MyManager, self).get_queryset())

    def custom_annotation(self, qs):
        return qs.annotate(
            attr3=  # Details of annotation outside the scope of this post
        )


class MyModel(models.Model):
    attr1 = models.DateTimeField()
    attr2 = models.IntegerField()

    objects = MyManager()

def my_function():
    MyModel.objects.filter(
        attr3=...  # Details of filter outside the scope of this post
    ).update(
        # Details of operation outside the scope of this post
    )

def my_other_function():
    instance = MyModel.objects.get(pk=42)
    instance.attr3  # the instance is annotated thanks to the QuerySet annotation

Ok, fine so far but this has a flaw. When you are accessing your model directly (via a QuerySet or an instance), it is annotated. When you are accessing it via a ManyToMany, it is annotated too but not when it is used as a ForeignKey:

class MyModel2(models.Model):
    foreign = models.ForeignKey(MyModel)

def my_function():
    instance2 = MyModel2.objects.get(pk=57)
    instance2.foreign.attr3  # AttributeError

Solution

So I wanted to have MyModel act dynamically and go get the attr3 attribute when needed, at the cost of an additional SQL query if necessary.

This is possible by overriding __getattr__ like that:

class MyModel(models.Model):
    attr1 = models.DateTimeField()
    attr2 = models.IntegerField()

    objects = MyManager()

    def __getattr__(self, attrname):
        if attrname == "attr3":
            try:
                return object.__getattribute__(self, attrname)
            except AttributeError:
                value = Screen.objects.values_list("attr3", flat=True).get(pk=self.pk)
                setattr(self, attrname, value)
                return value
        return object.__getattribute__(self, attrname)

One should be careful when overriding __getattr__, you can easily fall into infinite loops.

Also, it is important to note that __getattr__ only gets called when accessing a missing attribute, whereas __getattribute__ gets called every time an attribute is accessed.

I'm using object.__getattribute__ in order to avoid recursion.