modules-interest — Discussion forum for modules usage.

[Modules] Always see hidden modules

[Xavier D. <xav...@gm...>]

Dear All,

Next version (5.6) will come with the ability to always see hidden
modules, through the addition of the "hidden" element to the output
configuration options:

https://modules.readthedocs.io/en/latest/MIGRATING.html

Best regards,
Xavier

Re: [Modules] Modulefiles mode for Emacs

[Xavier D. <xav...@gm...>]

Hello All,

Thanks to the contribution of Laurent, a "modulefile-mode" for Emacs
is now available with Modules.

See https://github.com/envmodules/modules/tree/main/share/emacs/lisp

I have adapted RPM spec file to include these Emacs addon files when
installation environment-modules RPM.

Best regards,
Xavier

Le jeu. 12 juin 2025 à 20:29, Xavier Delaruelle
<xav...@gm...> a écrit :
>
> Hello Laurent,
>
> I suggest you create a pull request on GitHub (fork+new
> branch+push+create pull request). Add the new file into directory
> "share/emacs".
>
> Best regards,
> Xavier
>
> Le jeu. 12 juin 2025 à 13:51, Laurent BESSON
> <lau...@ea...> a écrit :
> >
> > Hello Xavier, all
> >
> >
> >
> > I wrote a first version for a Modulefiles mode for Emacs. It relies on existing Tcl mode (tcl-mode) and adds highlighting for the Modulefiles commands.
> >
> >
> >
> > How can we proceed to make it available to anyone ? Do I create a new branch/fork from GitHub or do I send the file (only one, for the time being) directly to you for integration ?
> >
> > If anyone on the list wants to give it a try, I'll be happy to share 😊
> >
> >
> >
> >
> >
> > L.
> >
> >
> >
> > -----Message d'origine-----
> > De : Xavier Delaruelle <xav...@gm...>
> > Envoyé : mercredi 11 juin 2025 18:49
> > À : Environment Modules usage and discussion. <mod...@li...>
> > Objet : Re: [Modules] Modulefiles mode for Emacs
> >
> >
> >
> > Hello Laurent and All,
> >
> >
> >
> > That could be great stuff to contribute to the project. I am not an Emacs user, so I cannot help here. LLM may help but it requires someone with good enough Emacs knowledge to steer it.
> >
> >
> >
> > For Vim, we have already done this job. It is available within https://github.com/envmodules/modules/tree/main/share/vim.
> >
> >
> >
> > Best regards,
> >
> > Xavier
> >
> >
> >
> > Le mer. 11 juin 2025 à 11:58, Laurent BESSON <lau...@ea...> a écrit :
> >
> > >
> >
> > > Hello dear Modules list,
> >
> > >
> >
> > >
> >
> > >
> >
> > > I’m an old fashion guy and I’m still using Emacs as my favorite editor 😊. But I’m pretty sure I’m not the only one in this list.
> >
> > >
> >
> > >
> >
> > >
> >
> > > I was wondering if someone had developped a « mode » to colorize Modulefiles files ? or at least some setup to recognize Modulefiles and use tcl-mode automatically ?
> >
> > >
> >
> > >
> >
> > >
> >
> > > Best regards,
> >
> > >
> >
> > > Laurent.
> >
> > >
> >
> > > _______________________________________________
> >
> > > Modules-interest mailing list
> >
> > > Mod...@li...
> >
> > > https://lists.sourceforge.net/lists/listinfo/modules-interest
> >
> >
> >
> >
> >
> > _______________________________________________
> >
> > Modules-interest mailing list
> >
> > Mod...@li...
> >
> > https://lists.sourceforge.net/lists/listinfo/modules-interest
> >
> > _______________________________________________
> > Modules-interest mailing list
> > Mod...@li...
> > https://lists.sourceforge.net/lists/listinfo/modules-interest

Re: [Modules] envml

[Xavier D. <xav...@gm...>]

Thanks for the feedback, I have improved the description a bit.

Best regards,
Xavier

Le ven. 13 juin 2025 à 16:35, Paul Markfort <pau...@gm...> a écrit :
>
> It is a bash script (included with modules).
>
> So it starts a new process - then runs its commands - exiting when done.
>
> Alternatively, you could just write a bash script for the particular situation that loads modules and then runs a command.
>
>
> On 2025-06-13 6:50 AM, InfnPi wrote:
> > I read documentation, but don’t really understand it’s use.
> > What happens after the command is executed?
> > The loaded modules stay or they are just used to run the command and then unloaded?
> >
> > Would be nice to have a “real” usage example with environment before and after the command
> >
> > Roberto
> > On 13 Jun 2025 at 07:56 +0200, Xavier Delaruelle <xav...@gm...>, wrote:
> >> Dear All,
> >>
> >> Do you know the "envml" command?
> >>
> >> Like "env", it runs a program in a modified environment, but here
> >> environment is modified by Modules.
> >>
> >> "envml" is available since Modules 4.0 and it is freshly documented in
> >> its own man page:
> >> https://modules.readthedocs.io/en/latest/envml.html
> >>
> >> Best regards,
> >> Xavier
> >>
> >>
> >> _______________________________________________
> >> Modules-interest mailing list
> >> Mod...@li...
> >> https://lists.sourceforge.net/lists/listinfo/modules-interest
> >
> >
> >
> > _______________________________________________
> > Modules-interest mailing list
> > Mod...@li...
> > https://lists.sourceforge.net/lists/listinfo/modules-interest
> >
>
> --
> --------------------------------------------------------
> The views and opinions expressed above are strictly
> those of the author(s).  The content of this message has
> not been reviewed nor approved by any entity whatsoever.
> --------------------------------------------------------
> Paul FM         Info: http://paulfm.com/~paulfm/
> --------------------------------------------------------
>
>
> _______________________________________________
> Modules-interest mailing list
> Mod...@li...
> https://lists.sourceforge.net/lists/listinfo/modules-interest

Re: [Modules] envml

[Paul M. <pau...@gm...>]

It is a bash script (included with modules).

So it starts a new process - then runs its commands - exiting when done.

Alternatively, you could just write a bash script for the particular situation that loads modules and then runs a command.


On 2025-06-13 6:50 AM, InfnPi wrote:
> I read documentation, but don’t really understand it’s use.
> What happens after the command is executed?
> The loaded modules stay or they are just used to run the command and then unloaded?
> 
> Would be nice to have a “real” usage example with environment before and after the command
> 
> Roberto
> On 13 Jun 2025 at 07:56 +0200, Xavier Delaruelle <xav...@gm...>, wrote:
>> Dear All,
>>
>> Do you know the "envml" command?
>>
>> Like "env", it runs a program in a modified environment, but here
>> environment is modified by Modules.
>>
>> "envml" is available since Modules 4.0 and it is freshly documented in
>> its own man page:
>> https://modules.readthedocs.io/en/latest/envml.html
>>
>> Best regards,
>> Xavier
>>
>>
>> _______________________________________________
>> Modules-interest mailing list
>> Mod...@li...
>> https://lists.sourceforge.net/lists/listinfo/modules-interest
> 
> 
> 
> _______________________________________________
> Modules-interest mailing list
> Mod...@li...
> https://lists.sourceforge.net/lists/listinfo/modules-interest
> 

-- 
--------------------------------------------------------
The views and opinions expressed above are strictly
those of the author(s).  The content of this message has
not been reviewed nor approved by any entity whatsoever.
--------------------------------------------------------
Paul FM         Info: http://paulfm.com/~paulfm/
--------------------------------------------------------

Re: [Modules] envml

[InfnPi <rob...@pi...>]

I read documentation, but don’t really understand it’s use.
What happens after the command is executed?
The loaded modules stay or they are just used to run the command and then unloaded?

Would be nice to have a “real” usage example with environment before and after the command

Roberto
On 13 Jun 2025 at 07:56 +0200, Xavier Delaruelle <xav...@gm...>, wrote:
> Dear All,
>
> Do you know the "envml" command?
>
> Like "env", it runs a program in a modified environment, but here
> environment is modified by Modules.
>
> "envml" is available since Modules 4.0 and it is freshly documented in
> its own man page:
> https://modules.readthedocs.io/en/latest/envml.html
>
> Best regards,
> Xavier
>
>
> _______________________________________________
> Modules-interest mailing list
> Mod...@li...
> https://lists.sourceforge.net/lists/listinfo/modules-interest

[Modules] envml

[Xavier D. <xav...@gm...>]

Dear All,

Do you know the "envml" command?

Like "env", it runs a program in a modified environment, but here
environment is modified by Modules.

"envml" is available since Modules 4.0 and it is freshly documented in
its own man page:
  https://modules.readthedocs.io/en/latest/envml.html

Best regards,
Xavier

Re: [Modules] Modulefiles mode for Emacs

[Xavier D. <xav...@gm...>]

Hello Laurent,

I suggest you create a pull request on GitHub (fork+new
branch+push+create pull request). Add the new file into directory
"share/emacs".

Best regards,
Xavier

Le jeu. 12 juin 2025 à 13:51, Laurent BESSON
<lau...@ea...> a écrit :
>
> Hello Xavier, all
>
>
>
> I wrote a first version for a Modulefiles mode for Emacs. It relies on existing Tcl mode (tcl-mode) and adds highlighting for the Modulefiles commands.
>
>
>
> How can we proceed to make it available to anyone ? Do I create a new branch/fork from GitHub or do I send the file (only one, for the time being) directly to you for integration ?
>
> If anyone on the list wants to give it a try, I'll be happy to share 😊
>
>
>
>
>
> L.
>
>
>
> -----Message d'origine-----
> De : Xavier Delaruelle <xav...@gm...>
> Envoyé : mercredi 11 juin 2025 18:49
> À : Environment Modules usage and discussion. <mod...@li...>
> Objet : Re: [Modules] Modulefiles mode for Emacs
>
>
>
> Hello Laurent and All,
>
>
>
> That could be great stuff to contribute to the project. I am not an Emacs user, so I cannot help here. LLM may help but it requires someone with good enough Emacs knowledge to steer it.
>
>
>
> For Vim, we have already done this job. It is available within https://github.com/envmodules/modules/tree/main/share/vim.
>
>
>
> Best regards,
>
> Xavier
>
>
>
> Le mer. 11 juin 2025 à 11:58, Laurent BESSON <lau...@ea...> a écrit :
>
> >
>
> > Hello dear Modules list,
>
> >
>
> >
>
> >
>
> > I’m an old fashion guy and I’m still using Emacs as my favorite editor 😊. But I’m pretty sure I’m not the only one in this list.
>
> >
>
> >
>
> >
>
> > I was wondering if someone had developped a « mode » to colorize Modulefiles files ? or at least some setup to recognize Modulefiles and use tcl-mode automatically ?
>
> >
>
> >
>
> >
>
> > Best regards,
>
> >
>
> > Laurent.
>
> >
>
> > _______________________________________________
>
> > Modules-interest mailing list
>
> > Mod...@li...
>
> > https://lists.sourceforge.net/lists/listinfo/modules-interest
>
>
>
>
>
> _______________________________________________
>
> Modules-interest mailing list
>
> Mod...@li...
>
> https://lists.sourceforge.net/lists/listinfo/modules-interest
>
> _______________________________________________
> Modules-interest mailing list
> Mod...@li...
> https://lists.sourceforge.net/lists/listinfo/modules-interest

Re: [Modules] Modulefiles mode for Emacs

[Laurent B. <lau...@ea...>]

Hello Xavier, all



I wrote a first version for a Modulefiles mode for Emacs. It relies on existing Tcl mode (tcl-mode) and adds highlighting for the Modulefiles commands.



How can we proceed to make it available to anyone ? Do I create a new branch/fork from GitHub or do I send the file (only one, for the time being) directly to you for integration ?

If anyone on the list wants to give it a try, I'll be happy to share 😊





L.



-----Message d'origine-----
De : Xavier Delaruelle <xav...@gm...>
Envoyé : mercredi 11 juin 2025 18:49
À : Environment Modules usage and discussion. <mod...@li...>
Objet : Re: [Modules] Modulefiles mode for Emacs



Hello Laurent and All,



That could be great stuff to contribute to the project. I am not an Emacs user, so I cannot help here. LLM may help but it requires someone with good enough Emacs knowledge to steer it.



For Vim, we have already done this job. It is available within https://github.com/envmodules/modules/tree/main/share/vim.



Best regards,

Xavier



Le mer. 11 juin 2025 à 11:58, Laurent BESSON <lau...@ea...<mailto:lau...@ea...>> a écrit :

>

> Hello dear Modules list,

>

>

>

> I’m an old fashion guy and I’m still using Emacs as my favorite editor 😊. But I’m pretty sure I’m not the only one in this list.

>

>

>

> I was wondering if someone had developped a « mode » to colorize Modulefiles files ? or at least some setup to recognize Modulefiles and use tcl-mode automatically ?

>

>

>

> Best regards,

>

> Laurent.

>

> _______________________________________________

> Modules-interest mailing list

> Mod...@li...<mailto:Mod...@li...>

> https://lists.sourceforge.net/lists/listinfo/modules-interest





_______________________________________________

Modules-interest mailing list

Mod...@li...<mailto:Mod...@li...>

https://lists.sourceforge.net/lists/listinfo/modules-interest

Re: [Modules] Modulefiles mode for Emacs

[Xavier D. <xav...@gm...>]

Hello Laurent and All,

That could be great stuff to contribute to the project. I am not an
Emacs user, so I cannot help here. LLM may help but it requires
someone with good enough Emacs knowledge to steer it.

For Vim, we have already done this job. It is available within
https://github.com/envmodules/modules/tree/main/share/vim.

Best regards,
Xavier

Le mer. 11 juin 2025 à 11:58, Laurent BESSON
<lau...@ea...> a écrit :
>
> Hello dear Modules list,
>
>
>
> I’m an old fashion guy and I’m still using Emacs as my favorite editor 😊. But I’m pretty sure I’m not the only one in this list.
>
>
>
> I was wondering if someone had developped a « mode » to colorize Modulefiles files ? or at least some setup to recognize Modulefiles and use tcl-mode automatically ?
>
>
>
> Best regards,
>
> Laurent.
>
> _______________________________________________
> Modules-interest mailing list
> Mod...@li...
> https://lists.sourceforge.net/lists/listinfo/modules-interest

[Modules] Modulefiles mode for Emacs

[Laurent B. <lau...@ea...>]

Hello dear Modules list,

I’m an old fashion guy and I’m still using Emacs as my favorite editor 😊. But I’m pretty sure I’m not the only one in this list.

I was wondering if someone had developped a « mode » to colorize Modulefiles files ? or at least some setup to recognize Modulefiles and use tcl-mode automatically ?

Best regards,
Laurent.

[Modules] Support for newline character in environment variable value

[Xavier D. <xav...@gm...>]

Dear All,

Next version (5.6) will add the ability to define environment variable
whose value contains newline character:

https://modules.readthedocs.io/en/latest/MIGRATING.html#support-for-newline-character-in-environment-variable-value

Regards,
Xavier

Re: [Modules] Using variables inside a tcl command

[InfnPi <rob...@pi...>]

Thx

Roberto
On 2 Jun 2025 at 20:27 +0200, Xavier Delaruelle <xav...@gm...>, wrote:
> "colors" configuration option only contains key relative to items that
> are graphically rendered. But you may define these color items easily
> in your initrc configuration file:
>
> module config colors +red=1;31:green=1;32:yellow=1;33:blue=1;34
>
> Regards,
> Xavier
>
> Le lun. 2 juin 2025 à 09:00, InfnPi <rob...@pi...> a écrit :
> >
> > Indeed this seems the best option to me.
> > What would be nice, in order to make it usable site wide and out of the box, would be to define in colors some "standard" nicknames for colors like:
> > red=1;31:green=1;32:yellow=1;33:blue=1;34
> >
> > Roberto
> > On 30 May 2025 at 15:24 +0200, Xavier Delaruelle <xav...@gm...>, wrote:
> >
> > If you use Modules v5.2 or newer version, you may also rely on the
> > "sgr" internal procedure to render text graphically.
> >
> > First, you need to give access to this internal procedure within the
> > modulefile evaluation context. Add the following line in the
> > siteconfig.tcl script (usually installed in /etc/environment-modules):
> >
> > set modulefile_extra_cmds {sgr sgr}
> >
> > Two arguments should be given to sgr proc:
> >
> > sgr color_key text
> >
> > You may rely on the predefined color keys or add your own (through the
> > "colors" configuration option):
> >
> > $ ml config colors
> > Modules Release 5.5.0 (2024-11-11)
> >
> > - Config. name ---------.- Value (set by if default overridden) ---------------
> > colors
> > hi=1:db=2:tr=2:se=2:er=91:wa=93:me=95:in=94:mp=1;94:di=94:al=96:va=93:sy=95:de=4:cm=92:aL=100:L=90;47:H=2:F=41:nF=43:S=46:sS=44:kL=30;48;5;109
> >
> > For example, if you want the text to be rendered like warning message,
> > the modulefile will be:
> >
> > #%Module
> > module-whatis "This is an example using the [sgr wa XX] version"
> >
> > Another advantages to use "sgr" proc is that it does not graphically
> > render text if color mode is disabled by user.
> >
> > Regards,
> > Xavier
> >
> > Le ven. 30 mai 2025 à 14:48, InfnPi <rob...@pi...> a écrit :
> >
> >
> > So I finally managed (with the help of Xavier) to do what i wanted: Write some text to stderr using colors.
> >
> > Here is a simple script that defines and uses a procedure to print out red text using ANSI codes.
> > One thing to be careful about is that being the return value included in quotes (which get evaluated) you need to escape [ inside the return string.
> >
> > ---
> > #%Module
> >
> > proc Red {text} {
> > return "\033\[1;31m$text\033\[0m"
> > }
> >
> > module-whatis "This is an example using the [Red procedure] to color text."
> > ---
> >
> > Roberto
> >
> > Sent with Spark
> > On 29 May 2025 at 19:27 +0200, Xavier Delaruelle <xav...@gm...>, wrote:
> >
> > Hello Roberto,
> >
> > The syntax with double quotes is fine, you have no special character
> > in your text to escape:
> >
> > module-whatis "This module sets up software XXX $ver"
> >
> > You may use an internal variable to use this description at different places:
> >
> > set description "This module sets up software XXX $ver"
> > module-whatis $description
> > proc ModulesHelp {} {
> > puts stderr $::description
> > }
> >
> > For the color, I would use a "color" proc like you did, but I suggest
> > to directly use ANSI SGR code [1] rather calling for tput:
> >
> > return "\033\[1;31m$text\033\[0m"
> >
> > Regards
> > Xavier
> >
> > [1] https://en.wikipedia.org/wiki/ANSI_escape_code#Select_Graphic_Rendition_parameters
> >
> >
> > Le jeu. 29 mai 2025 à 10:32, InfnPi <rob...@pi...> a écrit :
> >
> >
> > Here we go with another question, due to my lack of tcl knowledge.
> >
> > What i would like to achieve is to be able to use variables in text printed to stderr inside a tcl command like module-whatis.
> >
> > Very often in modulefiles you have to refer to the same information in more than one place and therefore it is convenient to use a variable.
> >
> > as an example in a module installing tool XXX version YYY you write something like:
> >
> > module-whatis (This module sets up software XXX version YYY}
> >
> > and
> >
> > proc ModulesHelp {} {
> > puts stderr {This module sets up software XXX version YYY}
> > }
> >
> > Instead of writing "Version YYY" any times in different places it would be nice to be able to use:
> > set ver "Version YYY"
> > and then
> > module-whatis (This module sets up software XXX $ver}
> >
> > this would reduce errors and add maintainability to the modulefile, in the sense that if a new version ZZZ of software XXX comes out i would (probably) use the same modulefile just replacing a few general variables.
> >
> > Unfortunately in using
> > module-watis {This module sets up software XXX $ver} will not expand the variable $ver.
> >
> > A workaround i found is to write it in the following way:
> > module-whatis "This module sets up software XXX $ver"
> > which expands variables (but you have to escape special characters).
> >
> > Is this correct or does it have some unwanted consequences?
> >
> >
> > Along with this question there is a second one i would like to ask:
> >
> > Is there a way to print text to stderr using colors?
> >
> > I found a way to do it defining a procedure and some variables:
> >
> > proc color {color text} {
> > return [exec tput setaf $color]$text[exec tput sgr0]
> > }
> > set red 1
> > set green 2
> > set yellow 3
> > set blue 4
> >
> > and then in the module file i will use:
> > module-whatis "This module sets up software [color $green XXX] $ver"
> >
> > which will print XXX in green.
> >
> > Is there a native way to do the same?
> > Is it fine to use it in the way i described?
> >
> > Again, many thx in advance for all the answers.
> >
> > Roberto
> >
> >
> >
> > _______________________________________________
> > Modules-interest mailing list
> > Mod...@li...
> > https://lists.sourceforge.net/lists/listinfo/modules-interest
> >
> > _______________________________________________
> > Modules-interest mailing list
> > Mod...@li...
> > https://lists.sourceforge.net/lists/listinfo/modules-interest
> >
> >
> >
> > _______________________________________________
> > Modules-interest mailing list
> > Mod...@li...
> > https://lists.sourceforge.net/lists/listinfo/modules-interest
> >
> > _______________________________________________
> > Modules-interest mailing list
> > Mod...@li...
> > https://lists.sourceforge.net/lists/listinfo/modules-interest
>
>
> _______________________________________________
> Modules-interest mailing list
> Mod...@li...
> https://lists.sourceforge.net/lists/listinfo/modules-interest

Re: [Modules] Using variables inside a tcl command

[Xavier D. <xav...@gm...>]

"colors" configuration option only contains key relative to items that
are graphically rendered. But you may define these color items easily
in your initrc configuration file:

module config colors +red=1;31:green=1;32:yellow=1;33:blue=1;34

Regards,
Xavier

Le lun. 2 juin 2025 à 09:00, InfnPi <rob...@pi...> a écrit :
>
> Indeed this seems the best option to me.
> What would be nice, in order to make it usable site wide and out of the box, would be to define in colors some "standard" nicknames for colors like:
> red=1;31:green=1;32:yellow=1;33:blue=1;34
>
> Roberto
> On 30 May 2025 at 15:24 +0200, Xavier Delaruelle <xav...@gm...>, wrote:
>
> If you use Modules v5.2 or newer version, you may also rely on the
> "sgr" internal procedure to render text graphically.
>
> First, you need to give access to this internal procedure within the
> modulefile evaluation context. Add the following line in the
> siteconfig.tcl script (usually installed in /etc/environment-modules):
>
> set modulefile_extra_cmds {sgr sgr}
>
> Two arguments should be given to sgr proc:
>
> sgr color_key text
>
> You may rely on the predefined color keys or add your own (through the
> "colors" configuration option):
>
> $ ml config colors
> Modules Release 5.5.0 (2024-11-11)
>
> - Config. name ---------.- Value (set by if default overridden) ---------------
> colors
> hi=1:db=2:tr=2:se=2:er=91:wa=93:me=95:in=94:mp=1;94:di=94:al=96:va=93:sy=95:de=4:cm=92:aL=100:L=90;47:H=2:F=41:nF=43:S=46:sS=44:kL=30;48;5;109
>
> For example, if you want the text to be rendered like warning message,
> the modulefile will be:
>
> #%Module
> module-whatis "This is an example using the [sgr wa XX] version"
>
> Another advantages to use "sgr" proc is that it does not graphically
> render text if color mode is disabled by user.
>
> Regards,
> Xavier
>
> Le ven. 30 mai 2025 à 14:48, InfnPi <rob...@pi...> a écrit :
>
>
> So I finally managed (with the help of Xavier) to do what i wanted: Write some text to stderr using colors.
>
> Here is a simple script that defines and uses a procedure to print out red text using ANSI codes.
> One thing to be careful about is that being the return value included in quotes (which get evaluated) you need to escape [ inside the return string.
>
> ---
> #%Module
>
> proc Red {text} {
> return "\033\[1;31m$text\033\[0m"
> }
>
> module-whatis "This is an example using the [Red procedure] to color text."
> ---
>
> Roberto
>
> Sent with Spark
> On 29 May 2025 at 19:27 +0200, Xavier Delaruelle <xav...@gm...>, wrote:
>
> Hello Roberto,
>
> The syntax with double quotes is fine, you have no special character
> in your text to escape:
>
> module-whatis "This module sets up software XXX $ver"
>
> You may use an internal variable to use this description at different places:
>
> set description "This module sets up software XXX $ver"
> module-whatis $description
> proc ModulesHelp {} {
> puts stderr $::description
> }
>
> For the color, I would use a "color" proc like you did, but I suggest
> to directly use ANSI SGR code [1] rather calling for tput:
>
> return "\033\[1;31m$text\033\[0m"
>
> Regards
> Xavier
>
> [1] https://en.wikipedia.org/wiki/ANSI_escape_code#Select_Graphic_Rendition_parameters
>
>
> Le jeu. 29 mai 2025 à 10:32, InfnPi <rob...@pi...> a écrit :
>
>
> Here we go with another question, due to my lack of tcl knowledge.
>
> What i would like to achieve is to be able to use variables in text printed to stderr inside a tcl command like module-whatis.
>
> Very often in modulefiles you have to refer to the same information in more than one place and therefore it is convenient to use a variable.
>
> as an example in a module installing tool XXX version YYY you write something like:
>
> module-whatis (This module sets up software XXX version YYY}
>
> and
>
> proc ModulesHelp {} {
> puts stderr {This module sets up software XXX version YYY}
> }
>
> Instead of writing "Version YYY" any times in different places it would be nice to be able to use:
> set ver "Version YYY"
> and then
> module-whatis (This module sets up software XXX $ver}
>
> this would reduce errors and add maintainability to the modulefile, in the sense that if a new version ZZZ of software XXX comes out i would (probably) use the same modulefile just replacing a few general variables.
>
> Unfortunately in using
> module-watis {This module sets up software XXX $ver} will not expand the variable $ver.
>
> A workaround i found is to write it in the following way:
> module-whatis "This module sets up software XXX $ver"
> which expands variables (but you have to escape special characters).
>
> Is this correct or does it have some unwanted consequences?
>
>
> Along with this question there is a second one i would like to ask:
>
> Is there a way to print text to stderr using colors?
>
> I found a way to do it defining a procedure and some variables:
>
> proc color {color text} {
> return [exec tput setaf $color]$text[exec tput sgr0]
> }
> set red 1
> set green 2
> set yellow 3
> set blue 4
>
> and then in the module file i will use:
> module-whatis "This module sets up software [color $green XXX] $ver"
>
> which will print XXX in green.
>
> Is there a native way to do the same?
> Is it fine to use it in the way i described?
>
> Again, many thx in advance for all the answers.
>
> Roberto
>
>
>
> _______________________________________________
> Modules-interest mailing list
> Mod...@li...
> https://lists.sourceforge.net/lists/listinfo/modules-interest
>
> _______________________________________________
> Modules-interest mailing list
> Mod...@li...
> https://lists.sourceforge.net/lists/listinfo/modules-interest
>
>
>
> _______________________________________________
> Modules-interest mailing list
> Mod...@li...
> https://lists.sourceforge.net/lists/listinfo/modules-interest
>
> _______________________________________________
> Modules-interest mailing list
> Mod...@li...
> https://lists.sourceforge.net/lists/listinfo/modules-interest

Re: [Modules] Using variables inside a tcl command

[InfnPi <rob...@pi...>]

Indeed this seems the best option to me.
What would be nice, in order to make it usable site wide and out of the box, would be to define in colors some "standard" nicknames for colors like:
red=1;31:green=1;32:yellow=1;33:blue=1;34

Roberto
On 30 May 2025 at 15:24 +0200, Xavier Delaruelle <xav...@gm...>, wrote:
> If you use Modules v5.2 or newer version, you may also rely on the
> "sgr" internal procedure to render text graphically.
>
> First, you need to give access to this internal procedure within the
> modulefile evaluation context. Add the following line in the
> siteconfig.tcl script (usually installed in /etc/environment-modules):
>
> set modulefile_extra_cmds {sgr sgr}
>
> Two arguments should be given to sgr proc:
>
> sgr color_key text
>
> You may rely on the predefined color keys or add your own (through the
> "colors" configuration option):
>
> $ ml config colors
> Modules Release 5.5.0 (2024-11-11)
>
> - Config. name ---------.- Value (set by if default overridden) ---------------
> colors
> hi=1:db=2:tr=2:se=2:er=91:wa=93:me=95:in=94:mp=1;94:di=94:al=96:va=93:sy=95:de=4:cm=92:aL=100:L=90;47:H=2:F=41:nF=43:S=46:sS=44:kL=30;48;5;109
>
> For example, if you want the text to be rendered like warning message,
> the modulefile will be:
>
> #%Module
> module-whatis "This is an example using the [sgr wa XX] version"
>
> Another advantages to use "sgr" proc is that it does not graphically
> render text if color mode is disabled by user.
>
> Regards,
> Xavier
>
> Le ven. 30 mai 2025 à 14:48, InfnPi <rob...@pi...> a écrit :
> >
> > So I finally managed (with the help of Xavier) to do what i wanted: Write some text to stderr using colors.
> >
> > Here is a simple script that defines and uses a procedure to print out red text using ANSI codes.
> > One thing to be careful about is that being the return value included in quotes (which get evaluated) you need to escape [ inside the return string.
> >
> > ---
> > #%Module
> >
> > proc Red {text} {
> > return "\033\[1;31m$text\033\[0m"
> > }
> >
> > module-whatis "This is an example using the [Red procedure] to color text."
> > ---
> >
> > Roberto
> >
> > Sent with Spark
> > On 29 May 2025 at 19:27 +0200, Xavier Delaruelle <xav...@gm...>, wrote:
> >
> > Hello Roberto,
> >
> > The syntax with double quotes is fine, you have no special character
> > in your text to escape:
> >
> > module-whatis "This module sets up software XXX $ver"
> >
> > You may use an internal variable to use this description at different places:
> >
> > set description "This module sets up software XXX $ver"
> > module-whatis $description
> > proc ModulesHelp {} {
> > puts stderr $::description
> > }
> >
> > For the color, I would use a "color" proc like you did, but I suggest
> > to directly use ANSI SGR code [1] rather calling for tput:
> >
> > return "\033\[1;31m$text\033\[0m"
> >
> > Regards
> > Xavier
> >
> > [1] https://en.wikipedia.org/wiki/ANSI_escape_code#Select_Graphic_Rendition_parameters
> >
> >
> > Le jeu. 29 mai 2025 à 10:32, InfnPi <rob...@pi...> a écrit :
> >
> >
> > Here we go with another question, due to my lack of tcl knowledge.
> >
> > What i would like to achieve is to be able to use variables in text printed to stderr inside a tcl command like module-whatis.
> >
> > Very often in modulefiles you have to refer to the same information in more than one place and therefore it is convenient to use a variable.
> >
> > as an example in a module installing tool XXX version YYY you write something like:
> >
> > module-whatis (This module sets up software XXX version YYY}
> >
> > and
> >
> > proc ModulesHelp {} {
> > puts stderr {This module sets up software XXX version YYY}
> > }
> >
> > Instead of writing "Version YYY" any times in different places it would be nice to be able to use:
> > set ver "Version YYY"
> > and then
> > module-whatis (This module sets up software XXX $ver}
> >
> > this would reduce errors and add maintainability to the modulefile, in the sense that if a new version ZZZ of software XXX comes out i would (probably) use the same modulefile just replacing a few general variables.
> >
> > Unfortunately in using
> > module-watis {This module sets up software XXX $ver} will not expand the variable $ver.
> >
> > A workaround i found is to write it in the following way:
> > module-whatis "This module sets up software XXX $ver"
> > which expands variables (but you have to escape special characters).
> >
> > Is this correct or does it have some unwanted consequences?
> >
> >
> > Along with this question there is a second one i would like to ask:
> >
> > Is there a way to print text to stderr using colors?
> >
> > I found a way to do it defining a procedure and some variables:
> >
> > proc color {color text} {
> > return [exec tput setaf $color]$text[exec tput sgr0]
> > }
> > set red 1
> > set green 2
> > set yellow 3
> > set blue 4
> >
> > and then in the module file i will use:
> > module-whatis "This module sets up software [color $green XXX] $ver"
> >
> > which will print XXX in green.
> >
> > Is there a native way to do the same?
> > Is it fine to use it in the way i described?
> >
> > Again, many thx in advance for all the answers.
> >
> > Roberto
> >
> >
> >
> > _______________________________________________
> > Modules-interest mailing list
> > Mod...@li...
> > https://lists.sourceforge.net/lists/listinfo/modules-interest
> >
> > _______________________________________________
> > Modules-interest mailing list
> > Mod...@li...
> > https://lists.sourceforge.net/lists/listinfo/modules-interest
>
>
> _______________________________________________
> Modules-interest mailing list
> Mod...@li...
> https://lists.sourceforge.net/lists/listinfo/modules-interest

Re: [Modules] Using variables inside a tcl command

[Xavier D. <xav...@gm...>]

If you use Modules v5.2 or newer version, you may also rely on the
"sgr" internal procedure to render text graphically.

First, you need to give access to this internal procedure within the
modulefile evaluation context. Add the following line in the
siteconfig.tcl script (usually installed in /etc/environment-modules):

set modulefile_extra_cmds {sgr sgr}

Two arguments should be given to sgr proc:

sgr color_key text

You may rely on the predefined color keys or add your own (through the
"colors" configuration option):

$ ml config colors
Modules Release 5.5.0 (2024-11-11)

- Config. name ---------.- Value (set by if default overridden) ---------------
colors
hi=1:db=2:tr=2:se=2:er=91:wa=93:me=95:in=94:mp=1;94:di=94:al=96:va=93:sy=95:de=4:cm=92:aL=100:L=90;47:H=2:F=41:nF=43:S=46:sS=44:kL=30;48;5;109

For example, if you want the text to be rendered like warning message,
the modulefile will be:

#%Module
module-whatis "This is an example using the [sgr wa XX] version"

Another advantages to use "sgr" proc is that it does not graphically
render text if color mode is disabled by user.

Regards,
Xavier

Le ven. 30 mai 2025 à 14:48, InfnPi <rob...@pi...> a écrit :
>
> So I finally managed (with the help of Xavier) to do what i wanted: Write some text to stderr using colors.
>
> Here is a simple script that defines and uses a procedure to print out red text using ANSI codes.
> One thing to be careful about is that being the return value included in quotes (which get evaluated) you need to escape [ inside the return string.
>
> ---
> #%Module
>
> proc Red {text} {
>    return "\033\[1;31m$text\033\[0m"
> }
>
> module-whatis "This is an example using the [Red procedure] to color text."
> ---
>
> Roberto
>
> Sent with Spark
> On 29 May 2025 at 19:27 +0200, Xavier Delaruelle <xav...@gm...>, wrote:
>
> Hello Roberto,
>
> The syntax with double quotes is fine, you have no special character
> in your text to escape:
>
> module-whatis "This module sets up software XXX $ver"
>
> You may use an internal variable to use this description at different places:
>
> set description "This module sets up software XXX $ver"
> module-whatis $description
> proc ModulesHelp {} {
> puts stderr $::description
> }
>
> For the color, I would use a "color" proc like you did, but I suggest
> to directly use ANSI SGR code [1] rather calling for tput:
>
> return "\033\[1;31m$text\033\[0m"
>
> Regards
> Xavier
>
> [1] https://en.wikipedia.org/wiki/ANSI_escape_code#Select_Graphic_Rendition_parameters
>
>
> Le jeu. 29 mai 2025 à 10:32, InfnPi <rob...@pi...> a écrit :
>
>
> Here we go with another question, due to my lack of tcl knowledge.
>
> What i would like to achieve is to be able to use variables in text printed to stderr inside a tcl command like module-whatis.
>
> Very often in modulefiles you have to refer to the same information in more than one place and therefore it is convenient to use a variable.
>
> as an example in a module installing tool XXX version YYY you write something like:
>
> module-whatis (This module sets up software XXX version YYY}
>
> and
>
> proc ModulesHelp {} {
> puts stderr {This module sets up software XXX version YYY}
> }
>
> Instead of writing "Version YYY" any times in different places it would be nice to be able to use:
> set ver "Version YYY"
> and then
> module-whatis (This module sets up software XXX $ver}
>
> this would reduce errors and add maintainability to the modulefile, in the sense that if a new version ZZZ of software XXX comes out i would (probably) use the same modulefile just replacing a few general variables.
>
> Unfortunately in using
> module-watis {This module sets up software XXX $ver} will not expand the variable $ver.
>
> A workaround i found is to write it in the following way:
> module-whatis "This module sets up software XXX $ver"
> which expands variables (but you have to escape special characters).
>
> Is this correct or does it have some unwanted consequences?
>
>
> Along with this question there is a second one i would like to ask:
>
> Is there a way to print text to stderr using colors?
>
> I found a way to do it defining a procedure and some variables:
>
> proc color {color text} {
> return [exec tput setaf $color]$text[exec tput sgr0]
> }
> set red 1
> set green 2
> set yellow 3
> set blue 4
>
> and then in the module file i will use:
> module-whatis "This module sets up software [color $green XXX] $ver"
>
> which will print XXX in green.
>
> Is there a native way to do the same?
> Is it fine to use it in the way i described?
>
> Again, many thx in advance for all the answers.
>
> Roberto
>
>
>
> _______________________________________________
> Modules-interest mailing list
> Mod...@li...
> https://lists.sourceforge.net/lists/listinfo/modules-interest
>
> _______________________________________________
> Modules-interest mailing list
> Mod...@li...
> https://lists.sourceforge.net/lists/listinfo/modules-interest

Re: [Modules] Using variables inside a tcl command

[InfnPi <rob...@pi...>]

So I finally managed (with the help of Xavier) to do what i wanted: Write some text to stderr using colors.

Here is a simple script that defines and uses a procedure to print out red text using ANSI codes.
One thing to be careful about is that being the return value included in quotes (which get evaluated) you need to escape [ inside the return string.

---
#%Module

proc Red {text} {
   return "\033\[1;31m$text\033\[0m"
}

module-whatis "This is an example using the [Red procedure] to color text."
---

Roberto

Sent with Spark
On 29 May 2025 at 19:27 +0200, Xavier Delaruelle <xav...@gm...>, wrote:
> Hello Roberto,
>
> The syntax with double quotes is fine, you have no special character
> in your text to escape:
>
> module-whatis "This module sets up software XXX $ver"
>
> You may use an internal variable to use this description at different places:
>
> set description "This module sets up software XXX $ver"
> module-whatis $description
> proc ModulesHelp {} {
> puts stderr $::description
> }
>
> For the color, I would use a "color" proc like you did, but I suggest
> to directly use ANSI SGR code [1] rather calling for tput:
>
> return "\033\[1;31m$text\033\[0m"
>
> Regards
> Xavier
>
> [1] https://en.wikipedia.org/wiki/ANSI_escape_code#Select_Graphic_Rendition_parameters
>
>
> Le jeu. 29 mai 2025 à 10:32, InfnPi <rob...@pi...> a écrit :
> >
> > Here we go with another question, due to my lack of tcl knowledge.
> >
> > What i would like to achieve is to be able to use variables in text printed to stderr inside a tcl command like module-whatis.
> >
> > Very often in modulefiles you have to refer to the same information in more than one place and therefore it is convenient to use a variable.
> >
> > as an example in a module installing tool XXX version YYY you write something like:
> >
> > module-whatis (This module sets up software XXX version YYY}
> >
> > and
> >
> > proc ModulesHelp {} {
> > puts stderr {This module sets up software XXX version YYY}
> > }
> >
> > Instead of writing "Version YYY" any times in different places it would be nice to be able to use:
> > set ver "Version YYY"
> > and then
> > module-whatis (This module sets up software XXX $ver}
> >
> > this would reduce errors and add maintainability to the modulefile, in the sense that if a new version ZZZ of software XXX comes out i would (probably) use the same modulefile just replacing a few general variables.
> >
> > Unfortunately in using
> > module-watis {This module sets up software XXX $ver} will not expand the variable $ver.
> >
> > A workaround i found is to write it in the following way:
> > module-whatis "This module sets up software XXX $ver"
> > which expands variables (but you have to escape special characters).
> >
> > Is this correct or does it have some unwanted consequences?
> >
> >
> > Along with this question there is a second one i would like to ask:
> >
> > Is there a way to print text to stderr using colors?
> >
> > I found a way to do it defining a procedure and some variables:
> >
> > proc color {color text} {
> > return [exec tput setaf $color]$text[exec tput sgr0]
> > }
> > set red 1
> > set green 2
> > set yellow 3
> > set blue 4
> >
> > and then in the module file i will use:
> > module-whatis "This module sets up software [color $green XXX] $ver"
> >
> > which will print XXX in green.
> >
> > Is there a native way to do the same?
> > Is it fine to use it in the way i described?
> >
> > Again, many thx in advance for all the answers.
> >
> > Roberto
>
>
> _______________________________________________
> Modules-interest mailing list
> Mod...@li...
> https://lists.sourceforge.net/lists/listinfo/modules-interest

Re: [Modules] Using variables inside a tcl command

[InfnPi <rob...@pi...>]

Many thx!

Roberto
On 29 May 2025 at 19:27 +0200, Xavier Delaruelle <xav...@gm...>, wrote:
> Hello Roberto,
>
> The syntax with double quotes is fine, you have no special character
> in your text to escape:
>
> module-whatis "This module sets up software XXX $ver"
>
> You may use an internal variable to use this description at different places:
>
> set description "This module sets up software XXX $ver"
> module-whatis $description
> proc ModulesHelp {} {
> puts stderr $::description
> }
>
> For the color, I would use a "color" proc like you did, but I suggest
> to directly use ANSI SGR code [1] rather calling for tput:
>
> return "\033\[1;31m$text\033\[0m"
>
> Regards
> Xavier
>
> [1] https://en.wikipedia.org/wiki/ANSI_escape_code#Select_Graphic_Rendition_parameters
>
>
> Le jeu. 29 mai 2025 à 10:32, InfnPi <rob...@pi...> a écrit :
> >
> > Here we go with another question, due to my lack of tcl knowledge.
> >
> > What i would like to achieve is to be able to use variables in text printed to stderr inside a tcl command like module-whatis.
> >
> > Very often in modulefiles you have to refer to the same information in more than one place and therefore it is convenient to use a variable.
> >
> > as an example in a module installing tool XXX version YYY you write something like:
> >
> > module-whatis (This module sets up software XXX version YYY}
> >
> > and
> >
> > proc ModulesHelp {} {
> > puts stderr {This module sets up software XXX version YYY}
> > }
> >
> > Instead of writing "Version YYY" any times in different places it would be nice to be able to use:
> > set ver "Version YYY"
> > and then
> > module-whatis (This module sets up software XXX $ver}
> >
> > this would reduce errors and add maintainability to the modulefile, in the sense that if a new version ZZZ of software XXX comes out i would (probably) use the same modulefile just replacing a few general variables.
> >
> > Unfortunately in using
> > module-watis {This module sets up software XXX $ver} will not expand the variable $ver.
> >
> > A workaround i found is to write it in the following way:
> > module-whatis "This module sets up software XXX $ver"
> > which expands variables (but you have to escape special characters).
> >
> > Is this correct or does it have some unwanted consequences?
> >
> >
> > Along with this question there is a second one i would like to ask:
> >
> > Is there a way to print text to stderr using colors?
> >
> > I found a way to do it defining a procedure and some variables:
> >
> > proc color {color text} {
> > return [exec tput setaf $color]$text[exec tput sgr0]
> > }
> > set red 1
> > set green 2
> > set yellow 3
> > set blue 4
> >
> > and then in the module file i will use:
> > module-whatis "This module sets up software [color $green XXX] $ver"
> >
> > which will print XXX in green.
> >
> > Is there a native way to do the same?
> > Is it fine to use it in the way i described?
> >
> > Again, many thx in advance for all the answers.
> >
> > Roberto
>
>
> _______________________________________________
> Modules-interest mailing list
> Mod...@li...
> https://lists.sourceforge.net/lists/listinfo/modules-interest

Re: [Modules] Using variables inside a tcl command

[Xavier D. <xav...@gm...>]

Hello Roberto,

The syntax with double quotes is fine, you have no special character
in your text to escape:

module-whatis "This module sets up software XXX $ver"

You may use an internal variable to use this description at different places:

set description "This module sets up software XXX $ver"
module-whatis $description
proc ModulesHelp {} {
    puts stderr $::description
}

For the color, I would use a "color" proc like you did, but I suggest
to directly use ANSI SGR code [1] rather calling for tput:

return "\033\[1;31m$text\033\[0m"

Regards
Xavier

[1] https://en.wikipedia.org/wiki/ANSI_escape_code#Select_Graphic_Rendition_parameters


Le jeu. 29 mai 2025 à 10:32, InfnPi <rob...@pi...> a écrit :
>
> Here we go with another question, due to my lack of tcl knowledge.
>
> What i would like to achieve is to be able to use variables in text printed to stderr inside a tcl command like module-whatis.
>
> Very often in modulefiles you have to refer to the same information in more than one place and therefore it is convenient to use a variable.
>
> as an example in a module installing tool XXX version YYY you write something like:
>
> module-whatis (This module sets up software XXX version YYY}
>
> and
>
> proc ModulesHelp {} {
> puts stderr {This module sets up software XXX version YYY}
> }
>
> Instead of writing "Version YYY" any times in different places it would be nice to be able to use:
> set ver "Version YYY"
> and then
> module-whatis (This module sets up software XXX $ver}
>
> this would reduce errors and add maintainability to the modulefile, in the sense that if a new version ZZZ of software XXX comes out i would (probably) use the same modulefile just replacing a few general variables.
>
> Unfortunately in using
> module-watis {This module sets up software XXX $ver} will not expand the variable $ver.
>
> A workaround i found is to write it in the following way:
> module-whatis "This module sets up software XXX $ver"
> which expands variables (but you have to escape special characters).
>
> Is this correct or does it have some unwanted consequences?
>
>
> Along with this question there is a second one i would like to ask:
>
> Is there a way to print text to stderr using colors?
>
> I found a way to do it defining a procedure and some variables:
>
> proc color {color text} {
>    return [exec tput setaf $color]$text[exec tput sgr0]
> }
> set red 1
> set green 2
> set yellow 3
> set blue 4
>
> and then in the module file i will use:
> module-whatis "This module sets up software [color $green XXX] $ver"
>
> which will print XXX in green.
>
> Is there a native way to do the same?
> Is it fine to use it in the way i described?
>
> Again, many thx in advance for all the answers.
>
> Roberto

[Modules] Using variables inside a tcl command

[InfnPi <rob...@pi...>]

Here we go with another question, due to my lack of tcl knowledge.

What i would like to achieve is to be able to use variables in text printed to stderr inside a tcl command like module-whatis.

Very often in modulefiles you have to refer to the same information in more than one place and therefore it is convenient to use a variable.

as an example in a module installing tool XXX version YYY you write something like:

module-whatis (This module sets up software XXX version YYY}

and

proc ModulesHelp {} {
puts stderr {This module sets up software XXX version YYY}
}

Instead of writing "Version YYY" any times in different places it would be nice to be able to use:
set ver "Version YYY"
and then
module-whatis (This module sets up software XXX $ver}

this would reduce errors and add maintainability to the modulefile, in the sense that if a new version ZZZ of software XXX comes out i would (probably) use the same modulefile just replacing a few general variables.

Unfortunately in using
module-watis {This module sets up software XXX $ver} will not expand the variable $ver.

A workaround i found is to write it in the following way:
module-whatis "This module sets up software XXX $ver"
which expands variables (but you have to escape special characters).

Is this correct or does it have some unwanted consequences?


Along with this question there is a second one i would like to ask:

Is there a way to print text to stderr using colors?

I found a way to do it defining a procedure and some variables:

proc color {color text} {
   return [exec tput setaf $color]$text[exec tput sgr0]
}
set red 1
set green 2
set yellow 3
set blue 4

and then in the module file i will use:
module-whatis "This module sets up software [color $green XXX] $ver"

which will print XXX in green.

Is there a native way to do the same?
Is it fine to use it in the way i described?

Again, many thx in advance for all the answers.

Roberto

Re: [Modules] Executing external script in modules

[InfnPi <rob...@pi...>]

Thank you so much!
It worked perfectly.

Roberto
On 27 May 2025 at 20:56 +0200, Kirker, Ian <i.k...@uc...>, wrote:
> Roberto,
>
> You can do this with an [exec my_script.sh] call inside a [module-info mode load] check, but as a slightly alternative approach, we have some modules in our setup that do something like this entirely in Tcl.
>
> We have a small library of procedures to do things like this here: https://github.com/UCL-ARC/UsefulModuleFunctions
>
> Which, as an example, are used by: https://github.com/UCL-ARC/rcps-modulefiles/blob/master/applications/ansys/2024.r1
>
> The createDir procedure does the kind of thing it sounds like you want to do, but also check out the getDirFreeSpace procedure to see an example of running an external command.
>
> -Ian Kirker
>
>
> > On 27 May 2025, at 17:39, InfnPi <rob...@pi...> wrote:
> >
> > ⚠ Caution: External sender
> >
> > Hi,
> >    I have a (probably) stupid question.
> >
> > I would linke to set-up an user environment for a certain project for users and then configure it accordingly.
> >
> > The setup phase is usually done once and involves running a script which makes some changes to the filesystem.
> > Typically i will create some "standard" directory structures and link some files/directories to this structure.
> >
> > Once the setup is complete, i need to configure the environment for using it.
> >
> > This second part is easily dome with modules but i was wondering if there is any way to execute a script (that does not have environment settings) to check if a particular directory structure is in place.
> > If it is not there it will create it, otherwise it will just skip it and proceed to the configuration part.
> >
> > Of course this first part would have just to be executed on a module load command and should not be reverted by a module unload or switch command.
> >
> > Something like:
> > exec-shell-script bash ./path/to/script/Create.sh
> > (instead of bash it could be anything like another shell, a python script or even a program written by the user)
> >
> > followed by some standard modulefile commands that set user environment variables.
> >
> > A user would then alway call a single modulefile regardless of the fact that the directory structure is already in place.
> >
> > Something like:
> > module load setup/ProjectXXX
> >
> > If it is the first time it is run it will create the complete directory structure (with directories, links etc) and then setup the environment variables (tools, licenses, paths etc)
> > If the user runs it a second time the script would still be executed but being the directory structure already in place it would just skip that part (this is handled by the script itself) and go to the environment configuration part.
> >
> > Of course, in case of a:
> > module unload setup/ProjectXXX
> > only the environment part would be undone and the whole directory structure would stay as before.
> >
> > Of course this procedure has not to be a one step solution but it could well be one that reguires loading two different modules,
> > the first one that creates/checks the structure and a second one that configures the environment.
> >
> > I tried to look if this is possible but did not find a solution.
> >
> > Many thx in advance,
> >     Roberto
> > _______________________________________________
> > Modules-interest mailing list
> > Mod...@li...
> > https://lists.sourceforge.net/lists/listinfo/modules-interest
>
> _______________________________________________
> Modules-interest mailing list
> Mod...@li...
> https://lists.sourceforge.net/lists/listinfo/modules-interest

Re: [Modules] Executing external script in modules

[InfnPi <rob...@pi...>]

Thank you so much, will definitely look into this!

Roberto
On 27 May 2025 at 20:56 +0200, Kirker, Ian <i.k...@uc...>, wrote:
> Roberto,
>
> You can do this with an [exec my_script.sh] call inside a [module-info mode load] check, but as a slightly alternative approach, we have some modules in our setup that do something like this entirely in Tcl.
>
> We have a small library of procedures to do things like this here: https://github.com/UCL-ARC/UsefulModuleFunctions
>
> Which, as an example, are used by: https://github.com/UCL-ARC/rcps-modulefiles/blob/master/applications/ansys/2024.r1
>
> The createDir procedure does the kind of thing it sounds like you want to do, but also check out the getDirFreeSpace procedure to see an example of running an external command.
>
> -Ian Kirker
>
>
> > On 27 May 2025, at 17:39, InfnPi <rob...@pi...> wrote:
> >
> > ⚠ Caution: External sender
> >
> > Hi,
> >    I have a (probably) stupid question.
> >
> > I would linke to set-up an user environment for a certain project for users and then configure it accordingly.
> >
> > The setup phase is usually done once and involves running a script which makes some changes to the filesystem.
> > Typically i will create some "standard" directory structures and link some files/directories to this structure.
> >
> > Once the setup is complete, i need to configure the environment for using it.
> >
> > This second part is easily dome with modules but i was wondering if there is any way to execute a script (that does not have environment settings) to check if a particular directory structure is in place.
> > If it is not there it will create it, otherwise it will just skip it and proceed to the configuration part.
> >
> > Of course this first part would have just to be executed on a module load command and should not be reverted by a module unload or switch command.
> >
> > Something like:
> > exec-shell-script bash ./path/to/script/Create.sh
> > (instead of bash it could be anything like another shell, a python script or even a program written by the user)
> >
> > followed by some standard modulefile commands that set user environment variables.
> >
> > A user would then alway call a single modulefile regardless of the fact that the directory structure is already in place.
> >
> > Something like:
> > module load setup/ProjectXXX
> >
> > If it is the first time it is run it will create the complete directory structure (with directories, links etc) and then setup the environment variables (tools, licenses, paths etc)
> > If the user runs it a second time the script would still be executed but being the directory structure already in place it would just skip that part (this is handled by the script itself) and go to the environment configuration part.
> >
> > Of course, in case of a:
> > module unload setup/ProjectXXX
> > only the environment part would be undone and the whole directory structure would stay as before.
> >
> > Of course this procedure has not to be a one step solution but it could well be one that reguires loading two different modules,
> > the first one that creates/checks the structure and a second one that configures the environment.
> >
> > I tried to look if this is possible but did not find a solution.
> >
> > Many thx in advance,
> >     Roberto
> > _______________________________________________
> > Modules-interest mailing list
> > Mod...@li...
> > https://lists.sourceforge.net/lists/listinfo/modules-interest
>
> _______________________________________________
> Modules-interest mailing list
> Mod...@li...
> https://lists.sourceforge.net/lists/listinfo/modules-interest

Re: [Modules] Executing external script in modules

[Kirker, I. <i.k...@uc...>]

Roberto,

You can do this with an [exec my_script.sh] call inside a [module-info mode load] check, but as a slightly alternative approach, we have some modules in our setup that do something like this entirely in Tcl.

We have a small library of procedures to do things like this here: https://github.com/UCL-ARC/UsefulModuleFunctions

Which, as an example, are used by: https://github.com/UCL-ARC/rcps-modulefiles/blob/master/applications/ansys/2024.r1

The createDir procedure does the kind of thing it sounds like you want to do, but also check out the getDirFreeSpace procedure to see an example of running an external command.

-Ian Kirker


On 27 May 2025, at 17:39, InfnPi <rob...@pi...> wrote:


⚠ Caution: External sender

Hi,
   I have a (probably) stupid question.

I would linke to set-up an user environment for a certain project for users and then configure it accordingly.

The setup phase is usually done once and involves running a script which makes some changes to the filesystem.
Typically i will create some "standard" directory structures and link some files/directories to this structure.

Once the setup is complete, i need to configure the environment for using it.

This second part is easily dome with modules but i was wondering if there is any way to execute a script (that does not have environment settings) to check if a particular directory structure is in place.
If it is not there it will create it, otherwise it will just skip it and proceed to the configuration part.

Of course this first part would have just to be executed on a module load command and should not be reverted by a module unload or switch command.

Something like:
exec-shell-script bash ./path/to/script/Create.sh<https://create.sh/>
(instead of bash it could be anything like another shell, a python script or even a program written by the user)

followed by some standard modulefile commands that set user environment variables.

A user would then alway call a single modulefile regardless of the fact that the directory structure is already in place.

Something like:
module load setup/ProjectXXX

If it is the first time it is run it will create the complete directory structure (with directories, links etc) and then setup the environment variables (tools, licenses, paths etc)
If the user runs it a second time the script would still be executed but being the directory structure already in place it would just skip that part (this is handled by the script itself) and go to the environment configuration part.

Of course, in case of a:
module unload setup/ProjectXXX
only the environment part would be undone and the whole directory structure would stay as before.

Of course this procedure has not to be a one step solution but it could well be one that reguires loading two different modules,
the first one that creates/checks the structure and a second one that configures the environment.

I tried to look if this is possible but did not find a solution.

Many thx in advance,
    Roberto
_______________________________________________
Modules-interest mailing list
Mod...@li...
https://lists.sourceforge.net/lists/listinfo/modules-interest

Re: [Modules] Executing external script in modules

[InfnPi <rob...@pi...>]

Thx for the suggestion.

Before asking I tried briefly but without success.
I was not even able to run a simple
mkdir -p /some/path

That’s why I asked here.

Of course I will try again following your suggestions!

Roberto

Sent with Spark
On 27 May 2025 at 19:04 +0200, Paul Markfort <pau...@gm...>, wrote:
> module scripts are also tclsh scripts.
>
> You would probably use the tcl exec command:
> https://www.tcl-lang.org/man/tcl/TclCmd/exec.html#M3
>
> Make sure that you redirect stdout, as stdout will be evaluated by the shell calling modules (which could result in strange behavior from your module script).
>
> You would put this in an
> if {[module-info mode load]} {
> block (so it is only invoked on load)
>
> NOTE: there may be other module states you may want to run it under as well (see: man modulefile, for more info on "module-info mode").
>
>
>
> On 2025-05-27 11:39 AM, InfnPi wrote:
> > Hi,
> >    I have a (probably) stupid question.
> >
> > I would linke to set-up an user environment for a certain project for users and then configure it accordingly.
> >
> > The setup phase is usually done once and involves running a script which makes some changes to the filesystem.
> > Typically i will create some "standard" directory structures and link some files/directories to this structure.
> >
> > Once the setup is complete, i need to configure the environment for using it.
> >
> > This second part is easily dome with modules but i was wondering if there is any way to execute a script (that does not have environment settings) to check if a particular directory structure is in place.
> > If it is not there it will create it, otherwise it will just skip it and proceed to the configuration part.
> >
> > Of course this first part would have just to be executed on a module load command and should not be reverted by a module unload or switch command.
> >
> > Something like:
> > exec-shell-script bash ./path/to/script/Create.sh
> > (instead of bash it could be anything like another shell, a python script or even a program written by the user)
> >
> > followed by some standard modulefile commands that set user environment variables.
> >
> > A user would then alway call a single modulefile regardless of the fact that the directory structure is already in place.
> >
> > Something like:
> > module load setup/ProjectXXX
> >
> > If it is the first time it is run it will create the complete directory structure (with directories, links etc) and then setup the environment variables (tools, licenses, paths etc)
> > If the user runs it a second time the script would still be executed but being the directory structure already in place it would just skip that part (this is handled by the script itself) and go to the environment configuration part.
> >
> > Of course, in case of a:
> > module unload setup/ProjectXXX
> > only the environment part would be undone and the whole directory structure would stay as before.
> >
> > Of course this procedure has not to be a one step solution but it could well be one that reguires loading two different modules,
> > the first one that creates/checks the structure and a second one that configures the environment.
> >
> > I tried to look if this is possible but did not find a solution.
> >
> > Many thx in advance,
> >     Roberto
> >
> >
> >
> > _______________________________________________
> > Modules-interest mailing list
> > Mod...@li...
> > https://lists.sourceforge.net/lists/listinfo/modules-interest
> >
>
> --
> --------------------------------------------------------
> The views and opinions expressed above are strictly
> those of the author(s). The content of this message has
> not been reviewed nor approved by any entity whatsoever.
> --------------------------------------------------------
> Paul FM Info: http://paulfm.com/~paulfm/
> --------------------------------------------------------
>
>
> _______________________________________________
> Modules-interest mailing list
> Mod...@li...
> https://lists.sourceforge.net/lists/listinfo/modules-interest

Re: [Modules] Executing external script in modules

[Paul M. <pau...@gm...>]

module scripts are also tclsh scripts.

You would probably use the tcl exec command:
https://www.tcl-lang.org/man/tcl/TclCmd/exec.html#M3

Make sure that you redirect stdout, as stdout will be evaluated by the shell calling modules (which could result in strange behavior from your module script).

You would put this in an
if {[module-info mode load]} {
block (so it is only invoked on load)

NOTE: there may be other module states you may want to run it under as well (see: man modulefile, for more info on "module-info mode").



On 2025-05-27 11:39 AM, InfnPi wrote:
> Hi,
>     I have a (probably) stupid question.
> 
> I would linke to set-up an user environment for a certain project for users and then configure it accordingly.
> 
> The setup phase is usually done once and involves running a script which makes some changes to the filesystem.
> Typically i will create some "standard" directory structures and link some files/directories to this structure.
> 
> Once the setup is complete, i need to configure the environment for using it.
> 
> This second part is easily dome with modules but i was wondering if there is any way to execute a script (that does not have environment settings) to check if a particular directory structure is in place.
> If it is not there it will create it, otherwise it will just skip it and proceed to the configuration part.
> 
> Of course this first part would have just to be executed on a module load command and should not be reverted by a module unload or switch command.
> 
> Something like:
> exec-shell-script bash ./path/to/script/Create.sh
> (instead of bash it could be anything like another shell, a python script or even a program written by the user)
> 
> followed by some standard modulefile commands that set user environment variables.
> 
> A user would then alway call a single modulefile regardless of the fact that the directory structure is already in place.
> 
> Something like:
> module load setup/ProjectXXX
> 
> If it is the first time it is run it will create the complete directory structure (with directories, links etc) and then setup the environment variables (tools, licenses, paths etc)
> If the user runs it a second time the script would still be executed but being the directory structure already in place it would just skip that part (this is handled by the script itself) and go to the environment configuration part.
> 
> Of course, in case of a:
> module unload setup/ProjectXXX
> only the environment part would be undone and the whole directory structure would stay as before.
> 
> Of course this procedure has not to be a one step solution but it could well be one that reguires loading two different modules,
> the first one that creates/checks the structure and a second one that configures the environment.
> 
> I tried to look if this is possible but did not find a solution.
> 
> Many thx in advance,
>      Roberto
> 
> 
> 
> _______________________________________________
> Modules-interest mailing list
> Mod...@li...
> https://lists.sourceforge.net/lists/listinfo/modules-interest
> 

-- 
--------------------------------------------------------
The views and opinions expressed above are strictly
those of the author(s).  The content of this message has
not been reviewed nor approved by any entity whatsoever.
--------------------------------------------------------
Paul FM         Info: http://paulfm.com/~paulfm/
--------------------------------------------------------

[Modules] Executing external script in modules

[InfnPi <rob...@pi...>]

Hi,
   I have a (probably) stupid question.

I would linke to set-up an user environment for a certain project for users and then configure it accordingly.

The setup phase is usually done once and involves running a script which makes some changes to the filesystem.
Typically i will create some "standard" directory structures and link some files/directories to this structure.

Once the setup is complete, i need to configure the environment for using it.

This second part is easily dome with modules but i was wondering if there is any way to execute a script (that does not have environment settings) to check if a particular directory structure is in place.
If it is not there it will create it, otherwise it will just skip it and proceed to the configuration part.

Of course this first part would have just to be executed on a module load command and should not be reverted by a module unload or switch command.

Something like:
exec-shell-script bash ./path/to/script/Create.sh
(instead of bash it could be anything like another shell, a python script or even a program written by the user)

followed by some standard modulefile commands that set user environment variables.

A user would then alway call a single modulefile regardless of the fact that the directory structure is already in place.

Something like:
module load setup/ProjectXXX

If it is the first time it is run it will create the complete directory structure (with directories, links etc) and then setup the environment variables (tools, licenses, paths etc)
If the user runs it a second time the script would still be executed but being the directory structure already in place it would just skip that part (this is handled by the script itself) and go to the environment configuration part.

Of course, in case of a:
module unload setup/ProjectXXX
only the environment part would be undone and the whole directory structure would stay as before.

Of course this procedure has not to be a one step solution but it could well be one that reguires loading two different modules,
the first one that creates/checks the structure and a second one that configures the environment.

I tried to look if this is possible but did not find a solution.

Many thx in advance,
    Roberto