flytekit.clis.sdk_in_container.utils

Directory

Classes

Methods

Variables

Methods

get_option_from_metadata()

def get_option_from_metadata(
    metadata: mappingproxy,
) -> click.core.Option

make_click_option_field()

def make_click_option_field(
    o: click.core.Option,
) -> dataclasses.Field

pretty_print_exception()

def pretty_print_exception(
    e: Exception,
    verbosity: int,
)

This method will print the exception in a nice way. It will also check if the exception is a grpc.RpcError and print it in a human-readable way.

pretty_print_grpc_error()

def pretty_print_grpc_error(
    e: grpc.RpcError,
)

This method will print the grpc error that us more human readable.

pretty_print_traceback()

def pretty_print_traceback(
    e: Exception,
    verbosity: int,
)

This method will print the Traceback of an error. Print the traceback in a nice formatted way if verbose is set to True.

remove_unwanted_traceback_frames()

def remove_unwanted_traceback_frames(
    tb: traceback,
    unwanted_module_names: typing.List[str],
) -> traceback

Custom function to remove certain frames from the traceback.

validate_package()

def validate_package(
    ctx,
    param,
    values,
)

This method will validate the packages passed in by the user. It will check that the packages are in the correct format, and will also split the packages if the user passed in a comma separated list.

flytekit.clis.sdk_in_container.utils.ErrorHandlingCommand

Helper class that wraps the invoke method of a click command to catch exceptions and print them in a nice way.

class ErrorHandlingCommand(
    args: *args,
    kwargs: **kwargs,
)

Create RichGroup instance.

Methods

add_command()

def add_command(
    cmd: click.Command,
    name: Optional[str],
    aliases: Optional[Iterable[str]],
    panel: Optional[Union[str, List[str]]],
)

Register another :class:Command with this group. If the name is not provided, the name of the command is used.

add_command_to_panel()

def add_command_to_panel(
    command: click.Command,
    panel_name: Union[str, Iterable[str]],
)

add_panel()

def add_panel(
    panel: 'RichPanel[Any, Any]',
)

Add a RichPanel to the RichCommand.

collect_usage_pieces()

def collect_usage_pieces(
    ctx: click.core.Context,
) -> typing.List[str]

Returns all the pieces that go into the usage line and returns it as a list of strings.

command()

def command(
    args: *args,
    kwargs: **kwargs,
) -> Union[Callable[[Callable[..., Any]], RichCommand], RichCommand]

A shortcut decorator for declaring and attaching a command to the group. This takes the same arguments as :func:command and immediately registers the created command with this group by calling :meth:add_command.

To customize the command class used, set the :attr:command_class attribute.

.. versionchanged:: 8.1 This decorator can be applied without parentheses.

.. versionchanged:: 8.0 Added the :attr:command_class attribute.

format_commands()

def format_commands(
    ctx: click.Context,
    formatter: click.HelpFormatter,
)

Extra format methods for multi methods that adds all the commands after the options.

format_epilog()

def format_epilog(
    ctx: RichContext,
    formatter: RichHelpFormatter,
)

Writes the epilog into the formatter if it exists.

format_help()

def format_help(
    ctx: RichContext,
    formatter: RichHelpFormatter,
)

Writes the help into the formatter if it exists.

This is a low-level method called by :meth:get_help.

This calls the following methods:

• :meth:format_usage
• :meth:format_help_text
• :meth:format_options
• :meth:format_epilog

format_help_text()

def format_help_text(
    ctx: RichContext,
    formatter: RichHelpFormatter,
)

Writes the help text to the formatter if it exists.

format_options()

def format_options(
    ctx: click.Context,
    formatter: click.HelpFormatter,
)

Writes all the options into the formatter if they exist.

format_usage()

def format_usage(
    ctx: click.core.Context,
    formatter: click.formatting.HelpFormatter,
)

Writes the usage line into the formatter.

This is a low-level method called by :meth:get_usage.

get_command()

def get_command(
    ctx: click.Context,
    cmd_name: str,
) -> Optional[click.Command]

Given a context and a command name, this returns a :class:Command object if it exists or returns None.

get_help()

def get_help(
    ctx: click.core.Context,
) -> str

Formats the help into a string and returns it.

Calls :meth:format_help internally.

get_help_option()

def get_help_option(
    ctx: click.Context,
) -> Union[click.Option, None]

Return the help option object.

Skipped if :attr:add_help_option is False.

.. versionchanged:: 8.1.8 The help option is now cached to avoid creating it multiple times.

get_help_option_names()

def get_help_option_names(
    ctx: click.core.Context,
) -> typing.List[str]

Returns the names for the help option.

get_params()

def get_params(
    ctx: click.core.Context,
) -> typing.List[ForwardRef('Parameter')]

get_rich_table_row()

def get_rich_table_row(
    ctx: 'RichContext',
    formatter: 'RichHelpFormatter',
    panel: Optional['RichCommandPanel'],
) -> 'RichPanelRow'

Create a row for the rich table corresponding with this parameter.

get_short_help_str()

def get_short_help_str(
    limit: int,
) -> str

Gets short help for the command or makes it by shortening the long help string.

get_usage()

def get_usage(
    ctx: click.core.Context,
) -> str

Formats the usage line into a string and returns it.

Calls :meth:format_usage internally.

group()

def group(
    args: *args,
    kwargs: **kwargs,
) -> Union[Callable[[Callable[..., Any]], 'RichGroup'], 'RichGroup']

A shortcut decorator for declaring and attaching a group to the group. This takes the same arguments as :func:group and immediately registers the created group with this group by calling :meth:add_command.

To customize the group class used, set the :attr:group_class attribute.

.. versionchanged:: 8.1 This decorator can be applied without parentheses.

.. versionchanged:: 8.0 Added the :attr:group_class attribute.

invoke()

def invoke(
    ctx: click.core.Context,
) -> typing.Any

Given a context, this invokes the attached callback (if it exists) in the right way.

list_commands()

def list_commands(
    ctx: click.core.Context,
) -> typing.List[str]

Returns a list of subcommand names in the order they should appear.

main()

def main(
    args: *args,
    prog_name: Optional[str],
    complete_var: Optional[str],
    standalone_mode: bool,
    windows_expand_args: bool,
    extra: Any,
) -> Any

This is the way to invoke a script with all the bells and whistles as a command line application. This will always terminate the application after a call. If this is not wanted, SystemExit needs to be caught.

This method is also available by directly calling the instance of a :class:Command.

make_context()

def make_context(
    info_name: typing.Optional[str],
    args: *args,
    parent: typing.Optional[click.core.Context],
    extra: typing.Any,
) -> click.core.Context

This function when given an info name and arguments will kick off the parsing and create a new :class:Context. It does not invoke the actual command callback though.

To quickly customize the context class used without overriding this method, set the :attr:context_class attribute.

make_parser()

def make_parser(
    ctx: click.core.Context,
) -> click.parser.OptionParser

Creates the underlying option parser for this command.

parse_args()

def parse_args(
    ctx: click.core.Context,
    args: *args,
) -> typing.List[str]

Given a context and a list of arguments this creates the parser and parses the arguments, then modifies the context as necessary. This is automatically invoked by :meth:make_context.

resolve_command()

def resolve_command(
    ctx: click.core.Context,
    args: *args,
) -> typing.Tuple[typing.Optional[str], typing.Optional[click.core.Command], typing.List[str]]

result_callback()

def result_callback(
    replace: bool,
) -> typing.Callable[[~F], ~F]

Adds a result callback to the command. By default if a result callback is already registered this will chain them but this can be disabled with the replace parameter. The result callback is invoked with the return value of the subcommand (or the list of return values from all subcommands if chaining is enabled) as well as the parameters as they would be passed to the main callback.

Example::

@click.group()
@click.option('-i', '--input', default=23)
def cli(input):
    return 42

@cli.result_callback()
def process_result(result, input):
    return result + input

shell_complete()

def shell_complete(
    ctx: click.core.Context,
    incomplete: str,
) -> typing.List[ForwardRef('CompletionItem')]

Return a list of completions for the incomplete value. Looks at the names of options, subcommands, and chained multi-commands.

to_info_dict()

def to_info_dict(
    ctx: click.Context,
) -> Dict[str, Any]

Gather information that could be useful for a tool generating user-facing documentation. This traverses the entire structure below this command.

Use :meth:click.Context.to_info_dict to traverse the entire CLI structure.

Properties

flytekit.clis.sdk_in_container.utils.PyFlyteParams

class PyFlyteParams(
    config_file: typing.Optional[str],
    verbose: bool,
    pkgs: typing.List[str],
)

Methods

from_dict()

def from_dict(
    d: typing.Dict[str, typing.Any],
) -> PyFlyteParams