@U3LHMD2E8 First: yes, use {:coerce {:opt :boolean}} for flags

Second: use {:coerce {:X [:string]}}

user=> (cli/parse-opts ["-X" "file1.clj" "-X" "file2.clj"] {:coerce {:X [:string]}})
{:X ["file1.clj" "file2.clj"]}

All together:

user=> (cli/parse-args ["-X" "file1.clj" "-X" "file2.clj" "--myflag" "arg1"] {:coerce {:myflag :boolean :X [:string]}})
{:args ["arg1"], :opts {:X ["file1.clj" "file2.clj"], :myflag true}}

Thanks!

> {:coerce {:X [:string]}} The additional :string doesn’t seem to change behavior:

(def args ["-X" "foo1" "-X" "foo2" "file1" "file2"])
(cli/parse-args args ; original
                {:coerce {:X [] :files []}
                 :args->opts (repeat :files)})
(cli/parse-args args ; explicit :string
                {:coerce {:X [:string] :files []}
                 :args->opts (repeat :files)})
(cli/parse-args args ; explicit :string in both
                {:coerce {:X [:string] :files [:string]}
                 :args->opts (repeat :files)})

...
user=> {:opts {:X ["foo1" "foo2" "file1" "file2"]}}
user=> {:opts {:X ["foo1" "foo2" "file1" "file2"]}}
user=> {:opts {:X ["foo1" "foo2" "file1" "file2"]}}

babashka cli supports two ways of specifying multiple values: either by repeating the option name + value or by providing the option name followed by multiple values

to separate args from opts at the end you can use the -- separator

user=> (def args ["-X" "foo1" "-X" "foo2" "--" "file1" "file2"])
#'user/args
user=> (cli/parse-args args {:coerce {:X [] :files []} :args->opts (repeat :files)})
{:args ["file1" "file2"], :opts {:X ["foo1" "foo2"]}}

Ok, makes sense then: this particular form (with the args->opts coersion) will only with with -- in the presence of a trailing array-stuffing opt.

we could include an option to disable the --opt val1 val2 syntax

if that's what you want

For this it’s only a personal tool — I brought up these since they’re common CLI patterns, and in my experience a single --arg rarely takes >1 value

if it doesn't take > 1 value you should not specify it as something that can be multiple with :coerce []

user=> (cli/parse-args ["--foo" "1" "a" "b" "c"])
{:args ["a" "b" "c"], :opts {:foo 1}}

user=> (cli/parse-args ["--foo" "1" "a" "b" "c"] {:coerce {:foo :boolean}})
{:args ["1" "a" "b" "c"], :opts {:foo true}}

user=> (cli/parse-args ["--foo" "1" "a" "b" "c"] {:coerce {:foo []}})
{:opts {:foo [1 "a" "b" "c"]}}

but I can see that the last syntax might not be posix-y, I'm fine with optionally disabling that

I need multiple args for both — in my actual case, I have 0-n “pre-ambles”, and 1+ actual files. Thus the -X foo -X bar file1 file2 is the syntax I hoped to work, without requiring me to remember to add -- and force the parser to stop. I’d love to tackle this, but will have to look at that code again to see what I can figure out. [removed bits which were poorly written]

soo…meander doesn’t? (honest question, I’m still new to this)

I had noticed the announcement of lasagna-pull, too, and wondered how it differed from meander… 💭

@U04GFG14FCP Meander also works:

$ time bb -Sdeps '{:deps {meander/epsilon {:mvn/version "0.0.650"}}}' -e "(require '[meander.epsilon :as m]) (m/match {:foo :bar} {:foo ?a} ?a)"
:bar
bb -Sdeps '{:deps {meander/epsilon {:mvn/version "0.0.650"}}}' -e    0.38s  user 0.02s system 98% cpu 0.404 total

💡 thanks!

I'm sure there's more trade-offs, probably meander has better performance etc

but for bb scripts startup matters

Thanks for discussing my library here. I did not know meander when I wrote lasagna-pull. From my initial observation, meander is much more complex than lasagna-pull; it is a real compiler from a logical programming background, whereas lasagna-pull is a pure practical effort to try to match Clojure’s map and sequences of maps, which might explain the start time difference @U04V15CAJ observed (or performance) between them.

yes of course

oh stream

what exactly do you mean, can you give an example?

I would like to send back the python stdout as stream.. with the same id

Does this help? https://github.com/babashka/pods#out-and-err

You can also use the socket transport and then your python program can just print whatever

I would like to catch https://github.com/openai/whisper stdout with babashka. In -verbose mode. Whisper transcribe the audio.. in realtime mainly.. every 8 sec.. you get back the copy.. and I would like to drop to output. See this action

I try out the socket part in this case

I notice that socket transport isn't that greatly documented, but here is a pod which uses it: https://github.com/babashka/pod-babashka-lanterna

Thank you very much!!

I check it now.

(load-pod your-pod {:transport :socket}) on the caller side

or you can say in the manifest: https://github.com/babashka/pod-registry/blob/a474904c2b964c8212b7b62a773ab97a014a28c3/manifests/org.babashka/lanterna/0.0.1/manifest.edn#L5 and then it will work automatically (but for local development it's easier to use the manual option)

This is an example of the lanterna pod which uses the socket and all stdin/stdout is going normally:

bb -Sdeps '{:deps {io.github.borkdude/console-tetris {:git/sha "2d3bee34ea93c84608c7cc5994ae70480b2df54c"}}}' -m tetris.core

Wow! Thank you 🙂

Ok, I need to go now. But if I will have question I drop to here. Thank you very much again your help!! 🍻