code: def run(args):
      """Run an operation.
  
      By default Guild tries to run `OPERATION` for the default model
      defined in the current project.
  
      If `MODEL` is specified, Guild uses it instead of the default
      model.
  
      `OPERATION` may alternatively be a Python script. In this case any
      current project is ignored and the script is run directly. Options
      in the format ``--NAME=VAL`` can be passed to the script using
      flags (see below).
  
      `[MODEL]:OPERATION` may be omitted if `--restart` or `--proto` is
      specified, in which case the operation used in `RUN` is used.
  
      Specify `FLAG` values in the form `FLAG=VAL`.
  
      ### Batch Files
  
      One or more batch files can be used to run multiple trials by
      specifying the file path as `@PATH`.
  
      For example, to run trials specified in a CSV file named
      `trials.csv`, run:
  
          guild run [MODEL:]OPERATION @trials.csv
  
      NOTE: At this time you must specify the operation with batch files
      - batch files only contain flag values and cannot be used to run
      different operations for the same command.
  
      Batch files may be formatted as CSV, JSON, or YAML. Format is
      determined by the file extension.
  
      Each entry in the file is used as a set of flags for a trial run.
  
      CSV files must have a header row containing the flag names. Each
      subsequent row is a corresponding list of flag values that Guild
      uses for a generated trial.
  
      JSON and YAML files must contain a top-level list of flag-to-value
      maps.
  
      Use `--print-trials` to preview the trials run for the specified
      batch files.
  
      ### Flag Lists
  
      A list of flag values may be specified using the syntax
      `[VAL1[,VAL2]...]`. Lists containing white space must be
      quoted. When a list of values is provided, Guild generates a trial
      run for each value. When multiple flags have list values, Guild
      generates the cartesian product of all possible flag combinations.
  
      Flag lists may be used to perform grid search operations.
  
      For example, the following generates four runs for operation
      `train` and flags `learning-rate` and `batch-size`:
  
          guild run train learning-rate[0.01,0.1] batch-size=[10,100]
  
      You can preview the trials generated from flag lists using
      `--print-trials`. You can save the generated trials to a batch
      file using `--save-trials`. For more information, see PREVIEWING
      AND SAVING TRIALS below.
  
      When `--optimizer` is specified, flag lists may take on different
      meaning depending on the type of optimizer. For example, the
      `random` optimizer randomly selects values from a flag list,
      rather than generate trials for each value. See OPTIMIZERS for
      more information.
  
      ### Optimizers
  
      A run may be optimized using `--optimizer`. An optimizer runs up
      to `--max-trials` runs using flag values and flag configuration.
  
      For details on available optimizers and their behavior, refer to
      https://guild.ai/optimizers/.
  
      ### Limit Trials
  
      When using flag lists or optimizers, which generate trials, you
      can limit the number of trials with `--max-trials`. By default,
      Guild limits the number of generated trials to 20.
  
      Guild limits trials by randomly sampling the maximum number from
      the total list of generated files. You can specify the seed used
      for the random sample with `--random-seed`. The random seed is
      guaranteed to generate consistent results when used on the same
      version of Python. When used across different versions of Python,
      the results may be inconsistent.
  
      ### Preview or Save Trials
  
      When flag lists (used for grid search) or an optimizer is used,
      you can preview the generated trials using `--print-trials`. You
      can save the generated trials as a CSV batch file using
      `--save-trials`.
  
      ### Start an Operation Using a Prototype Run
  
      If `--proto` is specified, Guild applies the operation, flags, and
      source code used in `RUN` to the new operation. You may add or
      redefine flags in the new operation. You may use an alternative
      operation, in which case only the flag values and source code from
      `RUN` are applied. `RUN` must be a run ID or unique run ID prefix.
  
      ### Restart an Operation
  
      If `--restart` is specified, `RUN` is restarted using its
      operation and flags. Unlike `--proto`, restart does not create a
      new run. You cannot change the operation, flags, source code, or
      run directory when restarting a run.
  
      ### Staging an Operation
  
      Use `--stage` to stage an operation to be run later. Use `--start`
      with the staged run ID to start it.
  
      If `--start` is specified, `RUN` is started using the same rules
      applied to `--restart` (see above).
  
      ### Alternate Run Directory
  
      To run an operation outside of Guild's run management facility,
      use `--run-dir` or `--stage-dir` to specify an alternative run
      directory. These options are useful when developing or debugging
      an operation. Use `--stage-dir` to prepare a run directory for an
      operation without running the operation itself. This is useful
      when you want to verify run directory layout or manually run an
      operation in a prepared directory.
  
      **NOTE:** Runs started with `--run-dir` are not visible to Guild
      and do not appear in run listings.
  
      ### Control Visible GPUs
  
      By default, operations have access to all available GPU
      devices. To limit the GPU devices available to a run, use
      `--gpus`.
  
      For example, to limit visible GPU devices to `0` and `1`, run:
  
          guild run --gpus 0,1 ...
  
      To disable all available GPUs, use `--no-gpus`.
  
      **NOTE:** `--gpus` and `--no-gpus` are used to construct the
      `CUDA_VISIBLE_DEVICES` environment variable used for the run
      process. If `CUDA_VISIBLE_DEVICES` is set, using either of these
      options redefines that environment variable for the run.
  
      ### Optimize Runs
  
      Use `--optimizer` to run the operation multiple times in attempt
      to optimize a result. Use `--minimize` or `--maximize` to indicate
      what should be optimized. Use `--max-runs` to indicate the maximum
      number of runs the optimizer should generate.
  
      ### Edit Flags
  
      Use `--edit-flags` to use an editor to review and modify flag
      values. Guild uses the editor defined in `VISUAL` or `EDITOR`
      environment variables. If neither environment variable is defined,
      Guild uses an editor suitable for the current platform.
  
      ### Debug Source Code
  
      Use `--debug-sourcecode` to specify the location of project source
      code for debugging. Guild uses this path instead of the location
      of the copied soure code for the run. For example, when debugging
      project files, use this option to ensure that modules are loaded
      from the project location rather than the run directory.
  
      ### Breakpoints
  
      Use `--break` to set breakpoints for Python based operations.
      `LOCATION` may be specified as `[FILENAME:]LINE` or as
      `MODULE.FUNCTION`.
  
      If `FILENAME` is not specified, the main module is assumed. Use
      the value ``1`` to break at the start of the main module (line 1).
  
      Relative file names are resolved relative to the their location in
      the Python system path. You can omit the `.py` extension.
  
      If a line number does not correspond to a valid breakpoint, Guild
      attempts to set a breakpoint on the next valid breakpoint line in
      the applicable module.
  
      """
      from . import run_impl
  
      with click_util.CmdContext("guild.run", args):
          run_impl.main(args)
  
imports: import click
  from guild import click_util
  from .None import ac_support
  from .None import remote_support
label_desc: Use image node_id 21 for calling a global function with example usage: run(args) without return types