Lists entries stored in the specified bank.
333902
def list_(bank):
    '''
    
    '''
    redis_server = _get_redis_server()
    bank_redis_key = _get_bank_redis_key(bank)
    try:
        banks = redis_server.smembers(bank_redis_key)
    except (RedisConnectionError, RedisResponseError) as rerr:
        mesg = 'Cannot list the Redis cache key {rkey}: {rerr}'.format(rkey=bank_redis_key,
                                                                       rerr=rerr)
        log.error(mesg)
        raise SaltCacheError(mesg)
    if not banks:
        return []
    return list(banks)
328411
def _from_list_record(data):
    
    return [Schema._get_field_entry('Column%d' % (i + 1), value) for i, value in enumerate(data)]
1078601
function ListCache(entries) {
  var this$1 = this;

  var index = -1,
      length = entries == null ? 0 : entries.length;

  this.clear();
  while (++index < length) {
    var entry = entries[index];
    this$1.set(entry[0], entry[1]);
  }
}
131556
def listSecrets(region=None, table="credential-store", **kwargs):
    '''
    
    '''
    session = get_session(**kwargs)

    dynamodb = session.resource('dynamodb', region_name=region)
    secrets = dynamodb.Table(table)

    last_evaluated_key = True
    items = []

    while last_evaluated_key:
        params = dict(
            ProjectionExpression="#N, version, #C",
            ExpressionAttributeNames={"#N": "name", "#C": "comment"}
        )
        if last_evaluated_key is not True:
            params['ExclusiveStartKey'] = last_evaluated_key

        response = secrets.scan(**params)

        last_evaluated_key = response.get('LastEvaluatedKey')  # will set last evaluated key to a number
        items.extend(response['Items'])

    return items
843700
def use_isolated_bank_view(self):
        """"""
        self._bank_view = ISOLATED
        # self._get_provider_session('item_lookup_session') # To make sure the session is tracked
        for session in self._get_provider_sessions():
            try:
                session.use_isolated_bank_view()
            except AttributeError:
                pass
795852
def entries
      return [] unless exists?

      @entries ||=
        Utils.safe_glob(collection_dir, ["**", "*"], File::FNM_DOTMATCH).map do |entry|
          entry["#{collection_dir}/"] = ""
          entry
        end
    end
165386
def fetch_entries(self):
        """"""
        data = []
        for row in self.get_rows():
            # Stop fetching data if limit has been met
            if exceeded_limit(self.limit, len(data)):
                break

            entry = row.find_all('td')
            entry_dict = {}

            show = entry[0].string
            net = entry[1].string
            if not self._match_query(show, net):
                continue

            entry_dict['show'] = show
            entry_dict['net'] = net
            entry_dict['time'] = entry[2].string

            if ',' in entry[3].string:
                entry_dict['viewers'] = entry[3].string.replace(',', '.')
            else:
                entry_dict['viewers'] = '0.' + entry[3].string
            entry_dict['rating'] = entry[4].string

            # Add data to create cable entry
            data.append(Entry(**entry_dict))

        return data
499794
def listtransactions(self, account="", many=999, since=0):
        """"""
        return self.req("listtransactions", [account, many, since])
609224
def listIterators(self, login, tableName):
    
    self.send_listIterators(login, tableName)
    return self.recv_listIterators()
589868
def get_list_database(self):
        """"""
        url = "db"

        response = self.request(
            url=url,
            method='GET',
            expected_response_code=200
        )

        return response.json()
208405
def get_banks(self):
        """"""
        # Implemented from kitosid template for -
        # osid.resource.BinLookupSession.get_bins_template
        catalogs = self._get_provider_session('bank_lookup_session').get_banks()
        cat_list = []
        for cat in catalogs:
            cat_list.append(Bank(self._provider_manager, cat, self._runtime, self._proxy))
        return BankList(cat_list)
1041041
def list(cls,
             l,
             order=None,
             header=None,
             output="table",
             sort_keys=True,
             show_none=""
             ):
        
        d = {}
        count = 0
        for entry in l:
            name = str(count)
            d[name] = entry
            count += 1
        return cls.dict(d,
                        order=order,
                        header=header,
                        sort_keys=sort_keys,
                        output=output,
                        show_none=show_none)
129389
def list_records(self, limit=None, offset=None):
        
        return self.manager.list_records(self, limit=limit, offset=offset)
644838
def list(gandi, domain, zone_id, output, format, limit):
    """"""
    options = {
        'items_per_page': limit,
    }
    output_keys = ['name', 'type', 'value', 'ttl']

    if not zone_id:
        result = gandi.domain.info(domain)
        zone_id = result['zone_id']

    if not zone_id:
        gandi.echo('No zone records found, domain %s doesn\'t seems to be '
                   'managed at Gandi.' % domain)
        return

    records = gandi.record.list(zone_id, options)

    if not output and not format:
        for num, rec in enumerate(records):
            if num:
                gandi.separator_line()
            output_generic(gandi, rec, output_keys, justify=12)
    elif output:
        zone_filename = domain + "_" + str(zone_id)
        if os.path.isfile(zone_filename):
            open(zone_filename, 'w').close()
        for record in records:
            format_record = ('%s %s IN %s %s' %
                             (record['name'], record['ttl'],
                              record['type'], record['value']))
            with open(zone_filename, 'ab') as zone_file:
                zone_file.write(format_record + '\n')
        gandi.echo('Your zone file have been writen in %s' % zone_filename)
    elif format:
        if format == 'text':
            for record in records:
                format_record = ('%s %s IN %s %s' %
                                 (record['name'], record['ttl'],
                                  record['type'], record['value']))
                gandi.echo(format_record)
        if format == 'json':
            format_record = json.dumps(records, sort_keys=True,
                                       indent=4, separators=(',', ': '))
            gandi.echo(format_record)

    return records
716285
def as_list(self, fs_type=None):
        """"""
        entries = self._entries
        if fs_type:
            entries = filter(lambda a: a.fs_type == fs_type, entries)
        return entries
186522
def list_service(ctx, name):
    """"""
    swag = create_swag_from_ctx(ctx)
    accounts = swag.get_service_enabled(name)

    _table = [[result['name'], result.get('id')] for result in accounts]
    click.echo(
        tabulate(_table, headers=["Account Name", "Account Number"])
    )
422104
def machine_listings_to_file_entries(listings: Iterable[dict]) -> \
        Iterable[FileEntry]:
    ''''''
    for listing in listings:
        yield FileEntry(
            listing['name'],
            type=listing.get('type'),
            size=listing.get('size'),
            date=listing.get('modify')
        )