list(Operation): List of the slithir operations
327632
def slithir_operations(self):
        
        if self._slithir_operations is None:
            operations = [n.irs for n in self.nodes]
            operations = [item for sublist in operations for item in sublist if item]
            self._slithir_operations = operations
        return self._slithir_operations
334613
def list(self, filterfn=lambda x: True):
        
        return [self / p for p in self.listdir() if filterfn(self / p)]
594903
def list(self, channels=None, server=""):
        """"""
        self.send_items('LIST', ','.join(always_iterable(channels)), server)
1346276
def list(self):
        
        logger.debug('Sending FTP list command.')
        self.state['file_list'] = []
        self.state['dir_list'] = []
        self.client.retrlines('LIST', self._process_list)
11305
def list_by_cid(self):
        
        prs = self._processors
        return sorted(((cid, [prs[cid]]) for cid in sorted(prs.keys())),
                      key=operator.itemgetter(0))
349574
private List<E> remoteList() {
        List<E> result = (List<E>) cache.get(key);
        return result == null ? (List<E>) Collections.emptyList() : result;
    }
1131635
def lists(self):
        
        # Prepare the lists to be used to classify the metagenomes
        with open(self.filelist, 'w') as filelist:
            with open(self.reportlist, 'w') as reportlist:
                for sample in self.runmetadata.samples:
                    if self.extension == 'fastq':
                        try:
                            status = sample.run.Description
                            if status == 'metagenome':
                                filelist.write(sample.general.combined + '\n')
                                reportlist.write(sample.general.combined.split('.')[0] + '\n')
                        except AttributeError:
                            pass
                    else:
                        if sample.general.combined != 'NA':
                            filelist.write(sample.general.combined + '\n')
                            reportlist.write(sample.general.combined.split('.')[0] + '\n')
152217
def list(self, argv):
        """"""

        def read(index):
            print(index.name)
            for key in sorted(index.content.keys()): 
                value = index.content[key]
                print("    %s: %s" % (key, value))

        if len(argv) == 0:
            for index in self.service.indexes:
                count = index['totalEventCount']
                print("%s (%s)" % (index.name, count))
        else:
            self.foreach(argv, read)
1179900
def asList(self):
        
        return [self._red, self._green, self._blue, self._alpha]
155165
def do_list(self, line):
        '''
        
        '''
        repo_names = self.network.repo_names
        print('Known repos:')
        print('    ' + '\n    '.join(repo_names))
771118
def list(self, limit=None, offset=None):
        """"""
        uri = "/%s%s" % (self.uri_base, self._get_pagination_qs(limit, offset))
        return self._list(uri)
1023940
def as_list(self):
        ""
        netloc = ''
        if self.vpath_connector:
            netloc = '(('+self.vpath_connector+'))'
        elif self.authority:
            netloc = self.authority
        else:
            netloc = self.netloc
        return [
            self.scheme,
            netloc,
            self.path,
            self.query,
            '',
            ]
1058036
def list_strip(list_, to_strip, left=True, right=True):
    
    import utool as ut
    flags = [item != to_strip for item in list_]
    flag_lists = []
    if right:
        rstrip_flags = ut.cumsum(flags[::-1])[::-1]
        flag_lists.append(rstrip_flags)
    if left:
        lstrip_flags = ut.cumsum(flags)
        flag_lists.append(lstrip_flags)
    strip_flags = ut.and_lists(*flag_lists)
    stripped_list = ut.compress(list_, strip_flags)
    return stripped_list
343369
function getList() {
  if(!COMMAND_LIST) {
    COMMAND_LIST = [];
    for(var z in this.execs) {
      COMMAND_LIST.push(this.execs[z].definition.getDefinition());
    }
  }
  return COMMAND_LIST;
}
1051207
def do_list(self):
        """"""
        # Default to listing probes.
        if (self._args.probes, self._args.targets, self._args.boards) == (False, False, False):
            self._args.probes = True
        
        # Create a session with no device so we load any config.
        session = Session(None,
                            project_dir=self._args.project_dir,
                            config_file=self._args.config,
                            no_config=self._args.no_config,
                            pack=self._args.pack,
                            **convert_session_options(self._args.options)
                            )
        
        if self._args.probes:
            ConnectHelper.list_connected_probes()
        elif self._args.targets:
            # Create targets from provided CMSIS pack.
            if ('pack' in session.options) and (session.options['pack'] is not None):
                pack_target.PackTargets.populate_targets_from_pack(session.options['pack'])

            obj = ListGenerator.list_targets()
            pt = self._get_pretty_table(["Name", "Vendor", "Part Number", "Families", "Source"])
            for info in sorted(obj['targets'], key=lambda i: i['name']):
                pt.add_row([
                            info['name'],
                            info['vendor'],
                            info['part_number'],
                            ', '.join(info['part_families']),
                            info['source'],
                            ])
            print(pt)
        elif self._args.boards:
            obj = ListGenerator.list_boards()
            pt = self._get_pretty_table(["ID", "Name", "Target", "Test Binary"])
            for info in sorted(obj['boards'], key=lambda i: i['id']):
                pt.add_row([
                            info['id'],
                            info['name'],
                            info['target'],
                            info['binary']
                            ])
            print(pt)
562524
@SuppressWarnings("unchecked")
    private List<String> operations(Map<String, Object> ops) {
        List<String> result = new LinkedList<>();
        for (String operation : ops.keySet()) {
            Object operationOrListOfOperations = ops.get(operation);
            List<Map<String, Object>> toStringify;
            if (operationOrListOfOperations instanceof List) {
                toStringify = (List<Map<String, Object>>) operationOrListOfOperations;
            } else {
                toStringify = Collections.singletonList((Map<String, Object>) operationOrListOfOperations);
            }
            for (Map<String, Object> op : toStringify) {
                List<Map<String, String>> args = (List<Map<String, String>>) op.get("args");
                result.add(operation + "(" + argsToString(args) + ")");
            }
        }

        return result;
    }
177463
def list_containers(self):
        
        data = run_cmd(["machinectl", "list", "--no-legend", "--no-pager"],
                       return_output=True)
        output = []
        reg = re.compile(r"\s+")
        for line in data.split("\n"):
            stripped = line.strip()
            if stripped:
                parts = reg.split(stripped)
                name = parts[0]
                output.append(self.ContainerClass(None, None, name=name))
        return output