Prints the information stored in the Nimbus::Configuration object

 It could include errors on the configuration input data, training related info and/or testing related info.
546700
def log_configuration
      return if @silent
      if !@do_training && !@do_testing
        Nimbus.message "*" * 50
        Nimbus.message "* Nimbus could not find any input file: "
        Nimbus.message "*   No training file (default: training.data)"
        Nimbus.message "*   No testing file (default: testing.data)"
        Nimbus.message "*   Not defined in config file (default: config.yml)"
        Nimbus.message "* Nothing to do."
        Nimbus.message "*" * 50
        Nimbus.stop "Error: No input data. Nimbus finished."
      end

      Nimbus.message "*" * 50
      Nimbus.message "* Nimbus version #{::Nimbus::VERSION}"
      Nimbus.message "* configured with the following parameters: "
      Nimbus.message "*   Forest size: #{@forest_size} trees"
      Nimbus.message "*   Total SNP count: #{@tree_SNP_total_count}"
      Nimbus.message "*   SNPs sample size (mtry): #{@tree_SNP_sample_size}"
      Nimbus.message "*   Minimun node size in tree: #{@tree_node_min_size}"

      if @classes
        Nimbus.message "*   Mode: CLASSIFICATION"
        Nimbus.message "*     Classes: [#{@classes*', '}]"
      else
        Nimbus.message "*   Mode: REGRESSION"
      end
      Nimbus.message "*" * 50

      if @do_training
        Nimbus.message "* Training data:"
        Nimbus.message "*   Training file: #{@training_file}"
        Nimbus.message "*" * 50
      end

      if @do_testing
        Nimbus.message "* Data to be tested:"
        Nimbus.message "*   Testing file: #{@testing_file}"
        if @forest_file
          Nimbus.message "* using the structure of the random forest stored in:"
          Nimbus.message "*   Random forest file: #{@forest_file}"
        end
        Nimbus.message "*" * 50
      end
    end
705644
def _textOutput(self, gaObjects):
        
        for variant in gaObjects:
            print(
                variant.id, variant.variant_set_id, variant.names,
                variant.reference_name, variant.start, variant.end,
                variant.reference_bases, variant.alternate_bases,
                sep="\t", end="\t")
            for key, value in variant.attributes.attr.items():
                val = value.values[0].string_value
                print(key, val, sep="=", end=";")
            print("\t", end="")
            for c in variant.calls:
                print(
                    c.call_set_id,
                    c.genotype.__str__().replace('\n', ''),
                    c.genotype_likelihood, c.attributes,
                    c.phaseset, sep=":", end="\t")
            print()
198455
def print_env_info(key, out=sys.stderr):
    """"""
    value = os.getenv(key)
    if value is not None:
        print(key, "=", repr(value), file=out)
53331
def print_ctx(ctx):
    
    # Print title
    print_title('ctx attributes')

    # Print context object's attributes
    print_text(dir(ctx))

    # Print end title
    print_title('ctx attributes', is_end=True)

    # Print title
    print_title('ctx.options')

    # Print context options dict
    print_text(pformat(vars(ctx.options), indent=4, width=1))

    # Print end title
    print_title('ctx.options', is_end=True)

    # If the context object has `env` attribute.
    # Notice plain context object not has `env` attribute.
    if hasattr(ctx, 'env'):
        # Print title
        print_title('ctx.env')

        # Print context environment variables dict
        print_text(pformat(dict(ctx.env), indent=4, width=1))

        # Print end title
        print_title('ctx.env', is_end=True)
566450
def _print_exception_list(exceptions, message, output_file=None):
    
    output_file = output_file or sys.stderr
    message = 'Exception %s:\n' % message
    for exc_type, exc_value, exc_traceback in exceptions:
        output_file.write(message)
        traceback.print_exception(exc_type, exc_value, exc_traceback,
                                  file=output_file)
        output_file.write('\n')
814351
def print_report(runner_results):
    
    error_report = collections.defaultdict(list)
    output_report = collections.defaultdict(list)
    success_report = list()
    
    for runner_info in runner_results:
        hostname = runner_info['console']
        error = runner_info['error']
        output = runner_info['output']
        
        if error:
            error_report[error].append(hostname)
        elif output:
            output_report[output].append(hostname)
        else:
            success_report.append(hostname)
            
    if error_report:
        print("Errors : ")
        for error in error_report:
            print("{0} -- [{1}] {2}".format(error.strip(), len(error_report[error]), ", ".join(error_report[error])))
            print()
    
    if output_report:        
        for output in output_report:
            print("{0} -- [{1}] {2}".format(output, len(output_report[output]), ", ".join(output_report[output])))
    
    if success_report:
        print("Completed config on {0} hosts".format(len(success_report)))
742018
private void print(Config config, int indent)
  {
    for(int i = 0; i < indent; ++i) {
      System.out.print("\t");
    }
    System.out.print(config.name);
    System.out.print("\r\n");

    for(Config child : config.children) {
      print(child, indent + 1);
    }
  }
836284
public void print() {
    Iterator<String> iter = getKeys();
    while (iter.hasNext()) {
      String key = iter.next();
      log.info(key + " = " + getRawString(key));
    }
  }
1314169
def info(self):
        
        for key, value in self.dataset['info'].items():
            print('{}: {}'.format(key, value))
246232
def print_context_info(self):
        
        print("Context Version:")
        print('ModernGL:', moderngl.__version__)
        print('vendor:', self.ctx.info['GL_VENDOR'])
        print('renderer:', self.ctx.info['GL_RENDERER'])
        print('version:', self.ctx.info['GL_VERSION'])
        print('python:', sys.version)
        print('platform:', sys.platform)
        print('code:', self.ctx.version_code)
933436
def print_info(self):
        
        table = PrettyTable()
        start_string = "DutSerial {} \n".format(self.name)
        row = []
        info_string = ""
        if self.config:
            info_string = info_string + "Configuration for this DUT:\n\n {} \n".format(self.config)
        if self.comport:
            table.add_column("COM port", [])
            row.append(self.comport)
        if self.port:
            if hasattr(self.port, "baudrate"):
                table.add_column("Baudrate", [])
                row.append(self.port.baudrate)
            if hasattr(self.port, "xonxoff"):
                table.add_column("XON/XOFF", [])
                row.append(self.port.xonxoff)
            if hasattr(self.port, "timeout"):
                table.add_column("Timeout", [])
                row.append(self.port.timeout)
            if hasattr(self.port, "rtscts"):
                table.add_column("RTSCTS", [])
                row.append(self.port.rtscts)
        if self.location:
            table.add_column("Location", [])
            row.append("X = {}, Y = {}".format(self.location.x_coord, self.location.y_coord))
        self.logger.info(start_string)
        self.logger.debug(info_string)
        table.add_row(row)
        print(table)
792928
public void showHelp() {
      System.err.println(applicationDescription);
      System.err.println("===============================================");

      Map<NamedOption, String> optionNames = new HashMap<>();
      optionSet.forEach(option -> {
         String out = Stream.concat(
            Stream.of(option.getAliasSpecifications()),
            Stream.of(option.getSpecification()))
                            .sorted((s1, s2) -> Integer.compare(s1.length(), s2.length()))
                            .collect(Collectors.joining(", "));
         if (option.isRequired()) {
            out += " *";
         }
         optionNames.put(option, out);
      });

      int maxArgName = optionNames.values().stream().mapToInt(String::length).max().orElse(10);

      optionNames.entrySet().stream()
                 .sorted(Map.Entry.comparingByValue())
                 .forEach(entry -> {
                    String arg = entry.getValue();
                    boolean insertSpace = !arg.startsWith("--");
                    if (insertSpace) {
                       System.err.print(" ");
                    }
                    System.err.printf("%1$-" + maxArgName + "s\t", arg);
                    System.err.println(entry.getKey().getDescription());
                 });

      System.err.println("===============================================");
      System.err.println("* = Required");

   }
989227
def printed_out(self, name):
        
        opt = self.variables().optional_namestring()
        req = self.variables().required_namestring()
        out = ''
        out += '|   |\n'
        out += '|   |---{}({}{})\n'.format(name, req, opt)
        if self.description:
            out += '|   |       {}\n'.format(self.description)
        return out
1363051
def error_output(self, message, method_affected=None):
        
        color_fn = self._py3_wrapper.get_config_attribute
        color = color_fn(self.module_full_name, "color_error")
        if hasattr(color, "none_setting"):
            color = color_fn(self.module_full_name, "color_bad")
        if hasattr(color, "none_setting"):
            color = None

        error = {
            "full_text": message,
            "color": color,
            "instance": self.module_inst,
            "name": self.module_name,
        }
        for method in self.methods.values():
            if method_affected and method["method"] != method_affected:
                continue

            method["last_output"] = [error]

        self.allow_config_clicks = False
        self.set_updated()
1367989
def try_printout(data, out, opts, **kwargs):
    '''
    
    '''
    try:
        printout = get_printout(out, opts)(data, **kwargs)
        if printout is not None:
            return printout.rstrip()
    except (KeyError, AttributeError, TypeError):
        log.debug(traceback.format_exc())
        try:
            printout = get_printout('nested', opts)(data, **kwargs)
            if printout is not None:
                return printout.rstrip()
        except (KeyError, AttributeError, TypeError):
            log.error('Nested output failed: ', exc_info=True)
            printout = get_printout('raw', opts)(data, **kwargs)
            if printout is not None:
                return printout.rstrip()
815347
def on_error_print_details(actual, expected):
    
    try:
        yield
    except Exception:
        diff = difflib.ndiff(expected.splitlines(), actual.splitlines())
        diff_text = u"\n".join(diff)
        print(u"DIFF (+ ACTUAL, - EXPECTED):\n{0}\n".format(diff_text))
        if DEBUG:
            print(u"expected:\n{0}\n".format(expected))
            print(u"actual:\n{0}".format(actual))
        raise
1065988
def print(self, *args, **kwargs):
        
        print(self, *args, **kwargs)
        self.data = ''
        return self