Print a list of projects registered for that experiment.

    Args:
        exp: The experiment to print all projects for.
483995
def print_projects(projects=None):
    
    grouped_by = {}
    if not projects:
        print(
            "Your selection didn't include any projects for this experiment.")
        return

    for name in projects:
        prj = projects[name]

        if prj.GROUP not in grouped_by:
            grouped_by[prj.GROUP] = []

        grouped_by[prj.GROUP].append("{name}/{group}".format(
            name=prj.NAME, group=prj.GROUP))

    for name in grouped_by:
        print("group: {0}".format(name))
        group_projects = sorted(grouped_by[name])
        for prj in group_projects:
            prj_cls = projects[prj]

            version_str = None
            if hasattr(prj_cls, 'versions'):
                version_str = ", ".join(prj_cls.versions())

            project_id = "{0}/{1}".format(prj_cls.NAME, prj_cls.GROUP)

            project_str = \
                "  name: {id:<32} version: {version:<24} source: {src}".format(
                    id=str(project_id),
                    version=str(prj_cls.VERSION),
                    src=str(prj_cls.SRC_FILE))
            print(project_str)
            if prj_cls.__doc__:
                docstr = prj_cls.__doc__.strip("\n ")
                print("    description: {desc}".format(desc=docstr))
            if version_str:
                print("    versions: {versions}".format(versions=version_str))
        print()
276846
def load_experiments(folders):
    '''
    '''
    experiments = []
    if isinstance(folders,str):
        folders = [experiment_folders]
    for folder in folders:
        exp = load_experiment(folder)
        experiments.append(exp)
    return experiments
856896
def p_print_list(p):
    
    p[0] = p[1]
    p[0].eol = (p[3] is not None)

    if p[3] is not None:
        p[0].appendChild(p[3])
323141
def info(self):
        """"""

        print("Sorry, but I don't have much to share.")
        print("This is me:")
        print(self)
        print("And these are the experiments assigned to me:")
        print(self.experiments)
1280397
def list_experiments(self, collection_name):
        
        exp = ExperimentResource(
            name='', collection_name=collection_name, coord_frame='foo')
        return self._list_resource(exp)
1175480
def print_results(matches):
    
    output = ""
    for n, match in enumerate(matches):
        matched_text = match[0][:40]+"..." if len(match[0]) > 40 else match[0]
        search_result = match[1]
        if search_result.uri==surf.ns.EFRBROO['F10_Person']:
            label = unicode(search_result)[:40]+"..." if len(unicode(search_result)) > 40 else unicode(search_result)
            print("\n{:5}) {:50} {:40} (Matched: \"{}\")\n".format(n+1, label, search_result.get_urn(), matched_text))
        elif search_result.uri==surf.ns.EFRBROO['F1_Work']:
            label = "{}, {}".format(search_result.author, search_result)
            label = label[:40]+"..." if len(label) > 40 else label
            print("\n{:5}) {:50} {:40} (Matched: \"{}\")\n".format(n+1, label, search_result.get_urn(), matched_text))
714368
def project_map(self):
        """"""
        # first update with the experiments in the memory (the others should
        # already be loaded within the :attr:`exp_files` attribute)
        for key, val in self.items():
            if isinstance(val, dict):
                l = self._project_map[val['project']]
            elif isinstance(val, Archive):
                l = self._project_map[val.project]
            else:
                continue
            if key not in l:
                l.append(key)
        return self._project_map
1027179
def print_logs(query, types=None):
    
    if query is None:
        return

    for run, log in query:
        print(("{0} @ {1} - {2} id: {3} group: {4} status: {5}".format(
            run.end, run.experiment_name, run.project_name,
            run.experiment_group, run.run_group, log.status)))
        print(("command: {0}".format(run.command)))
        if "stderr" in types:
            print("StdErr:")
            print((log.stderr))
        if "stdout" in types:
            print("StdOut:")
            print((log.stdout))
        print()
1101763
def names_from_exp(exp):
  ""
  def match(exp):
    return isinstance(exp, (sqparse2.NameX, sqparse2.AttrX))
  paths = treepath.sub_slots(exp, match, match=True, recurse_into_matches=False)
  return [exp[path] for path in paths]
655470
function experiments(fn) {
  enqueue(function() {
    var data = {};
    var ids = window._vwo_exp_ids;
    if (!ids) return fn();
    each(ids, function(id) {
      var name = variation(id);
      if (name) data['Experiment: ' + id] = name;
    });
    fn(null, data);
  });
}
1098931
def visit_generatorexp(self, node):
        """"""
        return "(%s %s)" % (
            node.elt.accept(self),
            " ".join(n.accept(self) for n in node.generators),
        )
771908
def print_desc(desc, verbose=False):
    '''
    
    '''
    if desc['class'] in ['project', 'workspace', 'container']:
        print_project_desc(desc, verbose=verbose)
    elif desc['class'] == 'app':
        print_app_desc(desc, verbose=verbose)
    elif desc['class'] == 'globalworkflow':
        print_globalworkflow_desc(desc, verbose=verbose)
    elif desc['class'] in ['job', 'analysis']:
        print_execution_desc(desc)
    elif desc['class'] == 'user':
        print_user_desc(desc)
    elif desc['class'] in ['org', 'team']:
        print_generic_desc(desc)
    else:
        print_data_obj_desc(desc, verbose=verbose)
651760
def list_records_for_project(id=None, name=None, page_size=200, page_index=0, sort="", q=""):
    
    data = list_records_for_project_raw(id, name, page_size, page_index, sort, q)
    if data:
        return utils.format_json_list(data)
733880
def run_all(logdir, verbose=False):
  
  writer = tf.summary.FileWriter(logdir)
  writer.add_summary(create_experiment_summary())
  writer.close()
  session_num = 0
  num_sessions = (len(TEMPERATURE_LIST)*len(TEMPERATURE_LIST)*
                  len(HEAT_COEFFICIENTS)*2)
  for initial_temperature in TEMPERATURE_LIST:
    for ambient_temperature in TEMPERATURE_LIST:
      for material in HEAT_COEFFICIENTS:
        hparams = {u'initial_temperature': initial_temperature,
                   u'ambient_temperature': ambient_temperature,
                   u'material': material}
        hparam_str = str(hparams)
        group_name = fingerprint(hparam_str)
        for repeat_idx in xrange(2):
          session_id = str(session_num)
          if verbose:
            print('--- Running training session %d/%d' % (session_num + 1,
                                                          num_sessions))
            print(hparam_str)
            print('--- repeat #: %d' % (repeat_idx+1))
          run(logdir, session_id, hparams, group_name)
          session_num += 1
997498
def experiment_list(args):
    ''''''
    experiment_config = Experiments()
    experiment_dict = experiment_config.get_all_experiments()
    if not experiment_dict:
        print('There is no experiment running...')
        exit(1)
    update_experiment()
    experiment_id_list = []
    if args.all and args.all == 'all':
        for key in experiment_dict.keys():
            experiment_id_list.append(key)
    else:
        for key in experiment_dict.keys():
            if experiment_dict[key]['status'] != 'STOPPED':
                experiment_id_list.append(key)
        if not experiment_id_list:
            print_warning('There is no experiment running...\nYou can use \'nnictl experiment list all\' to list all stopped experiments!')
    experiment_information = ""
    for key in experiment_id_list:
        
        experiment_information += (EXPERIMENT_DETAIL_FORMAT % (key, experiment_dict[key]['status'], experiment_dict[key]['port'],\
        experiment_dict[key].get('platform'), experiment_dict[key]['startTime'], experiment_dict[key]['endTime']))
    print(EXPERIMENT_INFORMATION_FORMAT % experiment_information)
234688
def print_values(self, parameter):
        
        if parameter in self.VALUES:
            self.print_info(u"Available values for parameter '%s':" % parameter)
            self.print_generic(u"\n".join(self.VALUES[parameter]))
            return self.HELP_EXIT_CODE
        if parameter not in [u"?", u""]:
            self.print_error(u"Invalid parameter name '%s'" % parameter)
        self.print_info(u"Parameters for which values can be listed:")
        self.print_generic(u"\n".join(sorted(self.VALUES.keys())))
        return self.HELP_EXIT_CODE
968695
def list_ext(self, collection, path, retrieve_all, **_params):
        """"""
        return self.list(collection, path, retrieve_all, **_params)