fix(yapf): align weird new lines break [generated] [skip ci] (#284)

fix(yapf): align weird new lines break

Signed-off-by: aarnphm-ec2-dev <29749331+aarnphm@users.noreply.github.com>

openllm-python/src/openllm/cli/_factory.py

@@ -50,14 +50,10 @@ def bento_complete_envvar(ctx: click.Context, param: click.Parameter, incomplete
   ]
 
 def model_complete_envvar(ctx: click.Context, param: click.Parameter, incomplete: str) -> list[sc.CompletionItem]:
-  return [
-      sc.CompletionItem(inflection.dasherize(it), help='Model')
-      for it in openllm.CONFIG_MAPPING
-      if it.startswith(incomplete)
-  ]
+  return [sc.CompletionItem(inflection.dasherize(it), help='Model') for it in openllm.CONFIG_MAPPING if it.startswith(incomplete)]
 
-def parse_config_options(config: LLMConfig, server_timeout: int, workers_per_resource: float,
-                         device: t.Tuple[str, ...] | None, cors: bool, environ: DictStrAny) -> DictStrAny:
+def parse_config_options(config: LLMConfig, server_timeout: int, workers_per_resource: float, device: t.Tuple[str, ...] | None, cors: bool,
+                         environ: DictStrAny) -> DictStrAny:
   # TODO: Support amd.com/gpu on k8s
   _bentoml_config_options_env = environ.pop('BENTOML_CONFIG_OPTIONS', '')
   _bentoml_config_options_opts = [
@@ -67,22 +63,15 @@ def parse_config_options(config: LLMConfig, server_timeout: int, workers_per_res
   ]
   if device:
     if len(device) > 1:
-      _bentoml_config_options_opts.extend([
-          f'runners."llm-{config["start_name"]}-runner".resources."nvidia.com/gpu"[{idx}]={dev}'
-          for idx, dev in enumerate(device)
-      ])
+      _bentoml_config_options_opts.extend(
+          [f'runners."llm-{config["start_name"]}-runner".resources."nvidia.com/gpu"[{idx}]={dev}' for idx, dev in enumerate(device)])
     else:
-      _bentoml_config_options_opts.append(
-          f'runners."llm-{config["start_name"]}-runner".resources."nvidia.com/gpu"=[{device[0]}]')
-  _bentoml_config_options_opts.append(
-      f'runners."llm-generic-embedding".resources.cpu={openllm.get_resource({"cpu":"system"},"cpu")}')
+      _bentoml_config_options_opts.append(f'runners."llm-{config["start_name"]}-runner".resources."nvidia.com/gpu"=[{device[0]}]')
+  _bentoml_config_options_opts.append(f'runners."llm-generic-embedding".resources.cpu={openllm.get_resource({"cpu":"system"},"cpu")}')
   if cors:
+    _bentoml_config_options_opts.extend(['api_server.http.cors.enabled=true', 'api_server.http.cors.access_control_allow_origins="*"'])
     _bentoml_config_options_opts.extend(
-        ['api_server.http.cors.enabled=true', 'api_server.http.cors.access_control_allow_origins="*"'])
-    _bentoml_config_options_opts.extend([
-        f'api_server.http.cors.access_control_allow_methods[{idx}]="{it}"'
-        for idx, it in enumerate(['GET', 'OPTIONS', 'POST', 'HEAD', 'PUT'])
-    ])
+        [f'api_server.http.cors.access_control_allow_methods[{idx}]="{it}"' for idx, it in enumerate(['GET', 'OPTIONS', 'POST', 'HEAD', 'PUT'])])
   _bentoml_config_options_env += ' ' if _bentoml_config_options_env else '' + ' '.join(_bentoml_config_options_opts)
   environ['BENTOML_CONFIG_OPTIONS'] = _bentoml_config_options_env
   if DEBUG: logger.debug('Setting BENTOML_CONFIG_OPTIONS=%s', _bentoml_config_options_env)
@@ -104,17 +93,13 @@ def _id_callback(ctx: click.Context, _: click.Parameter, value: t.Tuple[str, ...
     ctx.params[_adapter_mapping_key][adapter_id] = adapter_name[0] if len(adapter_name) > 0 else None
   return None
 
-def start_command_factory(group: click.Group,
-                          model: str,
-                          _context_settings: DictStrAny | None = None,
-                          _serve_grpc: bool = False) -> click.Command:
+def start_command_factory(group: click.Group, model: str, _context_settings: DictStrAny | None = None, _serve_grpc: bool = False) -> click.Command:
   llm_config = openllm.AutoConfig.for_model(model)
-  command_attrs: DictStrAny = dict(
-      name=llm_config['model_name'],
-      context_settings=_context_settings or termui.CONTEXT_SETTINGS,
-      short_help=f"Start a LLMServer for '{model}'",
-      aliases=[llm_config['start_name']] if llm_config['name_type'] == 'dasherize' else None,
-      help=f'''\
+  command_attrs: DictStrAny = dict(name=llm_config['model_name'],
+                                   context_settings=_context_settings or termui.CONTEXT_SETTINGS,
+                                   short_help=f"Start a LLMServer for '{model}'",
+                                   aliases=[llm_config['start_name']] if llm_config['name_type'] == 'dasherize' else None,
+                                   help=f'''\
 {llm_config['env'].start_docstring}
 
 \b
@@ -133,15 +118,13 @@ Available official model_id(s): [default: {llm_config['default_id']}]
 \b
 {orjson.dumps(llm_config['model_ids'], option=orjson.OPT_INDENT_2).decode()}
 ''',
-  )
+                                   )
 
   if llm_config['requires_gpu'] and openllm.utils.device_count() < 1:
     # NOTE: The model requires GPU, therefore we will return a dummy command
     command_attrs.update({
-        'short_help':
-            '(Disabled because there is no GPU available)',
-        'help':
-            f'{model} is currently not available to run on your local machine because it requires GPU for inference.'
+        'short_help': '(Disabled because there is no GPU available)',
+        'help': f'{model} is currently not available to run on your local machine because it requires GPU for inference.'
     })
     return noop_command(group, llm_config, _serve_grpc, **command_attrs)
 
@@ -150,12 +133,10 @@ Available official model_id(s): [default: {llm_config['default_id']}]
   @click.pass_context
   def start_cmd(ctx: click.Context, /, server_timeout: int, model_id: str | None, model_version: str | None,
                 workers_per_resource: t.Literal['conserved', 'round_robin'] | LiteralString, device: t.Tuple[str, ...],
-                quantize: t.Literal['int8', 'int4', 'gptq'] | None, backend: LiteralBackend,
-                serialisation_format: t.Literal['safetensors', 'legacy'], cors: bool, adapter_id: str | None,
-                return_process: bool, **attrs: t.Any,
-               ) -> LLMConfig | subprocess.Popen[bytes]:
-    if serialisation_format == 'safetensors' and quantize is not None and openllm_core.utils.check_bool_env(
-        'OPENLLM_SERIALIZATION_WARNING'):
+                quantize: t.Literal['int8', 'int4', 'gptq'] | None, backend: LiteralBackend, serialisation_format: t.Literal['safetensors', 'legacy'],
+                cors: bool, adapter_id: str | None, return_process: bool, **attrs: t.Any,
+                ) -> LLMConfig | subprocess.Popen[bytes]:
+    if serialisation_format == 'safetensors' and quantize is not None and openllm_core.utils.check_bool_env('OPENLLM_SERIALIZATION_WARNING'):
       termui.echo(
           f"'--quantize={quantize}' might not work with 'safetensors' serialisation format. Use with caution!. To silence this warning, set \"OPENLLM_SERIALIZATION_WARNING=False\"\nNote: You can always fallback to '--serialisation legacy' when running quantisation.",
           fg='yellow')
@@ -184,10 +165,7 @@ Available official model_id(s): [default: {llm_config['default_id']}]
       wpr = float(wpr)
 
     # Create a new model env to work with the envvar during CLI invocation
-    env = openllm.utils.EnvVarMixin(config['model_name'],
-                                    backend,
-                                    model_id=model_id or config['default_id'],
-                                    quantize=quantize)
+    env = openllm.utils.EnvVarMixin(config['model_name'], backend, model_id=model_id or config['default_id'], quantize=quantize)
     requirements = llm_config['requirements']
     if requirements is not None and len(requirements) > 0:
       missing_requirements = [i for i in requirements if importlib.util.find_spec(inflection.underscore(i)) is None]
@@ -218,17 +196,14 @@ Available official model_id(s): [default: {llm_config['default_id']}]
                                                                          serialisation=serialisation_format)
     start_env.update({env.config: llm.config.model_dump_json().decode()})
 
-    server = bentoml.GrpcServer('_service:svc', **server_attrs) if _serve_grpc else bentoml.HTTPServer(
-        '_service:svc', **server_attrs)
+    server = bentoml.GrpcServer('_service:svc', **server_attrs) if _serve_grpc else bentoml.HTTPServer('_service:svc', **server_attrs)
     openllm.utils.analytics.track_start_init(llm.config)
 
     def next_step(model_name: str, adapter_map: DictStrAny | None) -> None:
       cmd_name = f'openllm build {model_name}'
       if adapter_map is not None:
-        cmd_name += ' ' + ' '.join([
-            f'--adapter-id {s}'
-            for s in [f'{p}:{name}' if name not in (None, 'default') else p for p, name in adapter_map.items()]
-        ])
+        cmd_name += ' ' + ' '.join(
+            [f'--adapter-id {s}' for s in [f'{p}:{name}' if name not in (None, 'default') else p for p, name in adapter_map.items()]])
       if not openllm.utils.get_quiet_mode():
         termui.echo(f"\n🚀 Next step: run '{cmd_name}' to create a Bento for {model_name}", fg='blue')
 
@@ -265,17 +240,13 @@ def noop_command(group: click.Group, llm_config: LLMConfig, _serve_grpc: bool, *
   return noop
 
 def start_decorator(llm_config: LLMConfig, serve_grpc: bool = False) -> t.Callable[[FC], t.Callable[[FC], FC]]:
-
   def wrapper(fn: FC) -> t.Callable[[FC], FC]:
     composed = openllm.utils.compose(
         llm_config.to_click_options, _http_server_args if not serve_grpc else _grpc_server_args,
-        cog.optgroup.group(
-            'General LLM Options',
-            help=f"The following options are related to running '{llm_config['start_name']}' LLM Server."),
+        cog.optgroup.group('General LLM Options', help=f"The following options are related to running '{llm_config['start_name']}' LLM Server."),
         model_id_option(factory=cog.optgroup), model_version_option(factory=cog.optgroup),
         cog.optgroup.option('--server-timeout', type=int, default=None, help='Server timeout in seconds'),
-        workers_per_resource_option(factory=cog.optgroup), cors_option(factory=cog.optgroup),
-        backend_option(factory=cog.optgroup),
+        workers_per_resource_option(factory=cog.optgroup), cors_option(factory=cog.optgroup), backend_option(factory=cog.optgroup),
         cog.optgroup.group('LLM Optimization Options',
                            help='''Optimization related options.
 
@@ -286,7 +257,7 @@ def start_decorator(llm_config: LLMConfig, serve_grpc: bool = False) -> t.Callab
             - DeepSpeed Inference: [link](https://www.deepspeed.ai/inference/)
             - GGML: Fast inference on [bare metal](https://github.com/ggerganov/ggml)
             ''',
-                          ), quantize_option(factory=cog.optgroup), serialisation_option(factory=cog.optgroup),
+                           ), quantize_option(factory=cog.optgroup), serialisation_option(factory=cog.optgroup),
         cog.optgroup.option('--device',
                             type=openllm.utils.dantic.CUDA,
                             multiple=True,
@@ -312,8 +283,7 @@ def start_decorator(llm_config: LLMConfig, serve_grpc: bool = False) -> t.Callab
     '''),
         cog.optgroup.option('--adapter-id',
                             default=None,
-                            help='Optional name or path for given LoRA adapter' +
-                            f" to wrap '{llm_config['model_name']}'",
+                            help='Optional name or path for given LoRA adapter' + f" to wrap '{llm_config['model_name']}'",
                             multiple=True,
                             callback=_id_callback,
                             metavar='[PATH | [remote/][adapter_name:]adapter_id][, ...]'),
@@ -323,8 +293,7 @@ def start_decorator(llm_config: LLMConfig, serve_grpc: bool = False) -> t.Callab
 
   return wrapper
 
-def parse_device_callback(ctx: click.Context, param: click.Parameter,
-                          value: tuple[tuple[str], ...] | None) -> t.Tuple[str, ...] | None:
+def parse_device_callback(ctx: click.Context, param: click.Parameter, value: tuple[tuple[str], ...] | None) -> t.Tuple[str, ...] | None:
   if value is None: return value
   if not isinstance(value, tuple): ctx.fail(f'{param} only accept multiple values, not {type(value)} (value: {value})')
   el: t.Tuple[str, ...] = tuple(i for k in value for i in k)
@@ -342,19 +311,15 @@ def parse_serve_args(serve_grpc: bool) -> t.Callable[[t.Callable[..., LLMConfig]
   from bentoml_cli.cli import cli
 
   command = 'serve' if not serve_grpc else 'serve-grpc'
-  group = cog.optgroup.group(
-      f"Start a {'HTTP' if not serve_grpc else 'gRPC'} server options",
-      help=f"Related to serving the model [synonymous to `bentoml {'serve-http' if not serve_grpc else command }`]",
-  )
+  group = cog.optgroup.group(f"Start a {'HTTP' if not serve_grpc else 'gRPC'} server options",
+                             help=f"Related to serving the model [synonymous to `bentoml {'serve-http' if not serve_grpc else command }`]",
+                             )
 
   def decorator(f: t.Callable[Concatenate[int, t.Optional[str], P], LLMConfig]) -> t.Callable[[FC], FC]:
     serve_command = cli.commands[command]
     # The first variable is the argument bento
     # The last five is from BentoMLCommandGroup.NUMBER_OF_COMMON_PARAMS
-    serve_options = [
-        p for p in serve_command.params[1:-BentoMLCommandGroup.NUMBER_OF_COMMON_PARAMS]
-        if p.name not in _IGNORED_OPTIONS
-    ]
+    serve_options = [p for p in serve_command.params[1:-BentoMLCommandGroup.NUMBER_OF_COMMON_PARAMS] if p.name not in _IGNORED_OPTIONS]
     for options in reversed(serve_options):
       attrs = options.to_info_dict()
       # we don't need param_type_name, since it should all be options
@@ -391,10 +356,7 @@ def _click_factory_type(*param_decls: t.Any, **attrs: t.Any) -> t.Callable[[FC |
 cli_option = functools.partial(_click_factory_type, attr='option')
 cli_argument = functools.partial(_click_factory_type, attr='argument')
 
-def output_option(f: _AnyCallable | None = None,
-                  *,
-                  default_value: LiteralOutput = 'pretty',
-                  **attrs: t.Any) -> t.Callable[[FC], FC]:
+def output_option(f: _AnyCallable | None = None, *, default_value: LiteralOutput = 'pretty', **attrs: t.Any) -> t.Callable[[FC], FC]:
   output = ['json', 'pretty', 'porcelain']
 
   def complete_output_var(ctx: click.Context, param: click.Parameter, incomplete: str) -> list[CompletionItem]:
@@ -434,12 +396,11 @@ def model_id_option(f: _AnyCallable | None = None, **attrs: t.Any) -> t.Callable
                     **attrs)(f)
 
 def model_version_option(f: _AnyCallable | None = None, **attrs: t.Any) -> t.Callable[[FC], FC]:
-  return cli_option(
-      '--model-version',
-      type=click.STRING,
-      default=None,
-      help='Optional model version to save for this model. It will be inferred automatically from model-id.',
-      **attrs)(f)
+  return cli_option('--model-version',
+                    type=click.STRING,
+                    default=None,
+                    help='Optional model version to save for this model. It will be inferred automatically from model-id.',
+                    **attrs)(f)
 
 def backend_option(f: _AnyCallable | None = None, **attrs: t.Any) -> t.Callable[[FC], FC]:
   # NOTE: LiteralBackend needs to remove the last two item as ggml and mlc is wip
@@ -453,10 +414,7 @@ def backend_option(f: _AnyCallable | None = None, **attrs: t.Any) -> t.Callable[
                     **attrs)(f)
 
 def model_name_argument(f: _AnyCallable | None = None, required: bool = True, **attrs: t.Any) -> t.Callable[[FC], FC]:
-  return cli_argument('model_name',
-                      type=click.Choice([inflection.dasherize(name) for name in openllm.CONFIG_MAPPING]),
-                      required=required,
-                      **attrs)(f)
+  return cli_argument('model_name', type=click.Choice([inflection.dasherize(name) for name in openllm.CONFIG_MAPPING]), required=required, **attrs)(f)
 
 def quantize_option(f: _AnyCallable | None = None, *, build: bool = False, **attrs: t.Any) -> t.Callable[[FC], FC]:
   return cli_option('--quantise',
@@ -482,10 +440,7 @@ def quantize_option(f: _AnyCallable | None = None, *, build: bool = False, **att
       > [!NOTE] that quantization are currently only available in *PyTorch* models.''',
                     **attrs)(f)
 
-def workers_per_resource_option(f: _AnyCallable | None = None,
-                                *,
-                                build: bool = False,
-                                **attrs: t.Any) -> t.Callable[[FC], FC]:
+def workers_per_resource_option(f: _AnyCallable | None = None, *, build: bool = False, **attrs: t.Any) -> t.Callable[[FC], FC]:
   return cli_option('--workers-per-resource',
                     default=None,
                     callback=workers_per_resource_callback,
@@ -536,18 +491,16 @@ def serialisation_option(f: _AnyCallable | None = None, **attrs: t.Any) -> t.Cal
                     **attrs)(f)
 
 def container_registry_option(f: _AnyCallable | None = None, **attrs: t.Any) -> t.Callable[[FC], FC]:
-  return cli_option(
-      '--container-registry',
-      'container_registry',
-      type=click.Choice(list(openllm.bundle.CONTAINER_NAMES)),
-      default='ecr',
-      show_default=True,
-      show_envvar=True,
-      envvar='OPENLLM_CONTAINER_REGISTRY',
-      callback=container_registry_callback,
-      help=
-      'The default container registry to get the base image for building BentoLLM. Currently, it supports ecr, ghcr, docker',
-      **attrs)(f)
+  return cli_option('--container-registry',
+                    'container_registry',
+                    type=click.Choice(list(openllm.bundle.CONTAINER_NAMES)),
+                    default='ecr',
+                    show_default=True,
+                    show_envvar=True,
+                    envvar='OPENLLM_CONTAINER_REGISTRY',
+                    callback=container_registry_callback,
+                    help='The default container registry to get the base image for building BentoLLM. Currently, it supports ecr, ghcr, docker',
+                    **attrs)(f)
 
 _wpr_strategies = {'round_robin', 'conserved'}
 
@@ -559,9 +512,8 @@ def workers_per_resource_callback(ctx: click.Context, param: click.Parameter, va
     try:
       float(value)  # type: ignore[arg-type]
     except ValueError:
-      raise click.BadParameter(
-          f"'workers_per_resource' only accept '{_wpr_strategies}' as possible strategies, otherwise pass in float.",
-          ctx, param) from None
+      raise click.BadParameter(f"'workers_per_resource' only accept '{_wpr_strategies}' as possible strategies, otherwise pass in float.", ctx,
+                               param) from None
     else:
       return value
 

openllm-python/src/openllm/cli/_sdk.py

@@ -84,8 +84,7 @@ def _start(model_name: str,
   from .entrypoint import start_grpc_command
   llm_config = openllm.AutoConfig.for_model(model_name)
   _ModelEnv = openllm_core.utils.EnvVarMixin(model_name,
-                                             backend=openllm_core.utils.first_not_none(
-                                                 backend, default=llm_config.default_backend()),
+                                             backend=openllm_core.utils.first_not_none(backend, default=llm_config.default_backend()),
                                              model_id=model_id,
                                              quantize=quantize)
   os.environ[_ModelEnv.backend] = _ModelEnv['backend_value']
@@ -94,26 +93,19 @@ def _start(model_name: str,
   if model_id: args.extend(['--model-id', model_id])
   if timeout: args.extend(['--server-timeout', str(timeout)])
   if workers_per_resource:
-    args.extend([
-        '--workers-per-resource',
-        str(workers_per_resource) if not isinstance(workers_per_resource, str) else workers_per_resource
-    ])
+    args.extend(['--workers-per-resource', str(workers_per_resource) if not isinstance(workers_per_resource, str) else workers_per_resource])
   if device and not os.environ.get('CUDA_VISIBLE_DEVICES'): args.extend(['--device', ','.join(device)])
   if quantize: args.extend(['--quantize', str(quantize)])
   if cors: args.append('--cors')
   if adapter_map:
-    args.extend(
-        list(
-            itertools.chain.from_iterable([['--adapter-id', f"{k}{':'+v if v else ''}"] for k, v in adapter_map.items()
-                                          ])))
+    args.extend(list(itertools.chain.from_iterable([['--adapter-id', f"{k}{':'+v if v else ''}"] for k, v in adapter_map.items()])))
   if additional_args: args.extend(additional_args)
   if __test__: args.append('--return-process')
 
   return start_command_factory(start_command if not _serve_grpc else start_grpc_command,
                                model_name,
                                _context_settings=termui.CONTEXT_SETTINGS,
-                               _serve_grpc=_serve_grpc).main(args=args if len(args) > 0 else None,
-                                                             standalone_mode=False)
+                               _serve_grpc=_serve_grpc).main(args=args if len(args) > 0 else None, standalone_mode=False)
 
 @inject
 def _build(model_name: str,
@@ -180,9 +172,7 @@ def _build(model_name: str,
   Returns:
       ``bentoml.Bento | str``: BentoLLM instance. This can be used to serve the LLM or can be pushed to BentoCloud.
   """
-  args: list[str] = [
-      sys.executable, '-m', 'openllm', 'build', model_name, '--machine', '--serialisation', serialisation_format
-  ]
+  args: list[str] = [sys.executable, '-m', 'openllm', 'build', model_name, '--machine', '--serialisation', serialisation_format]
   if quantize: args.extend(['--quantize', quantize])
   if containerize and push: raise OpenLLMException("'containerize' and 'push' are currently mutually exclusive.")
   if push: args.extend(['--push'])
@@ -265,8 +255,7 @@ def _list_models() -> dict[str, t.Any]:
   from .entrypoint import models_command
   return models_command.main(args=['-o', 'json', '--show-available', '--machine'], standalone_mode=False)
 
-start, start_grpc, build, import_model, list_models = openllm_core.utils.codegen.gen_sdk(
-    _start, _serve_grpc=False), openllm_core.utils.codegen.gen_sdk(
-        _start, _serve_grpc=True), openllm_core.utils.codegen.gen_sdk(_build), openllm_core.utils.codegen.gen_sdk(
-            _import_model), openllm_core.utils.codegen.gen_sdk(_list_models)
+start, start_grpc, build, import_model, list_models = openllm_core.utils.codegen.gen_sdk(_start, _serve_grpc=False), openllm_core.utils.codegen.gen_sdk(
+    _start, _serve_grpc=True), openllm_core.utils.codegen.gen_sdk(_build), openllm_core.utils.codegen.gen_sdk(
+        _import_model), openllm_core.utils.codegen.gen_sdk(_list_models)
 __all__ = ['start', 'start_grpc', 'build', 'import_model', 'list_models']

openllm-python/src/openllm/cli/extension/build_base_container.py

@@ -34,8 +34,8 @@ if t.TYPE_CHECKING:
               help='Version strategy to use for tagging the image.')
 @click.option('--push/--no-push', help='Whether to push to remote repository', is_flag=True, default=False)
 @machine_option
-def cli(container_registry: tuple[LiteralContainerRegistry, ...] | None,
-        version_strategy: LiteralContainerVersionStrategy, push: bool, machine: bool) -> dict[str, str]:
+def cli(container_registry: tuple[LiteralContainerRegistry, ...] | None, version_strategy: LiteralContainerVersionStrategy, push: bool,
+        machine: bool) -> dict[str, str]:
   mapping = openllm.bundle.build_container(container_registry, version_strategy, push, machine)
   if machine: termui.echo(orjson.dumps(mapping, option=orjson.OPT_INDENT_2).decode(), fg='white')
   return mapping

openllm-python/src/openllm/cli/extension/dive_bentos.py

@@ -24,10 +24,7 @@ if t.TYPE_CHECKING:
 @machine_option
 @click.pass_context
 @inject
-def cli(ctx: click.Context,
-        bento: str,
-        machine: bool,
-        _bento_store: BentoStore = Provide[BentoMLContainer.bento_store]) -> str | None:
+def cli(ctx: click.Context, bento: str, machine: bool, _bento_store: BentoStore = Provide[BentoMLContainer.bento_store]) -> str | None:
   '''Dive into a BentoLLM. This is synonymous to cd $(b get <bento>:<tag> -o path).'''
   try:
     bentomodel = _bento_store.get(bento)

openllm-python/src/openllm/cli/extension/get_containerfile.py

@@ -19,9 +19,7 @@ from openllm_core.utils import bentoml_cattr
 if t.TYPE_CHECKING:
   from bentoml._internal.bento import BentoStore
 
-@click.command('get_containerfile',
-               context_settings=termui.CONTEXT_SETTINGS,
-               help='Return Containerfile of any given Bento.')
+@click.command('get_containerfile', context_settings=termui.CONTEXT_SETTINGS, help='Return Containerfile of any given Bento.')
 @click.argument('bento', type=str, shell_complete=bento_complete_envvar)
 @click.pass_context
 @inject

openllm-python/src/openllm/cli/extension/get_prompt.py

@@ -32,8 +32,8 @@ LiteralOutput = t.Literal['json', 'pretty', 'porcelain']
               callback=opt_callback,
               metavar='ARG=VALUE[,ARG=VALUE]')
 @click.pass_context
-def cli(ctx: click.Context, /, model_name: str, prompt: str, format: str | None, output: LiteralOutput, machine: bool,
-        _memoized: dict[str, t.Any], **_: t.Any) -> str | None:
+def cli(ctx: click.Context, /, model_name: str, prompt: str, format: str | None, output: LiteralOutput, machine: bool, _memoized: dict[str, t.Any],
+        **_: t.Any) -> str | None:
   '''Get the default prompt used by OpenLLM.'''
   module = openllm.utils.EnvVarMixin(model_name).module
   _memoized = {k: v[0] for k, v in _memoized.items() if v}
@@ -46,15 +46,11 @@ def cli(ctx: click.Context, /, model_name: str, prompt: str, format: str | None,
       if format is None:
         if not hasattr(module, 'PROMPT_MAPPING') or module.PROMPT_MAPPING is None:
           raise RuntimeError('Failed to find prompt mapping while DEFAULT_PROMPT_TEMPLATE is a function.')
-        raise click.BadOptionUsage(
-            'format',
-            f"{model_name} prompt requires passing '--format' (available format: {list(module.PROMPT_MAPPING)})")
+        raise click.BadOptionUsage('format', f"{model_name} prompt requires passing '--format' (available format: {list(module.PROMPT_MAPPING)})")
       if prompt_mapping is None:
-        raise click.BadArgumentUsage(
-            f'Failed to fine prompt mapping while the default prompt for {model_name} is a callable.') from None
+        raise click.BadArgumentUsage(f'Failed to fine prompt mapping while the default prompt for {model_name} is a callable.') from None
       if format not in prompt_mapping:
-        raise click.BadOptionUsage(
-            'format', f'Given format {format} is not valid for {model_name} (available format: {list(prompt_mapping)})')
+        raise click.BadOptionUsage('format', f'Given format {format} is not valid for {model_name} (available format: {list(prompt_mapping)})')
       _prompt_template = template(format)
     else:
       _prompt_template = template

openllm-python/src/openllm/cli/extension/list_bentos.py

@@ -19,26 +19,28 @@ def cli(ctx: click.Context, output: LiteralOutput) -> None:
   '''List available bentos built by OpenLLM.'''
   mapping = {
       k: [{
-          'tag':
-              str(b.tag),
-          'size':
-              human_readable_size(openllm.utils.calc_dir_size(b.path)),
+          'tag': str(b.tag),
+          'size': human_readable_size(openllm.utils.calc_dir_size(b.path)),
           'models': [{
               'tag': str(m.tag),
               'size': human_readable_size(openllm.utils.calc_dir_size(m.path))
-          } for m in (bentoml.models.get(_.tag) for _ in b.info.models)]
-      } for b in tuple(i for i in bentoml.list() if all(
-          k in i.info.labels for k in {'start_name', 'bundler'})) if b.info.labels['start_name'] == k
-         ] for k in tuple(inflection.dasherize(key) for key in openllm.CONFIG_MAPPING.keys())
+          }
+                     for m in (bentoml.models.get(_.tag)
+                               for _ in b.info.models)]
+      }
+          for b in tuple(i
+                         for i in bentoml.list()
+                         if all(k in i.info.labels
+                                for k in {'start_name', 'bundler'}))
+          if b.info.labels['start_name'] == k] for k in tuple(inflection.dasherize(key) for key in openllm.CONFIG_MAPPING.keys())
   }
   mapping = {k: v for k, v in mapping.items() if v}
   if output == 'pretty':
     import tabulate
     tabulate.PRESERVE_WHITESPACE = True
-    termui.echo(tabulate.tabulate(
-        [(k, i['tag'], i['size'], [_['tag'] for _ in i['models']]) for k, v in mapping.items() for i in v],
-        tablefmt='fancy_grid',
-        headers=['LLM', 'Tag', 'Size', 'Models']),
+    termui.echo(tabulate.tabulate([(k, i['tag'], i['size'], [_['tag'] for _ in i['models']]) for k, v in mapping.items() for i in v],
+                                  tablefmt='fancy_grid',
+                                  headers=['LLM', 'Tag', 'Size', 'Models']),
                 fg='white')
   else:
     termui.echo(orjson.dumps(mapping, option=orjson.OPT_INDENT_2).decode(), fg='white')

openllm-python/src/openllm/cli/extension/list_models.py

@@ -26,17 +26,14 @@ def cli(model_name: str | None, output: LiteralOutput) -> DictStrAny:
   models = tuple(inflection.dasherize(key) for key in openllm.CONFIG_MAPPING.keys())
   ids_in_local_store = {
       k: [
-          i for i in bentoml.models.list() if 'framework' in i.info.labels and
-          i.info.labels['framework'] == 'openllm' and 'model_name' in i.info.labels and i.info.labels['model_name'] == k
+          i for i in bentoml.models.list() if 'framework' in i.info.labels and i.info.labels['framework'] == 'openllm' and
+          'model_name' in i.info.labels and i.info.labels['model_name'] == k
       ] for k in models
   }
   if model_name is not None:
     ids_in_local_store = {
-        k: [
-            i
-            for i in v
-            if 'model_name' in i.info.labels and i.info.labels['model_name'] == inflection.dasherize(model_name)
-        ] for k, v in ids_in_local_store.items()
+        k: [i for i in v if 'model_name' in i.info.labels and i.info.labels['model_name'] == inflection.dasherize(model_name)]
+        for k, v in ids_in_local_store.items()
     }
   ids_in_local_store = {k: v for k, v in ids_in_local_store.items() if v}
   local_models = {

openllm-python/src/openllm/cli/extension/playground.py

@@ -34,12 +34,7 @@ def load_notebook_metadata() -> DictStrAny:
 
 @click.command('playground', context_settings=termui.CONTEXT_SETTINGS)
 @click.argument('output-dir', default=None, required=False)
-@click.option('--port',
-              envvar='JUPYTER_PORT',
-              show_envvar=True,
-              show_default=True,
-              default=8888,
-              help='Default port for Jupyter server')
+@click.option('--port', envvar='JUPYTER_PORT', show_envvar=True, show_default=True, default=8888, help='Default port for Jupyter server')
 @click.pass_context
 def cli(ctx: click.Context, output_dir: str | None, port: int) -> None:
   """OpenLLM Playground.
@@ -60,9 +55,7 @@ def cli(ctx: click.Context, output_dir: str | None, port: int) -> None:
   > This command requires Jupyter to be installed. Install it with 'pip install "openllm[playground]"'
   """
   if not is_jupyter_available() or not is_jupytext_available() or not is_notebook_available():
-    raise RuntimeError(
-        "Playground requires 'jupyter', 'jupytext', and 'notebook'. Install it with 'pip install \"openllm[playground]\"'"
-    )
+    raise RuntimeError("Playground requires 'jupyter', 'jupytext', and 'notebook'. Install it with 'pip install \"openllm[playground]\"'")
   metadata = load_notebook_metadata()
   _temp_dir = False
   if output_dir is None:
@@ -74,8 +67,7 @@ def cli(ctx: click.Context, output_dir: str | None, port: int) -> None:
   termui.echo('The playground notebooks will be saved to: ' + os.path.abspath(output_dir), fg='blue')
   for module in pkgutil.iter_modules(playground.__path__):
     if module.ispkg or os.path.exists(os.path.join(output_dir, module.name + '.ipynb')):
-      logger.debug('Skipping: %s (%s)', module.name,
-                   'File already exists' if not module.ispkg else f'{module.name} is a module')
+      logger.debug('Skipping: %s (%s)', module.name, 'File already exists' if not module.ispkg else f'{module.name} is a module')
       continue
     if not isinstance(module.module_finder, importlib.machinery.FileFinder): continue
     termui.echo('Generating notebook for: ' + module.name, fg='magenta')
@@ -84,10 +76,7 @@ def cli(ctx: click.Context, output_dir: str | None, port: int) -> None:
     f.cells.insert(0, markdown_cell)
     jupytext.write(f, os.path.join(output_dir, module.name + '.ipynb'), fmt='notebook')
   try:
-    subprocess.check_output([
-        sys.executable, '-m', 'jupyter', 'notebook', '--notebook-dir', output_dir, '--port',
-        str(port), '--no-browser', '--debug'
-    ])
+    subprocess.check_output([sys.executable, '-m', 'jupyter', 'notebook', '--notebook-dir', output_dir, '--port', str(port), '--no-browser', '--debug'])
   except subprocess.CalledProcessError as e:
     termui.echo(e.output, fg='red')
     raise click.ClickException(f'Failed to start a jupyter server:\n{e}') from None

openllm-python/src/openllm/cli/termui.py

@@ -16,9 +16,5 @@ def echo(text: t.Any, fg: str = 'green', _with_style: bool = True, **attrs: t.An
     t.cast(t.Callable[..., None], click.echo if not _with_style else click.secho)(text, **attrs)
 
 COLUMNS: int = int(os.environ.get('COLUMNS', str(120)))
-CONTEXT_SETTINGS: DictStrAny = {
-    'help_option_names': ['-h', '--help'],
-    'max_content_width': COLUMNS,
-    'token_normalize_func': inflection.underscore
-}
+CONTEXT_SETTINGS: DictStrAny = {'help_option_names': ['-h', '--help'], 'max_content_width': COLUMNS, 'token_normalize_func': inflection.underscore}
 __all__ = ['echo', 'COLUMNS', 'CONTEXT_SETTINGS']