Exposing python script with dependencies via override_find_program

[sp1ritCS]

I have a python script that depends on a cpython extension module built in meson in a subproject.

I'm looking if there is a canonical way of exposing that script via meson.override_find_program, as it only takes in exe | file | external_program , which exe being the only one that supports dependencies, but I can create an executable target for my python script.

A really ugly hack that I've found was

pymod = import('python').find_installation('python3').extension_module('_tool', ...)

tool_name = 'tool.py'
tool_target = custom_target('tool-target',
  command: [ meson.current_source_dir() / 'produce-run-wrapper', meson.current_source_dir() / tool_name ],
  capture: true,
  depends: pymod,
  output: 'tool-wrapper.c'
)
tool_exec = executable('tool-wrapper', tool_target, install: false)

meson.override_find_program('tool', tool_exec)

with produce-run-wrapper being:

#!/bin/sh

if [ -z $1 ]; then exit 1; fi

cat <<EOF
#include <errno.h>
#include <unistd.h>

int main(int argc, char **argv) {
	execv("$1", argv);
	return -errno;
}
EOF

[eli-schwartz]

with produce-run-wrapper being:

You could also have the custom target just produce an empty file "stamp.h", and add it as a dependency to an ordinary executable to force the executable to be recompiled every time a random other file changes. Not saying this is the pinnacle of design, just a general way to force an executable into having an effective rebuild dependency on something else. No need to inline source code into a shell script, at least.

That does overall seem like the best you can do at the moment since custom_target isn't currently accepted by override_find_program. (Hmm, why is that?)

[sp1ritCS]

You could also have the custom target just produce an empty file "stamp.h"

custom_target works, even without a command? Or would I need to point it to something like /bin/true w. capture: true?

custom_target isn't currently accepted by override_find_program

Having it do so wouldn't be a fix for me given that custom_target is a lot less flexible (fixed arguments) than what I'd expect of find_program.

A better solution I think would be to have some sort of subclass from executable (like jar() is too) for interpretable targets

[eli-schwartz]

Or would I need to point it to something like /bin/true w. capture: true?

More like touch so you don't need to run a python wrapper to capture non-existent stdout just so it can be written to an empty file.

Having it do so wouldn't be a fix for me given that custom_target is a lot less flexible (fixed arguments)

I can't imagine why fixed arguments would be relevant here. We're talking about custom_target, a meson function that can implement the command "cp" and outputs a script program and runs "cp" with fixed arguments every time its depends are updated.

We're not talking about generator(), a function that outputs a callable template object.

A custom target that gets re-copied every time the dependency module is rebuilt would be a perfectly suitable replacement for an executable() that gets re-transpiled, recompiled, and relinked every time the dependency module is rebuilt.

[sp1ritCS]

That does overall seem like the best you can do at the moment since custom_target isn't currently accepted by override_find_program. (Hmm, why is that?)

It seems to me that there are a bunch of modules that expect to be able to call get_command on the output from find_program. CustomTarget doesn't have that

[sp1ritCS]

I can't imagine why fixed arguments would be relevant here.

ah, I was somehow thinking of the built tool run being the custom_target command for some reason, not that the tool is the output of custom_target itself.