Prints scheduler for user to read.
768884
def pretty_print_schedule(self, hyperband_schedule, describe_hyperband=True):
        
        print("=========================================")
        print("|           Hyperband Schedule          |")
        print("=========================================")
        if describe_hyperband:
            # Print a message indicating what the below schedule means
            print(
                "Table consists of tuples of "
                "(num configs, num_resources_per_config) "
                "which specify how many configs to run and "
                "for how many epochs. "
            )
            print(
                "Each bracket starts with a list of random "
                "configurations which is successively halved "
                "according the schedule."
            )
            print(
                "See the Hyperband paper "
                "(https://arxiv.org/pdf/1603.06560.pdf) for more details."
            )
            print("-----------------------------------------")
        for bracket_index, bracket in enumerate(hyperband_schedule):
            bracket_string = "Bracket %d:" % bracket_index
            for n_i, r_i in bracket:
                bracket_string += " (%d, %d)" % (n_i, r_i)
            print(bracket_string)
        print("-----------------------------------------")
943258
public static void printJobRuns(List<JobExecutionInfo> jobExecutionInfos) {
        if (jobExecutionInfos == null) {
            System.err.println("No job executions found.");
            System.exit(1);
        }

        List<String> labels = Arrays.asList("Job Id", "State", "Schedule", "Completed Tasks", "Launched Tasks",
                "Start Time", "End Time", "Duration (s)");
        List<String> flags = Arrays.asList("-", "-", "-", "", "", "-", "-", "-");
        List<List<String>> data = new ArrayList<>();
        for (JobExecutionInfo jobInfo : jobExecutionInfos) {
            List<String> entry = new ArrayList<>();
            entry.add(jobInfo.getJobId());
            entry.add(jobInfo.getState().toString());
            entry.add(extractJobSchedule(jobInfo));
            entry.add(jobInfo.getCompletedTasks().toString());
            entry.add(jobInfo.getLaunchedTasks().toString());
            entry.add(dateTimeFormatter.print(jobInfo.getStartTime()));
            entry.add(dateTimeFormatter.print(jobInfo.getEndTime()));
            entry.add(jobInfo.getState() == JobStateEnum.COMMITTED ?
                    decimalFormatter.format(jobInfo.getDuration() / 1000.0) : "-");
            data.add(entry);
        }
        new CliTablePrinter.Builder()
                .labels(labels)
                .data(data)
                .flags(flags)
                .delimiterWidth(2)
                .build()
                .printTable();
    }
1076272
def print(cls, *args, **kwargs):
        """"""
        # pylint: disable=protected-access
        with _shared._PRINT_LOCK:
            print(*args, **kwargs)
            _sys.stdout.flush()
469368
def Print(self, output_writer):
    
    if self._date_time_ranges:
      for date_time_range in self._date_time_ranges:
        if date_time_range.start_date_time is None:
          end_time_string = date_time_range.end_date_time.CopyToDateTimeString()
          output_writer.Write('\t{0:s} after {1:s}\n'.format(
              date_time_range.time_value, end_time_string))

        elif date_time_range.end_date_time is None:
          start_time_string = (
              date_time_range.start_date_time.CopyToDateTimeString())
          output_writer.Write('\t{0:s} before {1:s}\n'.format(
              date_time_range.time_value, start_time_string))

        else:
          start_time_string = (
              date_time_range.start_date_time.CopyToDateTimeString())
          end_time_string = date_time_range.end_date_time.CopyToDateTimeString()
          output_writer.Write('\t{0:s} between {1:s} and {2:s}\n'.format(
              date_time_range.time_value, start_time_string,
              end_time_string))
1212799
private void showAdminFormJobComparator(PrintWriter out, boolean advancedView) {
    out.print("<h2>Scheduling Mode</h2>\n");
    String curMode = scheduler.getJobComparator().toString();
    String advParam = advancedView ? "&advanced" : "";
    out.printf("<p>The scheduler is currently using <b>%s mode</b>.",
        generateSelect((Collection<String>)
            Arrays.asList("FAIR,DEFICIT,FIFO".split(",")),
            curMode, "/fairscheduler?setJobComparator=<CHOICE>" + advParam));
  }
828337
def print_settings(settings, depth=0):
    """"""
    # handle the case where a single setting is passed
    if isinstance(settings, Setting):
        settings = [settings]
    for setting in settings:
        cur = setting.currentValue
        print(
            "%s* %s (%s, value: %s, type: %s)"
            % (
                " " * depth,
                setting.title,
                setting.target,
                click.style(cur, bold=True),
                setting.type,
            )
        )
        for opt in setting.candidate:
            if not opt.isAvailable:
                logging.debug("Unavailable setting %s", opt)
                continue
            click.echo(
                click.style(
                    "%s  - %s (%s)" % (" " * depth, opt.title, opt.value),
                    bold=opt.value == cur,
                )
            )
298443
def generate_schedule(today=None):
    """"""
    # We create a list of slots and schedule items
    schedule_days = {}
    seen_items = {}
    for slot in Slot.objects.all().order_by('end_time', 'start_time', 'day'):
        day = slot.get_day()
        if today and day != today:
            # Restrict ourselves to only today
            continue
        schedule_day = schedule_days.get(day)
        if schedule_day is None:
            schedule_day = schedule_days[day] = ScheduleDay(day)
        row = make_schedule_row(schedule_day, slot, seen_items)
        schedule_day.rows.append(row)
    return sorted(schedule_days.values(), key=lambda x: x.day.date)
441492
def cprint(msg, reset=True, template=ColorTemplate):
    
    print(cformat(msg, reset, template))
1192017
private void displayQueueList() throws IOException {
    JobQueueInfo[] queues = jc.getQueues();
    for (JobQueueInfo queue : queues) {
      String schedInfo = queue.getSchedulingInfo();
      if(schedInfo.trim().equals("")){
        schedInfo = "N/A";
      }
      System.out.printf("Queue Name : %s \n", queue.getQueueName());
      System.out.printf("Scheduling Info : %s \n",queue.getSchedulingInfo());
    }
  }
1310827
def print(self, *objects, **kwargs):
		""""""
		file = kwargs.get("file")

		if file is not None and file is not sys.stdout:
			PRINT(*objects, **kwargs)

		else:
			sep = STR(kwargs.get("sep", " "))
			end = STR(kwargs.get("end", "\n"))

			text = sep.join(STR(o) for o in objects)

			self.imp_print(text, end)

		for callback in self.listeners:
			callback(text)
760746
def print_infos(results):
    
    print('transactions: %i' % results.total_transactions)
    print('timers: %i' % results.total_timers)
    print('errors: %i' % results.total_errors)
    print('test start: %s' % results.start_datetime)
    print('test finish: %s\n' % results.finish_datetime)
56290
def _print_jobs(jobs, token_manager, app_url, options):
    
    accountids = set()
    for job in jobs:
        if job['user'] != 'jut.internal.user':
            accountids.add(job['user'])

    account_lookup = {
        'jut.internal.user': {
            'username': 'Jut Internal'
        }
    }

    if accountids:
        accounts_details = accounts.get_accounts(accountids,
                                                 token_manager=token_manager,
                                                 app_url=app_url)

        for account in accounts_details['accounts']:
            account_lookup[account['id']] = account

    if options.format == 'text':
        labels = OrderedDict()
        labels['id'] = 'Job ID'
        labels['alias'] = 'Juttle Name'
        labels['username'] = 'Owner'
        labels['_start_time'] = 'Start Date'
        labels['persistent'] = 'Persistent'

        max_lengths = {
            'id': 0,
            'alias': 0,
            'username': 0,
            '_start_time': 0,
            'persistent': 0,
        }

        for key in max_lengths.keys():
            max_lengths[key] = len(labels[key]) + 1

        # retrieve username and fix up persistent marker
        for job in jobs:
            job['username'] = account_lookup[job['user']]['username']
            job['persistent'] = 'YES' if job['timeout'] == 0 else 'NO'

        # calculate max length of each column
        for job in jobs:
            for key in labels.keys():
                if max_lengths[key] < len(job[key]):
                    max_lengths[key] = len(job[key]) + 1

        # print labels
        header = ''
        for key in labels.keys():
            header += (labels[key] + ' ' * (max_lengths[key] - len(labels[key])))

        info(header)

        for job in jobs:
            line = ''

            for key in labels.keys():
                line += (job[key] + ' ' * (max_lengths[key] - len(job[key])))

            info(line)

    elif options.format == 'table':
        headers = ['Job ID', 'Juttle Name', 'Owner', 'Start Date', 'Persistent']

        table = []
        for job in jobs:
            owner = account_lookup[job['user']]['username']
            persistent = 'YES' if job['timeout'] == 0 else 'NO'
            name = ''

            if 'alias' in job:
                name = job['alias']

            table.append([job['id'],
                          name,
                          owner,
                          job['_start_time'],
                          persistent])

        info(tabulate.tabulate(table, headers, tablefmt="orgtbl"))

    else:
        raise JutException('Unsupported output format "%s"' %
                           options.format)
694607
def pylog(self, *args, **kwargs):
        """"""
        printerr(self.name, args, kwargs, traceback.format_exc())
169644
void print_list() {
	for (int i = 0; i < works.size(); i++) {
	    final WorkItem item = (WorkItem) works.elementAt(i);
	    Util.out4.println("Dev name = " + item.dev.get_name() + ", obj name = " + item.name
		    + ", next wake_up at " + item.wake_up_date.tv_sec + ","
		    + item.wake_up_date.tv_usec);
	}
    }
328005
def print(self, *args, **kwargs):
        '''
        
        '''
        if self._last_args and self._last_args.verbose:
            print(*args, **kwargs)
442797
def logger(self, iteration, ret):
    """"""
    print("Learning rate: {:f}".format(self.lr_scheduler.get_lr()[0]))
    entropies = getEntropies(self.model)
    print("Entropy and max entropy: ", float(entropies[0]), entropies[1])
    print("Training time for epoch=", self.epoch_train_time)
    for noise in self.noise_values:
      print("Noise= {:3.2f}, loss = {:5.4f}, Accuracy = {:5.3f}%".format(
        noise, ret[noise]["loss"], 100.0*ret[noise]["accuracy"]))
    print("Full epoch time =", self.epoch_time)
    if ret[0.0]["accuracy"] > 0.7:
      self.best_noise_score = max(ret[0.1]["accuracy"], self.best_noise_score)
      self.best_epoch = iteration
470218
def _print(self, msg=None, always=False):
        """"""
        if always or not self.commons['cmdlineopts'].quiet:
            if msg:
                print_(msg)
            else:
                print_()