Python module

Overview

Write job scripts

GooseSLURM.scripts.plain([command, shell])

Return simple SBATCH-file (as text).

GooseSLURM.scripts.tempdir([remove, ...])

Return SBATCH-file (as text) that uses a temporary working directory on the compute node.

GooseSLURM.files.cmake()

Return a list of typical build files/folders generated by CMake.

Parse ps

GooseSLURM.ps.read_interpret([data, theme])

Read and interpret ps -eo pid,user,rss,%cpu,command.

GooseSLURM.ps.read([data])

Read ps -eo pid,user,rss,%cpu,command.

GooseSLURM.ps.interpret(lines[, theme])

Interpret the output of GooseSLURM.ps.read.

GooseSLURM.ps.colors([theme])

Return dictionary of colors.

Parse squeue

GooseSLURM.squeue.read_interpret([data, ...])

Read and interpret squeue -o "%all".

GooseSLURM.squeue.read([data])

Read squeue -o "%all".

GooseSLURM.squeue.interpret(lines[, now, theme])

Interpret the output of GooseSLURM.squeue.read.

GooseSLURM.squeue.colors([theme])

Return dictionary of colors.

Parse sinfo

GooseSLURM.sinfo.read_interpret([data, theme])

Read and interpret sinfo -o "%all".

GooseSLURM.sinfo.read([data])

Read sinfo -o "%all".

GooseSLURM.sinfo.interpret(lines[, theme])

Interpret the output of GooseSLURM.sinfo.read.

GooseSLURM.sinfo.colors([theme])

Return dictionary of colors.

Rich strings

GooseSLURM.rich.String(data[, width, align, ...])

Rich string.

GooseSLURM.rich.Integer(data, **kwargs)

Rich integer.

GooseSLURM.rich.Float(data, **kwargs)

Rich float.

GooseSLURM.rich.Duration(data, **kwargs)

Rich duration (seconds).

GooseSLURM.rich.Memory(data, **kwargs)

Rich memory (bytes).

Print

GooseSLURM.table.print_long(lines)

Print full data without much formatting.

GooseSLURM.table.print_columns(lines, ...[, ...])

Print table to fit the screen.

GooseSLURM.table.print_list(lines, key[, sep])

Print a single column as a list.

Duration

GooseSLURM.duration.asSeconds(data[, default])

Convert string to seconds.

GooseSLURM.duration.asUnit(data, unit, precision)

Convert to rich-string with a certain unit and precision.

GooseSLURM.duration.asHuman(data[, precision])

Convert to string that has the biggest possible unit.

GooseSLURM.duration.asSlurm(data)

Convert to a SLURM time string.

Memory

GooseSLURM.memory.asBytes(data[, default, ...])

Convert string to bytes.

GooseSLURM.memory.asUnit(data, unit, precision)

Convert to rich-string with a certain unit and precision.

GooseSLURM.memory.asHuman(data[, precision])

Convert to string that has the biggest possible unit.

GooseSLURM.memory.asSlurm(data)

Convert to a SLURM string.

Documentation

GooseSLURM.scripts

GooseSLURM.scripts.plain(command=[], shell='#!/bin/bash -l', **sbatch)

Return simple SBATCH-file (as text).

Options
command (<str> | <list>)

Command(s) to execute. If the input is a list each entry is included as an individual line.

shell (<str>)

The shell to use.

SBATCH options
mem (<int> | <str>)

Memory claim (may be human readable, see GooseSLUM.memory.asSlurm).

time (<str>)

Wall-time claim (may be human readable, see GooseSLUM.duration.asSlurm).

out (<str>)

Name of the output file, e.g. myjob_%j.out.

GooseSLURM.scripts.tempdir(remove=[], command=[], shell='#!/bin/bash -l', **sbatch)

Return SBATCH-file (as text) that uses a temporary working directory on the compute node.

Options
remove (<list>)

List with files/folders to remove from the temporary directory before copying.

command (<str> | <list>)

Command(s) to execute. If the input is a list each entry is included as an individual line.

shell (<str>)

The shell to use.

SBATCH options
mem (<int> | <str>)

Memory claim (may be human readable, see GooseSLUM.memory.asSlurm).

time (<str>)

Wall-time claim (may be human readable, see GooseSLUM.duration.asSlurm).

out (<str>)

Name of the output file, e.g. myjob_%j.out.

GooseSLURM.files

GooseSLURM.files.cmake()

Return a list of typical build files/folders generated by CMake.

GooseSLURM.ps

GooseSLURM.ps.colors(theme=None)

Return dictionary of colors.

{
  'selection' : '...',
}
Options
theme (['dark'] | <str>)

Select color-theme.

GooseSLURM.ps.interpret(lines, theme={'selection': ''})

Interpret the output of GooseSLURM.ps.read. All fields are converted to the GooseSLURM.rich classes adding useful colors in the process.

Arguments
lines <list<dict>>

The output of GooseSLURM.ps.read

Options
theme (<dict>)

The color-theme, as selected by GooseSLURM.ps.colors.

Returns

lines (<list<dict>>)

A list of dictionaries, that contain the different fields. All data are GooseSLURM.rich.String or derived types.

GooseSLURM.ps.read(data=None)

Read ps -eo pid,user,rss,%cpu,command.

Options
data (<str>)

For debugging: specify the output of ps -eo pid,user,rss,%cpu,command as string.

Returns

lines <list<dict>>

A list of dictionaries, that contain the different fields. All data are strings.

GooseSLURM.ps.read_interpret(data=None, theme={'selection': ''})

Read and interpret ps -eo pid,user,rss,%cpu,command.

Returns

lines (<list<dict>>)

A list of dictionaries, that contain the different fields. All data are GooseSLURM.rich.String or derived types.

GooseSLURM.squeue

GooseSLURM.squeue.colors(theme=None)

Return dictionary of colors.

{
  'selection' : '...',
  'queued'    : '...',
}
Options
theme (['dark'] | <str>)

Select color-theme.

GooseSLURM.squeue.interpret(lines, now=None, theme={'queued': '', 'selection': ''})

Interpret the output of GooseSLURM.squeue.read. All fields are converted to the GooseSLURM.rich classes adding useful colors in the process.

Arguments
lines <list<dict>>

The output of GooseSLURM.squeue.read

Options
theme (<dict>)

The color-theme, as selected by GooseSLURM.squeue.colors.

Returns

lines (<list<dict>>)

A list of dictionaries, that contain the different fields. All data are GooseSLURM.rich.String or derived types.

GooseSLURM.squeue.read(data=None)

Read squeue -o "%all".

Options
data (<str>)

For debugging: specify the output of squeue -o "%all" as string.

Returns

lines <list<dict>>

A list of dictionaries, that contain the different fields. All data are strings.

GooseSLURM.squeue.read_interpret(data=None, now=None, theme={'queued': '', 'selection': ''})

Read and interpret squeue -o "%all".

Returns

lines (<list<dict>>)

A list of dictionaries, that contain the different fields. All data are GooseSLURM.rich.String or derived types.

GooseSLURM.sinfo

GooseSLURM.sinfo.colors(theme=None)

Return dictionary of colors.

{
    'selection' : '...',
    'free'      : '...',
    'error'     : '...',
    'warning'   : '...',
    'low'       : '...',
}
Options
theme (['dark'] | <str>)

Select color-theme.

GooseSLURM.sinfo.interpret(lines, theme={'error': '', 'free': '', 'low': '', 'selection': '', 'warning': ''})

Interpret the output of GooseSLURM.sinfo.read. All fields are converted to the GooseSLURM.rich classes adding useful colors in the process.

Arguments
lines <list<dict>>

The output of GooseSLURM.sinfo.read

Options
theme (<dict>)

The color-theme, as selected by GooseSLURM.sinfo.colors.

Returns

lines (<list<dict>>)

A list of dictionaries, that contain the different fields. All data are GooseSLURM.rich.String or derived types.

GooseSLURM.sinfo.read(data=None)

Read sinfo -o "%all".

Options
data (<str>)

For debugging: specify the output of sinfo -o "%all" as string.

Returns

lines <list<dict>>

A list of dictionaries, that contain the different fields. All data are strings.

GooseSLURM.sinfo.read_interpret(data=None, theme={'error': '', 'free': '', 'low': '', 'selection': '', 'warning': ''})

Read and interpret sinfo -o "%all".

Returns

lines (<list<dict>>)

A list of dictionaries, that contain the different fields. All data are GooseSLURM.rich.String or derived types.

GooseSLURM.rich

class GooseSLURM.rich.Duration(data, **kwargs)

Rich duration (seconds).

Note

All options are attributes, that can be modified at all times.

Options
data (<str> | None)

The data.

width ([None] | <int>)

Print width (formatted print only).

color ([None] | <str>)

Print color, e.g. “1;32” for bold green (formatted print only).

align (['<'] | '>')

Print alignment (formatted print only).

precision ([None] | <int>)

Print precision to use for the conversion (formatted print only). None means automatic precision. See GooseSLURM.duration.asHuman.

dummy ([0] | <int> | <float>)

Dummy numerical value, used in case of non-numerical data.

Methods
A.format()

Formatted string, after unit conversion.

str(A)

Unformatted string, after unit conversion.

A.isnumeric()

Return if the “data” is numeric.

int(A)

Return data as integer (dummy is returned if data is not numeric).

float(A)

Return data as float (dummy is returned if data is not numeric).

class GooseSLURM.rich.Float(data, **kwargs)

Rich float.

Note

All options are attributes, that can be modified at all times.

Options
data (<str> | None)

The data.

width ([None] | <int>)

Print width (formatted print only).

color ([None] | <str>)

Print color, e.g. “1;32” for bold green (formatted print only).

align (['<'] | '>')

Print alignment (formatted print only).

precision ([2] | <int>)

Print precision (formatted print only).

dummy ([0] | <int> | <float>)

Dummy numerical value, used in case of non-numerical data.

Methods
A.format()

Formatted string.

str(A)

Unformatted string.

A.isnumeric()

Return if the “data” is numeric.

int(A)

Return data as integer (dummy is returned if data is not numeric).

float(A)

Return data as float (dummy is returned if data is not numeric).

isnumeric()

Return if the “data” is numeric : always zero for this class.

class GooseSLURM.rich.Integer(data, **kwargs)

Rich integer.

Note

All options are attributes, that can be modified at all times.

Options
data (<str> | None)

The data.

width ([None] | <int>)

Print width (formatted print only).

color ([None] | <str>)

Print color, e.g. “1;32” for bold green (formatted print only).

align (['<'] | '>')

Print alignment (formatted print only).

dummy ([0] | <int> | <float>)

Dummy numerical value, used in case of non-numerical data.

Methods
A.format()

Formatted string.

str(A)

Unformatted string.

A.isnumeric()

Return if the “data” is numeric.

int(A)

Return data as integer (dummy is returned if data is not numeric).

float(A)

Return data as float (dummy is returned if data is not numeric).

isnumeric()

Return if the “data” is numeric : always zero for this class.

class GooseSLURM.rich.Memory(data, **kwargs)

Rich memory (bytes).

Note

All options are attributes, that can be modified at all times.

Options
data (<str> | None)

The data.

width ([None] | <int>)

Print width (formatted print only).

color ([None] | <str>)

Print color, e.g. “1;32” for bold green (formatted print only).

align (['<'] | '>')

Print alignment (formatted print only).

precision ([None] | <int>)

Print precision to use for the conversion (formatted print only). None means automatic precision. See GooseSLURM.memory.asHuman.

dummy ([0] | <int> | <float>)

Dummy numerical value, used in case of non-numerical data.

default_unit (int)

The unit to assume if no unit if specified (specify the number of bytes).

Methods
A.format()

Formatted string, after unit conversion.

str(A)

Unformatted string, after unit conversion.

A.isnumeric()

Return if the “data” is numeric.

int(A)

Return data as integer (dummy is returned if data is not numeric).

float(A)

Return data as float (dummy is returned if data is not numeric).

class GooseSLURM.rich.String(data, width=None, align='<', color=None, dummy=0)

Rich string.

Note

All options are attributes, that can be modified at all times.

Options
data (<str> | None)

The data.

width ([None] | <int>)

Print width (formatted print only).

color ([None] | <str>)

Print color, e.g. “1;32” for bold green (formatted print only).

align (['<'] | '>')

Print alignment (formatted print only).

dummy ([0] | <int> | <float>)

Dummy numerical value.

Methods
A.format()

Formatted string.

str(A)

Unformatted string.

A.isnumeric()

Return if the “data” is numeric.

int(A)

Dummy integer.

float(A)

Dummy float.

format()

Return formatted string: align/width/color are applied.

isnumeric()

Return if the “data” is numeric : always zero for this class.

GooseSLURM.table

GooseSLURM.table.print_columns(lines, columns, header, no_truncate=False, sep=', ', cols=None, print_header=True)

Print table to fit the screen. This function can show data truncated, or even suppress columns if there is insufficient room.

Arguments
lines ([ {'JOBID': '1234', ...}, ...])

List of lines, with each line stored as a dictionary. Note that all data has to be stored as one of the GooseSLURM.rich classes (to customize the color, precision, …) or as string.

columns ([ {'key': 'JOBID', 'width': 7, 'align': '>', 'priority': True}, ...])

List with print settings of each column: - ‘key’ : the key-name used to store each line (see lines below) - ‘width’ : minimum print width (expanded as much as possible to fit the data) - ‘align’ : alignment of the column - ‘priority’: priority of column expansion, columns marked True are expanded first

header ({'JOBID': 'JobID', ...})

Header name for each column.

Options
no_truncate ([False] | True)

Disable truncation of columns. In this case each column is expanded to fit the data.

sep ([', '] | <str>)

Separator between columns.

cols ([None] | <int>)

Number of characters on one line. If None the current terminal’s width is used.

print_header ([True] | False)

Optionally skip printing of header.

GooseSLURM.table.print_list(lines, key, sep=' ')

Print a single column as a list.

Arguments
lines ([ {'JOBID': '1234', ...}, ...])

List of lines, with each line stored as a dictionary. Note that all data has to be stored as one as string, or as one the GooseSLURM.rich classes (no rich printing is used though).

key ('JOBID')

Column to print.

Options
sep ([' '] | <str>)

Separator between columns.

GooseSLURM.table.print_long(lines)

Print full data without much formatting. The output looks as follows:

+------------------+
| line 1, column 1 |
| line 1, column 2 |
| ...              |
+-----------------+
| line 2, column 1 |
| line 2, column 2 |
| ...              |
+------------------+
Arguments
lines ([ {'JOBID': '1234', ...}, ...])

List of lines, with each line stored as a dictionary. Note that all data has to be stored as one as string, or as one the GooseSLURM.rich classes (no rich printing is used though).

GooseSLURM.duration

GooseSLURM.duration.asHuman(data, precision=None)

Convert to string that has the biggest possible unit. For example: 100 (seconds) -> "1.7m".

Arguments
data (<str> | <float> | <int>)

A time, see GooseSLURM.duration.asSeconds for conversion.

precision (<int>)

The precision with which to print. By default a precision of one is used for 0 < value < 10, while a precision of zero is used otherwise.

Returns

<str>

The rich-string.

GooseSLURM.duration.asSeconds(data, default=None)

Convert string to seconds. The following input is accepted:

  • A humanly readable time (e.g. “1d”).

  • A SLURM time string (e.g. “1-00:00:00”).

  • A time string (e.g. “24:00:00”).

  • int or float: interpreted as seconds.

Arguments
data (<str> | <float> | <int>)

The input string (number are equally accepted; they are directly interpreted as seconds).

Options
default ([None] | <int>)

Value to return if the conversion fails.

Returns

<int>

Number of seconds as integer (or default value if the conversion fails).

GooseSLURM.duration.asSlurm(data)

Convert to a SLURM time string. For example "1d" -> "1-00:00:00".

Arguments
data (<str> | <float> | <int>)

A time, see GooseSLURM.duration.asSeconds for conversion.

Returns

<str>

The rich-string.

GooseSLURM.duration.asUnit(data, unit, precision)

Convert to rich-string with a certain unit and precision. The output is e.g. "1.1d".

Arguments
data (<int> | <float>)

Numerical value (e.g. 1.1).

unit (<str>)

The unit (e.g. "d").

precision (<int>)

The precision with which to print (e.g. 1).

Returns

<str>

The rich-string.

GooseSLURM.memory

GooseSLURM.memory.asBytes(data, default=None, default_unit=1)

Convert string to bytes. The following input is accepted:

  • A humanly readable string (e.g. “1G”).

  • int or float: interpreted as bytes.

Arguments
data (<str> | <float> | <int>)

The input string (number are equally accepted; they are directly interpreted as bytes).

Options
default ([None] | <int>)

Value to return if the conversion fails.

default_unit (int)

The unit to assume if no unit if specified (specify the number of bytes).

Returns

<int>

Number of bytes as integer (or default value if the conversion fails).

GooseSLURM.memory.asHuman(data, precision=None)

Convert to string that has the biggest possible unit. For example 1e6 (bytes) -> "1.0M".

Arguments
data (<str> | <float> | <int>)

An amount of memory, see GooseSLURM.duration.asBytes for conversion.

precision (<int>)

The precision with which to print. By default a precision of one is used for 0 < value < 10, while a precision of zero is used otherwise.

Returns

<str>

The rich-string.

GooseSLURM.memory.asSlurm(data)

Convert to a SLURM string. For example "1G".

Arguments
data (<str> | <float> | <int>)

An amount of memory, see GooseSLURM.duration.asBytes for conversion.

Returns

<str>

The rich-string.

GooseSLURM.memory.asUnit(data, unit, precision)

Convert to rich-string with a certain unit and precision. The output is e.g. "1.1G".

Arguments
data (<int> | <float>)

Numerical value (e.g. 1.1).

unit (<str>)

The unit (e.g. "G").

precision (<int>)

The precision with which to print (e.g. 1).

Returns

<str>

The rich-string.