DEV Community: MoniqueLive

I love discoverability...

MoniqueLive — Fri, 05 Jun 2026 20:01:33 +0000

MoniqueLive

Jun 5

Finding man pages from Neovim with Telescope and/or mini.pick

#neovim #lua #telescope #vim

4 min read

Finding man pages from Neovim with Telescope and/or mini.pick

MoniqueLive — Fri, 05 Jun 2026 19:58:41 +0000

I use man pages all the time, but sometimes I do not know exactly what I want to open.

printf is a good example.

There is printf(1) for the shell command, printf(3) for the C library function, and depending on what is installed locally there may be even more entries around it.

I wanted something simple inside Neovim:

list local man pages
fuzzy search them
see the section before opening
open using Neovim's built-in :Man

So I made a small plugin: man.nvim.

Source:

GitHub: https://github.com/moniquelive/man.nvim

What it does

The plugin starts with the system database:

apropos .

Then it parses the output into picker items like:

[1 User commands] printf(1) - format and print data
[3 Library calls] printf(3) - formatted output conversion

The important part is that selecting an entry still delegates to Neovim:

:Man 3 printf

No custom renderer.
No terminal buffer pretending to be man.
No reimplementing man page navigation.

Just discovery through a picker, opening through :Man.

Why not just use :Man?

:Man is great once I know what I want.

But I often want to explore what is installed locally. I may remember part of the name, or the description, or the section.

With the picker I can type things like:

printf
3 printf
formatted output

And the item text includes the section label, so it is easy to see if I am about to open the command, library call, file format, etc.

Telescope version

The main branch exposes a Telescope extension.

Setup:

require('telescope').setup()
require('man_nvim').setup()

Usage:

:Telescope man

Internally it uses a table finder. Each parsed man page becomes an entry with data like:

{
  name = 'printf',
  section = '3',
  ref = 'printf(3)',
  description = 'formatted output conversion',
}

The display and ordinal use the same searchable text:

'[3 Library calls] printf(3) - formatted output conversion'

That keeps Telescope doing what Telescope is good at: prompt, sorting, preview, mappings.

mini.pick version

There is also a mini.picker branch using mini.pick.

Setup:

require('mini.pick').setup()
require('man_nvim').setup()

Usage:

:Pick man

The interesting part is that most of the plugin is shared conceptually:

parse apropos output
split aliases
sort by man section
build the :Man command
show a small preview
open the selected page

Only the picker integration changes.

Aliases

Some apropos entries have a lot of aliases.

For example, shells can produce lines like:

builtin(1), !(1), %(1), .(1), :(1), [(1) - shell built-in commands

The plugin creates searchable items for the aliases, but opens the canonical page.

So if I search for !, I can find !(1), but selecting it opens builtin(1).

That matters because some aliases are not real standalone man pages. They are documented under the first entry in that apropos line.

Filtering noisy results

One thing that got annoying very quickly: Tcl/Tk results.

Sometimes a search like format shows useful results, but also a bunch of Tcl-related entries that I do not care about at that moment.

So I added negative prompt terms.

In both Telescope and mini.pick versions:

format -tcl
format -tcl -tk

This means:

search for format
exclude entries containing tcl
optionally also exclude tk

The negative terms use smartcase too:

-tcl  # excludes tcl, Tcl, TCL, etc when smartcase allows it
-Tcl  # case-sensitive exclusion

The Telescope version implements this as a sorter wrapper. It removes the negative terms from the prompt, filters entries, then delegates the positive query back to Telescope's normal sorter.

The mini.pick version implements this as a custom source.match. It filters entries first, then passes the positive query back into MiniPick.default_match.

That way I keep each picker's normal matching behavior instead of replacing it with my own fuzzy matcher.

Opening mappings

The mappings are intentionally boring:

<CR>  :vertical Man {section} {name}
<C-x> :Man {section} {name}
<C-v> :vertical Man {section} {name}
<C-t> :tab Man {section} {name}

<CR> opens vertically by default because that is how I usually want docs next to code.

<C-x> opens with regular :Man for the classic horizontal split habit.

Portability notes

The plugin is meant to work on macOS, Linux, and FreeBSD.

That mostly means avoiding clever assumptions.

apropos output can be noisy. On my macOS machine I saw lines like makewhatis: ... No such file or directory, so the parser simply ignores lines that do not look like man entries.

Sections are also not always just 1 through 9. There can be things like:

3p
3posix
n

So the parser accepts section names inside parentheses instead of assuming one digit.

For opening pages, the plugin lets Neovim and the system man command handle the hard part.

Installation

With lazy.nvim, for the Telescope version:

{
  'moniquelive/man.nvim',
  dependencies = { 'nvim-telescope/telescope.nvim' },
  config = function()
    require('man_nvim').setup()
  end,
}

For the mini.pick version:

{
  'moniquelive/man.nvim',
  branch = 'mini.picker',
  dependencies = { 'echasnovski/mini.pick' },
  config = function()
    require('mini.pick').setup()
    require('man_nvim').setup()
  end,
}

With packer.nvim, for Telescope:

use({
  'moniquelive/man.nvim',
  requires = { 'nvim-telescope/telescope.nvim' },
  config = function()
    require('man_nvim').setup()
  end,
})

For mini.pick:

use({
  'moniquelive/man.nvim',
  branch = 'mini.picker',
  requires = { 'echasnovski/mini.pick' },
  config = function()
    require('mini.pick').setup()
    require('man_nvim').setup()
  end,
})

With vim-plug, for Telescope:

Plug 'nvim-telescope/telescope.nvim'
Plug 'moniquelive/man.nvim'

Then somewhere after plugins load:

require('man_nvim').setup()

For mini.pick:

Plug 'echasnovski/mini.pick'
Plug 'moniquelive/man.nvim', { 'branch': 'mini.picker' }

Then:

require('mini.pick').setup()
require('man_nvim').setup()

Final thoughts

This is a small plugin, but it fits my workflow nicely.

I did not want to replace man.
I only wanted a better way to discover local man pages from inside Neovim.

Telescope and mini.pick both work well for this. The fun part was keeping the core behavior simple, and only changing the picker layer.

If I extend this next, I may add a filesystem fallback for machines where the apropos database is missing or stale.

But for now: fuzzy search local docs, filter away noise, open with :Man.

Profit!

Integrating my AVR with Home Assistant

MoniqueLive — Mon, 30 Mar 2026 20:53:21 +0000

I was tired of digging through tiny on-device menus just to turn Zone 2 on and off on my AVR.

So I built a small Go CLI (zone2) that talks directly to the receiver over WebSocket, then wired it into Home Assistant as a command_line switch.

If you have an Arcam / AudioControl / JBL Synthesis receiver that exposes the setup WebSocket API on port 50001, this approach is straightforward and fast.

Source code

Why I chose a CLI first

Instead of jumping straight into a custom Home Assistant integration, I wanted a simple binary that:

can run anywhere
is easy to test from terminal
returns plain on / off output for automation parsing

That gave me a stable foundation before touching dashboards and YAML.

How the AVR communication works

The tool connects to:

ws://<AVR_IP>:50001

It sends binary protocol frames for Zone 2 (command 0x2F), then parses binary responses from the AVR.

Frame format (simplified):

request:  21 01 <command> <len> <payload...> 0D
response: 21 01 <command> <status> <len> <payload...> 0D

For reads, it queries the Zone 2 model and inspects the second byte (model[1]) as power state:

0 => off
1 => on

For writes (on, off, toggle), it updates that byte and sends the full model back.

Reliability changes that mattered

The hard part was not "sending commands", it was making behavior reliable enough for automations.

I added a few guardrails:

Frame splitting
- Receivers can send multiple protocol frames in a single WebSocket message.
- The client extracts valid frames by header/length/terminator and picks the right command.
Strict response parsing
- Validates framing, command ID, terminator, and declared payload length.
- Rejects malformed frames early.
Retry on transient states
- Zone 2 query retries up to 5 times.
- Handles temporary 0x85 status by waiting briefly and retrying.
Post-write verification loop
- After a write, it re-queries state until the target sticks (default 20 attempts).
- This avoids false positives where a write ACK arrives but state does not actually change.

This is what made it usable from Home Assistant without random "it worked... I think?" moments.

CLI usage

./zone2-macos-arm64 -host YOUR_AVR_IP -mode status
./zone2-macos-arm64 -host YOUR_AVR_IP -mode on
./zone2-macos-arm64 -host YOUR_AVR_IP -mode off
./zone2-macos-arm64 -host YOUR_AVR_IP -mode toggle

Flags:

-host (required)
-mode (on|off|toggle|status)
-timeout (default 4s)
-verify (default 20, used for writes)
-verbose (prints raw TX/RX frames)

Home Assistant integration

I cross-compile a Linux ARM64 binary for HA OS (Raspberry Pi 5), copy it into /config/bin, and expose it via command_line:

command_line:
  - switch:
      name: AVR Zone 2
      unique_id: avr_zone2
      command_on: "/config/bin/zone2 -host YOUR_AVR_IP -mode on -timeout 4s -verify 20"
      command_off: "/config/bin/zone2 -host YOUR_AVR_IP -mode off -timeout 4s -verify 20"
      command_state: "/config/bin/zone2 -host YOUR_AVR_IP -mode status -timeout 4s"
      value_template: "{{ value | trim | lower == 'on' }}"
      scan_interval: 10

Because the CLI prints exactly on or off, the value template stays simple and reliable.

Build + release flow

The repo includes:

Makefile targets for Linux ARM64 + macOS binaries
CI (go test, go vet)
tag-triggered GitHub release workflow attaching compiled binaries

That made it easy to test locally and deploy repeatably.

Final thoughts

This was a small project, but a useful reminder: in home automation, state verification is more important than "command sent successfully".

A tiny, deterministic CLI with clear output is often enough to bridge unsupported hardware into Home Assistant cleanly.

If I extend this next, I'll likely add controls for input/volume and package a full HA integration once the protocol surface is mature.

Tech Meets Tunes: Creating a Seamless Alfred Workflow for EDM Aficionados

MoniqueLive — Fri, 05 Jan 2024 18:54:46 +0000

The Problem

If you're a EDM fan like me you probably know the super traditional website Digitally Imported.

I'm a long time supporter (and I recommend you consider supporting it - streaming bills ain't cheap ya know). But one thing bugged me for a long time: it has no native player like Spotify and Apple Music. And I like changing stations all day long. And I don't like keeping a browser tab exclusively for this.

Since I'm a heavy Alfred user I looked for a workflow but had no luck. So I made one.

The Solution

The workflow editor is pretty neat. You drop boxes and link them in order to make one box's output become the other's input:

My Alfred's Workflow panel

And that's it. Just two boxes linked in order to play some electronic music ❤️

But wait, there's more!

It would be a very boring article if it ended here, right? 😊
First of all, the list of radio stations is huge! (99):

double clicking on List Filter

I would never type 99 times each station information... No... I asked our friendly overlord GPT-4 for some help.

Chat GPT to the rescue

All I had was the 99 url slugs for each radio station. When you open a playlist (.pls file) you'll get all the streaming url's in the form:

http://prem1.di.fm/${query}?XXXXXX

Where ${query} is the station name and XXXX is your 'Listen key' that can be grabbed on the Settings page.

But in order to fill the workflow's List Filter I needed a .csv file with 3 columns:

First some words, separated by space, which are searched after you type your workflow's keyword
A plain text english description that will be shown as a subtitle
The value that will be passed as the input for the next node on the graph

So the prompt I wrote was basically:

Given the following slugs:

- 00sclubhits
- ambient
- atmosphericbreaks
... (until 99)

Create a three column CSV formatted list of:

- the slug broken in words
- a plain english description of the slug
- the slug unchanged

For example:

- 00sclubhits

in CSV:

00s club hits, 2000's Club Hits, 00sclubhits

And it very kindly generated this csv file. ❤️ (full disclosure: I removed the header line and removed extra spaces between columns that confused Alfred)

Then I dragged the generated .csv file into the left column of the List Filter and that was it for this node.

The second node is super simple. It's a Run Script node with the following:

Open Apple Music with the following url

You can use your preferred player here. I tested with VLC and Apple Music.

And that's it!

Now you have a personalized station picker:

All the vocal stations

I hope you enjoyed reading this as much as I enjoyed putting this together.

Have a good one!

Using fzf to choose from a list of choices

MoniqueLive — Wed, 06 Sep 2023 20:18:53 +0000

Some scenarios I use fzf to help me pick from a list of choices

#1 - picking which docker images I'd like to remove

fzfrmimage () {
  # - list all docker images, skipping the first line
  # - feed these lines into fzf (user: TAB select/hit ENTER)
  # - format a list of 'image:tag's and pass it to `docker image rm` 
  images=$(docker image ls | tail -n +2 | fzf | sed -n 's/\(\S*\) *\(\S*\).*/\1:\2/p')
  docker image rm $(echo $images)
}

#2 - picking from pygments themes (styles)

I used this as a oneliner (actually 2 for better legibility) in order to preview some sample code using the style.

pygmentize -L styles | sed -n 's/^* \(.*\):/\1/p' |\
  fzf --preview "pygmentize -P style={} -l python ~/prj/python/bored/main.py"

list all styles
filter for lines that start with an asterisk
remove the trailing ':' character
feed the list into fzf with a sample code preview
user: TAB select / hit ENTER
fzf prints the selected themes
profit!

FZF is a super flexible tool that I'm always looking for ways to leveraging its powers. Thanks Junegunn Choi for creating it!

Using nerd font symbols and emoji with any (unpatched) font in Linux

MoniqueLive — Tue, 27 Jun 2023 23:29:05 +0000

After I read the note on this question on the Kitty terminal FAQ I started paying attention to editors, ide's and terminals that support fallback fonts.

A fallback font is a reserve typeface containing symbols for as many Unicode characters as possible. When a display system encounters a character that is not part of the repertoire of any of the other available fonts, a symbol from a fallback font is used instead. Typically, a fallback font will contain symbols representative of the various types of Unicode characters. ¹

But not all editors, ide's or terminals support them. Like the terminal emulator alacritty for example.

But Linux's fontconfig package is very complete and it allows you to create font families, which I understood are virtual fonts you create in order to have the fallback mechanism manually set up.

So let's cut to the chase! First create a file in ~/.config/fontconfig called fonts.conf with the following contents:

<?xml version="1.0"?>
<!DOCTYPE fontconfig SYSTEM "urn:fontconfig:fonts.dtd">
<fontconfig>
  <match target="font">
    <edit name="autohint" mode="assign">
      <bool>true</bool>
    </edit>
  </match>
  <alias>
    <family>my-chosen-font-family</family>
    <prefer>
      <family>JetBrains Mono</family>
      <family>Symbols Nerd Font</family>
      <family>Noto Color Emoji</family>
    </prefer>
  </alias>
</fontconfig>

The <match> tag asks for auto-hinting in order to have better looking fonts.

The <alias> tag contains the name of your virtual font my-chosen-font-family and the set of fonts that belong to it. In my case I have an unpatched (original) font, the symbols nerd font and the emoji one.

Now all you have to do is configure your apps to use it. In alacritty it would be:

font:
  normal:
    family: my-chosen-font-family
    style: Regular

  bold:
    family: my-chosen-font-family
    style: Bold

  italic:
    family: my-chosen-font-family
    style: Italic

  bold_italic:
    family: my-chosen-font-family
    style: Bold Italic

Enjoy!

https://en.wikipedia.org/wiki/Fallback_font ↩

Passing multiple arguments to golang sub-templates

MoniqueLive — Mon, 28 Nov 2022 21:04:31 +0000

Have you ever wanted to pass multiple arguments to a go sub-template? If you google it you'll be convinced it's not possible. But bear with me.

In go templates you can pass a single "argument" (pipeline in go parlance) to a "sub-template" defined block. But by creating a simple helper function you can pass as many arguments as you want. Simply add this function to your FuncMap:

func(els ...any) []any {
    return els
}

And you'll be able to create constructs such as:

{{ template "MyTemplate" (arr "first" 123 .Some.Value) }}
{{ template "MyTemplate" (arr "second" 456 .Other.Value) }}

{{ define "MyTeplate" }}
  {{ $strArg := index . 0 }}
  {{ $intArg := index . 1 }}
  {{ $valArg := index . 2 }}

  This is my str {{ $strArg }} parameter.
  ...
{{ end }}

I named arr my helper func, but you can call it whatever you want.

Enjoy!

Auto activate and deactivate python venv using zsh (and fish)

MoniqueLive — Fri, 17 Dec 2021 15:01:10 +0000

When I found out about python venv (apt-get install python3-venv) I became an instant addict. It's clean, it's built-in and it's explicit.

Now every time I create a new project folder I automatically run python3 -mvenv venv && source ./venv/bin/activate.

But typing ./venv/bin/activate and then deactivate is too much work for my lazy programmer head.

So I decided to finally invest 10 minutes to free me from activating and deactivating python's env every time I enter or leave a folder with my standard ./venv folder:

#---------------------------------------------- chpwd pyvenv ---
python_venv() {
  MYVENV=./venv
  # when you cd into a folder that contains $MYVENV
  [[ -d $MYVENV ]] && source $MYVENV/bin/activate > /dev/null 2>&1
  # when you cd into a folder that doesn't
  [[ ! -d $MYVENV ]] && deactivate > /dev/null 2>&1
}
autoload -U add-zsh-hook
add-zsh-hook chpwd python_venv

python_venv

edit: just figured out that deactivating was working because of other stuff installed in my shell. Now it's a bit more agressive but works 100%

edit2: been trying out fish shell. Here it is translated to fish script:

function python_venv --on-variable PWD
    set myvenv ./venv
    if test -d $myvenv
        source $myvenv/bin/activate.fish
    else if type -q deactivate
        deactivate
    end
end

Python3 + GTK+3 + Glade + Templates = <3

MoniqueLive — Sun, 28 Mar 2021 01:26:28 +0000

Many software that you use on your Gnome environment could've been developed with Python. Apps like Gnome Music and Gnome Tweaks are some examples.

In this article I'll show you a minimal example in order to give you a foundation for your ideas. Let's go:

Create a basic layout on Glade:

Stuff you need to pay attention to:

The top level component is a GtkApplicationWindow (you can find it under Toplevels button)
While it's selected, check the Composite checkbox on the farther right (super important!)
When you check the Composite checkbox the ID field becomes Class Name. Give it a name and save it, we'll use it soon
Give the button an ID and save it, we'll use it soon

With the Button selected, switch to the Signals tab:

Click on the Handler column on the clicked Signal row
Type the first letter of your button's name
Accept the suggestion (btnMain_clicked_cb, in my example) and save it, we'll use it soon

And that's it for Glade. Save your .glade file on your project dir.

Create a basic Python skeleton:

import gi
gi.require_version("Gtk", "3.0")
from gi.repository import GLib, Gio, Gtk

import sys


#
# 1. our .glade file (may contain paths)
#
@Gtk.Template.from_file("a.glade")
class AppWindow(Gtk.ApplicationWindow):
    #
    # 2. the GtkApplicationWindow class
    #
    __gtype_name__ = "app_window"

    #
    # 3. the Button name we saved above
    #
    btnMain: Gtk.Button = Gtk.Template.Child()

    #
    # 4. the signal handler name we saved above
    #
    @Gtk.Template.Callback()
    def btnMain_clicked_cb(self, widget, **_kwargs):
        assert self.btnMain == widget
        print(widget.get_label())


class Application(Gtk.Application):
    def __init__(self, *args, **kwargs):
        super().__init__(*args, application_id="dev.monique.Gtk1",
                         flags=Gio.ApplicationFlags.FLAGS_NONE, **kwargs)
        self.window = None

    def do_activate(self):
        self.window = self.window or AppWindow(application=self)
        self.window.present()


if __name__ == '__main__':
    Application().run(sys.argv)

You'll also need to:

pip install PyGObject

It may complain about missing libraries, just read the error output and install the missing dependencies (I had to apt install libcairo2-dev libgirepository1.0-dev)

With this code you'll be able to get started.

Good luck!

How I compile OpenCV on Linux with lots of bells and whistles (CuDNN, CUDA, OpenGL, Qt, TrueType, Video CODECs)

MoniqueLive — Tue, 16 Feb 2021 02:09:32 +0000

Em português.

OpenCV is a beast of a library. It's huge. But it's also super flexible. You typically choose what your binary will contain by providing optional dependencies but sometimes you have to nudge it to the direction you need.

In this guide I'll show you how I compile it with the longest cmake line you'll ever see (hopefully) and I'll also add comments so you know what you need to compile it successfully.

Let's get started.

Downloading

You need two projects in order to build OpenCV: the OpenCV source code and OpenCV contrib.

You can either download the latest versions as as zip/tar ball or you can clone them and checkout the version (aka tag) you need.

Whatever way you choose, for the purpose of this tutorial all you need is both projects to be sitting next to each other on the same folder:

Dependencies

If you install all the depencies I explain bellow you'll have:

--   OpenCV modules:
--     To be built:                 aruco bgsegm bioinspired calib3d ccalib core cudaarithm cudabgsegm cudacodec cudafeatures2d cudafilters cudaimgproc cudalegacy cudaobjdetect cudaoptflow cudastereo cudawarping cudev cvv datasets dnn dnn_objdetect dnn_superres dpm face features2d flann freetype fuzzy gapi hfs highgui img_hash imgcodecs imgproc intensity_transform line_descriptor mcc ml objdetect optflow phase_unwrapping photo plot python3 quality rapid reg rgbd saliency shape stereo stitching structured_light superres surface_matching text tracking video videoio videostab xfeatures2d ximgproc xobjdetect xphoto
--     Disabled:                    world
--     Disabled by dependency:      -
--     Unavailable:                 alphamat cnn_3dobj hdf java julia matlab ovis python2 sfm ts viz

This is what you'll need:

python3 + numpy - I generally install it globally, outside of any venv/virtualenv sandboxes. Having OpenCV installed globally I can reference it on the venv sandboxes when needed. You'll see a similar cmake output:
python3-pyqt5.qtopengl - it's enough to bring in the dependencies in order to detect Qt + OpenGL. Why is OpenGL so important, you may ask? Hardware accelerated frame rates. You'll see a similar cmake output:
ffmpeg + gstreamer - if you want to load different video encodings:
libfreetype-dev + libharfbuzz-dev - if you want support for truetype fonts
CUDA + CuDNN - this one deserves a more detailed explanation bellow.

CUDA + CuDNN

CUDA (and CuDNN) are usually installed under the same directory. And this directory is typically /usr/local/cuda-<version>. But this is not a rule. I use PopOS and it gets installed in /usr/lib/cuda-<version>. It can also have as many versions as you want installed in parallel:

As you can see above, even though CUDA-11.2 was installed automatically (it's the current version as of today), CuDNN is only available up until 11.1 so I was forced to install CUDA-11.1 as well in order to have both CUDA and CuDNN installed on the same tree structure.

In order for cmake to find CUDA and CuDNN all you need is add <your CUDA root>/bin to your path.

You can check like this:

Super easy right? 🤣

Let's build it then!

Check for dependencies

In order to compile you need to create a build folder inside your opencv library root folder (cd opencv; mkdir build; cd build).

Now take a deep breath and enjoy the largest command line I've ever written for a single command:

cmake -D CMAKE_CXX_COMPILER=/usr/bin/g++ \
-D CUDA_HOST_COMPILER:FILEPATH=/usr/bin/gcc-9 \
-D CUDA_NVCC_FLAGS=--expt-relaxed-constexpr \
-D WITH_CUDA=ON \
-D WITH_CUDNN=ON \
-D CUDNN_INCLUDE_DIR=/usr/lib/cuda-11.1/include \
-D OPENCV_DNN_CUDA=ON \
-D ENABLE_FAST_MATH=1 \
-D CUDA_FAST_MATH=1 \
-D CUDA_ARCH_BIN=8.6 \
-D WITH_CUBLAS=1 \
-D WITH_TBB=ON \
-D WITH_OPENMP=ON \
-D WITH_IPP=ON \
-D CMAKE_BUILD_TYPE=RELEASE \
-D WITH_CSTRIPES=ON \
-D OPENCV_EXTRA_MODULES_PATH=../../opencv_contrib/modules \
-D CMAKE_INSTALL_PREFIX=/usr/local/ \
-D WITH_QT=ON \
-D WITH_OPENGL=ON \
-D BUILD_EXAMPLES=OFF \
-D BUILD_DOCS=OFF \
-D BUILD_PERF_TESTS=OFF \
-D BUILD_TESTS=OFF \
-D BUILD_opencv_python3=ON \
-D PYTHON3_EXECUTABLE=$(which python3) \
-D PYTHON_INCLUDE_DIR=$(python2 -c "from distutils.sysconfig import get_python_inc; print(get_python_inc())") \
-D PYTHON3_INCLUDE_DIR=$(python3 -c "from distutils.sysconfig import get_python_inc; print(get_python_inc())") \
-D PYTHON3_LIBRARY=$(python3 -c "from distutils.sysconfig import get_config_var;from os.path import dirname,join ; print(join(dirname(get_config_var('LIBPC')),get_config_var('LDLIBRARY')))") \
-D PYTHON3_NUMPY_INCLUDE_DIRS=$(python3 -c "import numpy; print(numpy.get_include())") \
-D PYTHON3_PACKAGES_PATH=$(python3 -c "from distutils.sysconfig import get_python_lib; print(get_python_lib())") \
..

Don't miss the double dots at the end!

Some configurations worth explaining:

CMAKE_CXX_COMPILER - to compile c++ files
CUDA_HOST_COMPILER:FILEPATH - to compile cuda files - During system76-cudnn package installation I noticed it installed gcc-9. Very deterministic (not), I know.
CUDA_NVCC_FLAGS - needed some day, may remove eventually
CUDNN_INCLUDE_DIR - check your cuda home folder
CUDA_ARCH_BIN - the architecture of your GPU. Check it here https://developer.nvidia.com/cuda-gpus
OPENCV_EXTRA_MODULES_PATH - relative or absolute path to opencv_contrib folder

In order to validate if all your dependencies are ok, read the line Unavailable: ... in the beginning of the previous section and check for differences with yours.

If you need to rerun cmake, leave the build folder, destroy it, recreate it, change back to it, only then rerun cmake... It's a tedious process but there's no shortcut here unfortunately.

Compiling

This step is the easiest. Given all the dependencies are met all you have to do is run the make command:

make -j<number of processes>

I highly recommend using the -j flag in order to cut compilation time. If you want to keep using your machine while the compilation is running, I recommend using $(nproc)-2.

For your reference, using -j60 + nvme, the compilation process takes 5m30s here.

If anything goes wrong don't be afraid to scroll up (or search for error:) and check what happened.

Installing

If everything went fine and dandy:

💯% baby!

All you need to do is:

sudo make install

That's the only time you need to invoke root's super powers in order to write files on /usr/local.

Validating

To test your achievement:

$ python3
>>> import cv2
>>> print(cv2.getBuildInformation())

You should see the same output as cmake's.

Using

In order to use OpenCV with a venv (you can read more about venv here) use the flags:

python -mvenv --system-site-packages venv

This will create a sub-folder named venv with a sandbox that comes with "system wide packages", such as ... you know it.

Closing

If you read until here, congrats, you are a very determined person 🤣

If you need any help just leave a comment!

Good luck.

Pre-compiled pytorch versions

MoniqueLive — Wed, 20 Jan 2021 17:51:25 +0000

I had just found about a repository that just saved my bacon so I decided to share it with you guys.

If you go to pytorch's website, you'll be given a lot of choices to install it:

The thing is, if you want to install a different version than the one listed (1.7.1 as of today) you'll begin a not very pleasant treasure hunt.

There's a repo that somehow took me quite a while to find here:

https://download.pytorch.org/whl/torch_stable.html

But you don't need to click on it! You can ask pip to fetch it for you:

pip[3] install pytorch==1.6.0+cu101 -f https://download.pytorch.org/whl/torch_stable.html

And voilá, your package will be installed automagically!

Now some extra tips:

Some cuda versions are considered "default". For instance if you look for 1.6.0+cu102 you won't find it, that's because installing pip install cuda==1.6.0 will automatically fetch cuda's 10.2 version.
If you're a masochist and need the CPU-only version: pip install 1.6.0+cpu
To save this repo on your requirements.txt, just add this as the first line of it:

-f https://download.pytorch.org/whl/torch_stable.html

...
torch==1.6.0+cu110
...

Happy torching!

Autocompletion globally installed OpenCV with PyCharm

MoniqueLive — Mon, 28 Dec 2020 17:19:43 +0000

Intro

For a long time I was a user of the virtualenv module. But ever since I learned about the standard module venv I became a devotee.

For starters it comes bundled with python (or by installing the python3-venv package). It's also more predictable than virtualenv since you don't need to mess with your .{bash/zsh/fish}rc files and it's generally installed under your project's root dir.

But there's one exception for using locally installed packages, and it's packages that need to be built on your machine. OpenCV is one of them. You can install a pre-built one using pip install opencv-python-contrib but it won't take advantage of your shiny new GPU.

OpenCV

Building OpenCV is a whole topic on itself but assuming you did all the steps (cmake + infinite flags / sudo make install) it'll be installed on your machine globally (on /usr/lib).

To use it locally on a venv isolated environment, you have to use the following flag:

python -mvenv --system-site-packages venv

The --system-site-packages flag creates a local environment but includes all the globally installed modules.

Just for completion sake, don't forget to active the environment:

source venv/bin/activate

PyCharm

Now if you use PyCharm and would love to see the autocompletion work with your just installed OpenCV there's one extra step.

First of all, tell PyCharm to use your venv by going to Settings -> Python Interpreter -> "cog" button -> Add -> Existing environment.

(If you create your venv first and then open the directory on PyCharm, it'll autodetect it)

But by default PyCharm won't find the .so built for OpenCV. You have to tell it where it is.

To find where yours was installed you can use the find tool:

find /usr -name cv2\*so

Mine was found under /usr/lib/python3/dist-packages/cv2/python-3.8/cv2.cpython-38-x86_64-linux-gnu.so

Now you get back to the interpreter settings (Settings -> Python Interpreter -> "cog" button -> Show all), select the interpreter for your project, click on the toolbar's last button (Show paths for the selected interpreter) and add the above directory removing your *.so file name:

After this last extra step autocomplete should work like a charm (oops...).

Happy coding!