class_docstr: Represent and manage a single run of an experiment.
class_docstr_tok: ["Represent","and","manage","a","single","run","of","an","experiment","."]
code: def __init__(
      self,
      config,
      config_modifications,
      main_function,
      observers,
      root_logger,
      run_logger,
      experiment_info,
      host_info,
      pre_run_hooks,
      post_run_hooks,
      captured_out_filter=None,
  ):
      self._id = None
      """The ID of this run as assigned by the first observer"""
  
      self.captured_out = ""
      """Captured stdout and stderr"""
  
      self.config = config
      """The final configuration used for this run"""
  
      self.config_modifications = config_modifications
      """A ConfigSummary object with information about config changes"""
  
      self.experiment_info = experiment_info
      """A dictionary with information about the experiment"""
  
      self.host_info = host_info
      """A dictionary with information about the host"""
  
      self.info = {}
      """Custom info dict that will be sent to the observers"""
  
      self.root_logger = root_logger
      """The root logger that was used to create all the others"""
  
      self.run_logger = run_logger
      """The logger that is used for this run"""
  
      self.main_function = main_function
      """The main function that is executed with this run"""
  
      self.observers = observers
      """A list of all observers that observe this run"""
  
      self.pre_run_hooks = pre_run_hooks
      """List of pre-run hooks (captured functions called before this run)"""
  
      self.post_run_hooks = post_run_hooks
      """List of post-run hooks (captured functions called after this run)"""
  
      self.result = None
      """The return value of the main function"""
  
      self.status = None
      """The current status of the run, from QUEUED to COMPLETED"""
  
      self.start_time = None
      """The datetime when this run was started"""
  
      self.stop_time = None
      """The datetime when this run stopped"""
  
      self.debug = False
      """Determines whether this run is executed in debug mode"""
  
      self.pdb = False
      """If true the pdb debugger is automatically started after a failure"""
  
      self.meta_info = {}
      """A custom comment for this run"""
  
      self.beat_interval = SETTINGS.DEFAULT_BEAT_INTERVAL  # sec
      """The time between two heartbeat events measured in seconds"""
  
      self.unobserved = False
      """Indicates whether this run should be unobserved"""
  
      self.force = False
      """Disable warnings about suspicious changes"""
  
      self.queue_only = False
      """If true then this run will only fire the queued_event and quit"""
  
      self.captured_out_filter = captured_out_filter
      """Filter function to be applied to captured output"""
  
      self.fail_trace = None
      """A stacktrace, in case the run failed"""
  
      self.capture_mode = None
      """Determines the way the stdout/stderr are captured"""
  
      self._heartbeat = None
      self._failed_observers = []
      self._output_file = None
  
      self._metrics = metrics_logger.MetricsLogger()
  
imports: import datetime
  import os.path
  import sys
  import traceback
  from sacred import metrics_logger, SETTINGS
  from sacred.metrics_logger import linearize_metrics
  from sacred.randomness import set_global_seed
  from sacred.utils import SacredInterrupt, join_paths, IntervalTimer
  from sacred.stdout_capturing import get_stdcapturer
label_desc: Use image node_id 1 to create a new Run object  with example: obj = Run(config, config_modifications, main_function, observers, root_logger, run_logger, experiment_info, host_info, pre_run_hooks, post_run_hooks, captured_out_filter)