How to pass command line arguments to include("<julia file>")?

[Luis_de_la_Torre]

I have a Julia file that takes command line arguments and parses them using ArgParse. I want to run the program in the REPL (trying to debug with Gallium). How do I pass the command line arguments?

[Michael_Eastwood]

Does this work for you?

From the command line:

$ cat test.jl
function main(args)
    @show args
end
main(ARGS)

$ julia test.jl hello world
args = String["hello","world"]

From the REPL:

julia> ARGS = ["hello", "world"]
       include("test.jl")
args = String["hello","world"]

[Luis_de_la_Torre]

Yes, thank you! There is one other change I had to make to accommodate ArgParse.jl
The ArgParse function parse_args(s) parses the command line input with parsing specified by s. I had to instead explicitly pass it ARGS as parse_args(ARGS, s) to use ArgParse in the REPL.

[ephemeris]

There is that question on StackOverflow. I was wondering if passing arguments as a Collection to include function is against some ideas behind julia. Because if not, I think it could be a useful feature. As of now you are either required to modify your script with the suggested isdefined() check or redefine ARGS explicitly which results in a warning.

I think It would be nice as it would for example streamline using others’ scripts that are not written as modules from within your own ones.

[ihnorton]

Merging in to duplicate

How to pass command line arguments to include("<julia file>")?

I have a Julia file that takes command line arguments and parses them using ArgParse. I want to run the program in the REPL (trying to debug with Gallium). How do I pass the command line arguments?

[StefanKarpinski]

Let’s suppose the API is include("script.jl", ARGS=["--foo", "123"]). What would that do?

[orhan_abar]

I couldn’t run my program from the REPL.
When I try this:

julia> ARGS = ["hello", "world"] include("test.jl")
error: ERROR: syntax: extra token "include" after end of expression

How can you make it 2 lines:
If I try to run first:

ARGS = ["hello", "world"] 
Error: ERROR: cannot assign variable Base.ARGS from module main

But command line is working with out any problem

[Zranz]

The format include("script.jl", ARGS=["--foo", "123"]) looks good to pass arguments. Rigth now we get an error if we try to redefine ARGS, or use @Michael_Eastwood suggestion in a single line.

[flalom]

Hello everybody.

I would like to ask you: how to enter the argument(s) for only one of the many functions I have in my script from command line?

Thank you!

[Tamas_Papp]

Please provide an MWE. Also, it may be best to just start a new topic since your question may not be related to this one.

Please read: make it easier to help you

Welcome to the Julia Discourse! We are enthusiastic about helping Julia programmers, both beginner and experienced. This public service announcement (PSA) outlines best practices when asking for help. Following these points makes it easier for us to help you and more likely you’ll get a prompt, useful answer. Keywords are highlighted to make it easier to refer to specific points. Choose a descriptive title that captures the key part of your question, eg “plots with multiple axes” instead of …

[flalom]

Thank you.
I opened a new topic because I think you are right and my question is not exactly related to this one of this thread.

Here the new post:
link

Cheers

[josePereiro]

If I include a ‘peace of code’ it just share the ‘includer’ ARGS dictionary. Include have the same effect than just copying the included code.

[nstgc]

MWE:

echo "@show ARGS" > /tmp/test.jl
echo 'ARGS = ["Hello World"]' > /tmp/test2.jl
echo 'include("/tmp/test.jl")' >> /tmp/test2.jl
julia /tmp/test2.jl

This will fail with the error:

ERROR: LoadError: cannot assign a value to variable Base.ARGS from module Main
Stacktrace:
[1] top-level scope at /tmp/test2.jl:1
in expression starting at /tmp/test2.jl:1

I’d very much like to know a work around other than wrap the target script in a function since I don’t think that would work in my use case without cluttering up my working directory with virtually empty files that just wrap other files.

edit: Actually, I just thought of a possible work around, though I don’t have time to test it right now. Later I’ll see if maybe I can pass the ARGS via stdout. In the target script (the one being included), I would check to see if ARGS is defined. If not, it will try reading from stdin.

This still feels unnecessary, but I think that should work.

edit2: Probably a better work around would be to check if args is defined. If it is, define variables based on that, otherwise look in ARGS. I’ll probably do that.

[fredrikekre]

You can modify ARGS rather than creating a new variable named ARGS

$ echo "@show ARGS" > test.jl
$ echo 'push!(empty!(ARGS), "Hello World")' > test2.jl
$ echo 'include("test.jl")' >> test2.jl
$ julia test2.jl
ARGS = ["Hello World"]

BTW, the code should not error. This is a bug that seems to have been introduced in Julia 1.5. Edit: https://github.com/JuliaLang/julia/issues/39259

[nstgc]

Thanks! That makes sense.

As for this being a bug, it actually seemed semi-reasonable for ARGS to be protected. I didn’t even think to check to see if it was a feature or a bug.

[RaulDurand]

@fredrikekre

push!(empty!(ARGS), "Hello World")

Wouldn’t it be simpler if the include function could consider an optional tuple argument with the command line parameters? ARGS would be evaluated per file.

[Tamas_Papp]

@RaulDurand

simpler if the include function could consider an optional tuple argument with the command line parameters?

I don’t think this is a common use case. The workaround (modify ARGS) is sufficient for debugging scripts.