API reference

def get_base_command(clt: CommandLineTool) -> str:
    """Return the executable name from a CWL tool.

    Raises:
        ValueError: If the tool does not define a string base command.
    """
    if clt.baseCommand:
        if isinstance(clt.baseCommand, list) and len(clt.baseCommand) > 0:
            command = clt.baseCommand[0]
            if isinstance(command, str):
                return command

        if isinstance(clt.baseCommand, str):
            return clt.baseCommand

    raise ValueError(
        f"CommandLineTool '{clt.id}' does not define a 'baseCommand' property, impossible to map it to a `click.Command`"
    )

def get_command_name(clt: CommandLineTool) -> str | None:
    """Return the subcommand name, or None when no string name is defined."""
    if clt.baseCommand:
        if isinstance(clt.baseCommand, list) and len(clt.baseCommand) > 1:
            command = clt.baseCommand[1]
            if isinstance(command, str):
                return command

        if clt.arguments:
            if isinstance(clt.arguments, list):
                command = clt.arguments[0]
                if isinstance(command, str):
                    return command
                return None
            return str(clt.arguments)

    return None

def is_flag(type_: Any) -> bool:
    """Indicate whether a CWL type includes a boolean flag."""
    return (isinstance(type_, list) and "boolean" in type_) or type_ == "boolean"

def is_multiple(type_: Any) -> bool:
    """Indicate whether a CWL input accepts multiple values."""
    if not is_array(type_):
        return False

    array_size = _get_array_size(type_)
    nullable_union_size = 2

    return not (array_size == nullable_union_size and is_nullable(type_))

def to_click(
    command_line_tools: Iterable[Process],
    module_name: str,
    output_stream: TextIO,
    bundle: bool = True,
) -> None:
    """Write generated Click command source to the supplied output stream."""
    template = _jinja_environment.get_template("command_line_tools.py.jinja")

    output_stream.write(
        template.render(
            version=_get_version(),
            timestamp=datetime.fromtimestamp(time.time()).isoformat(timespec="milliseconds"),
            bundle=bundle,
            module_name=module_name,
            command_line_tools=command_line_tools,
        )
    )

def to_click_type(type_: object) -> str:
    """Map a parsed CWL type to a Click parameter type expression."""
    key: object = None

    if isinstance(type_, str):
        key = type_
    elif isinstance(type_, list):
        key = next(item_type for item_type in type_ if item_type != "null")
    elif hasattr(type_, "items"):
        key = type_.items
    elif hasattr(type_, "class_"):
        key = type_.class_
    elif hasattr(type_, "symbols"):
        return f"Choice({[symbol.split('/')[-1] for symbol in type_.symbols]})"

    if key and not isinstance(key, str) and hasattr(key, "symbols"):
        return f"Choice({[symbol.split('/')[-1] for symbol in key.symbols]})"

    mapped_type: str = _CWL_CLICK_MAP_.get(key, "STRING")

    logger.debug(f"Type {type_}, represented by key type {key}, mapped to {mapped_type}")

    return mapped_type

def to_python_type(type_: object) -> str:
    """Map a parsed CWL type to its Python type name."""
    logger.debug(f"Converting {type_} CWL type to the related Python type...")

    key: object
    if isinstance(type_, str):
        key = type_
    elif isinstance(type_, list):
        key = next(item_type for item_type in type_ if item_type != "null")
    elif hasattr(type_, "class_"):
        key = type_.class_

        if key == "enum":
            key = "string"

    else:
        return str(type_)

    return _CWL_PYTHON_MAP_.get(key, str(type_))