List of model output names.
187124
def output_names(self) -> Iterable[str]:
        """"""
        self._load_models()
        return chain.from_iterable(map(lambda m: m.output_names, self._models))
784262
def _load_output_data_port_models(self):
        
        self.output_data_ports = []
        for output_data_port in self.state.output_data_ports.values():
            self._add_model(self.output_data_ports, output_data_port, DataPortModel)
994322
def _show_outputs(self):
        
        outs = self._get_outputs()
        print("\n\n" + '=> Terraform Outputs:')
        for k in sorted(outs):
            print('%s = %s' % (k, outs[k]))
303928
def _output_to_list(cmdoutput):
    '''
    
    '''
    return [item for line in cmdoutput.splitlines() if _safe_output(line) for item in line.split()]
1310077
def outputtemplates(self):
        """"""
        outputtemplates = []
        for o in self.output:
            if isinstance(o, ParameterCondition):
                outputtemplates += o.allpossibilities()
            else:
                assert isinstance(o, OutputTemplate)
                outputtemplates.append(o)
        return outputtemplates
1122406
def map_hmms(input_model, mapping):
    

    output_model = copy.copy(input_model)

    o_hmms = []
    for i_hmm in input_model['hmms']:
        i_hmm_name = i_hmm['name']
        o_hmm_names = mapping.get(i_hmm_name, [i_hmm_name])

        for o_hmm_name in o_hmm_names:
            o_hmm = copy.copy(i_hmm)
            o_hmm['name'] = o_hmm_name

            o_hmms.append(o_hmm)

    output_model['hmms'] = o_hmms

    return output_model
1148862
def outputs(ctx, client, revision, paths):
    
    """
    graph = Graph(client)
    filter = graph.build(paths=paths, revision=revision)
    output_paths = graph.output_paths

    click.echo('\n'.join(graph._format_path(path) for path in output_paths))

    if paths:
        if not output_paths:
            ctx.exit(1)

        from renku.models._datastructures import DirectoryTree
        tree = DirectoryTree.from_list(item.path for item in filter)

        for output in output_paths:
            if tree.get(output) is None:
                ctx.exit(1)
                return
1066939
def _descriptor_names(self):
        

        descriptor_names = []

        for name in dir(self):
            try:
                attr = getattr(type(self), name)

                if isinstance(attr, DJANGO_RELATED_FIELD_DESCRIPTOR_CLASSES):
                    descriptor_names.append(name)

            except AttributeError:
                pass

        return descriptor_names
395283
def list_names(cls):
        """"""
        response = subwrap.run(['lxc-ls'])
        output = response.std_out
        return map(str.strip, output.splitlines())
140155
def auto_model_name_recognize(model_name):
    
    name_list = model_name.split('-')
    return ''.join(['%s%s' % (name[0].upper(), name[1:]) for name in name_list])
449688
def models(self):
        """"""
        Model_ = self.app.config['PEEWEE_MODELS_CLASS']
        ignore = self.app.config['PEEWEE_MODELS_IGNORE']

        models = []
        if Model_ is not Model:
            try:
                mod = import_module(self.app.config['PEEWEE_MODELS_MODULE'])
                for model in dir(mod):
                    models = getattr(mod, model)
                    if not isinstance(model, pw.Model):
                        continue
                    models.append(models)
            except ImportError:
                return models
        elif isinstance(Model_, BaseSignalModel):
            models = BaseSignalModel.models

        return [m for m in models if m._meta.name not in ignore]
818769
def list_models(args: argparse.Namespace):
    
    try:
        git_index = GitIndex(remote=args.index_repo, username=args.username,
                             password=args.password, cache=args.cache, log_level=args.log_level)
    except ValueError:
        return 1
    for model_type, models in git_index.models.items():
        print(model_type)
        default = git_index.meta[model_type]["default"]
        for uuid, model in sorted(models.items(),
                                  key=lambda m: parse_datetime(m[1]["created_at"]),
                                  reverse=True):
            print("  %s %s" % ("*" if default == uuid else " ", uuid),
                  model["created_at"])
1339572
async def ListModels(self, tag):
        '''
        
        '''
        # map input types to rpc msg
        _params = dict()
        msg = dict(type='ModelManager',
                   request='ListModels',
                   version=5,
                   params=_params)
        _params['tag'] = tag
        reply = await self.rpc(msg)
        return reply
1282431
def _get_input_names(spec):
    
    retval = [feature.name for feature in spec.description.input]
    return retval
994569
def list_model_columns(obj)
      items = obj.class.columns.map{ |col| info_pair(col.name, obj[col.name]) }
      content_tag(:ul, convert_to_list_items(items), :class => "model_columns")
    end
323235
def flatten_models(models):
        "  "
        if isinstance(models, MultiFitterModel):
            ans = [models]
        else:
            tasklist = MultiFitter._compile_models(models)
            ans = MultiFitter._flatten_models(tasklist)
        return ans
1133152
def get_layer_names(self):
    
    layer_names = [x.name for x in self.model.layers]
    return layer_names