Python utils.prt_bytes函数代码示例

def stat_container(conn, options, args, thread_manager):
    headers = conn.head_container(args[0])
    if options.verbose > 1:
        path = '%s/%s' % (conn.url, args[0])
        thread_manager.print_items((
            ('URL', path),
            ('Auth Token', conn.token),
        ))
    object_count = prt_bytes(
        headers.get('x-container-object-count', 0),
        options.human).lstrip()
    bytes_used = prt_bytes(headers.get('x-container-bytes-used', 0),
                           options.human).lstrip()
    thread_manager.print_items((
        ('Account', conn.url.rsplit('/', 1)[-1]),
        ('Container', args[0]),
        ('Objects', object_count),
        ('Bytes', bytes_used),
        ('Read ACL', headers.get('x-container-read', '')),
        ('Write ACL', headers.get('x-container-write', '')),
        ('Sync To', headers.get('x-container-sync-to', '')),
        ('Sync Key', headers.get('x-container-sync-key', '')),
    ))
    thread_manager.print_headers(headers,
                                 meta_prefix='x-container-meta-',
                                 exclude_headers=(
                                     'content-length', 'date',
                                     'x-container-object-count',
                                     'x-container-bytes-used',
                                     'x-container-read',
                                     'x-container-write',
                                     'x-container-sync-to',
                                     'x-container-sync-key'))

def stat_account(conn, options, thread_manager):
    headers = conn.head_account()
    if options.verbose > 1:
        thread_manager.print_items((
            ('StorageURL', conn.url),
            ('Auth Token', conn.token),
        ))
    container_count = int(headers.get('x-account-container-count', 0))
    object_count = prt_bytes(headers.get('x-account-object-count', 0),
                             options.human).lstrip()
    bytes_used = prt_bytes(headers.get('x-account-bytes-used', 0),
                           options.human).lstrip()
    thread_manager.print_items((
        ('Account', conn.url.rsplit('/', 1)[-1]),
        ('Containers', container_count),
        ('Objects', object_count),
        ('Bytes', bytes_used),
    ))
    thread_manager.print_headers(headers,
                                 meta_prefix='x-account-meta-',
                                 exclude_headers=(
                                     'content-length', 'date',
                                     'x-account-container-count',
                                     'x-account-object-count',
                                     'x-account-bytes-used'))

def stat_container(conn, options, container):
    headers = conn.head_container(container)
    items = []
    if options['verbose'] > 1:
        path = '%s/%s' % (conn.url, container)
        items.extend([
            ('URL', path),
            ('Auth Token', conn.token)
        ])
    object_count = prt_bytes(
        headers.get('x-container-object-count', 0),
        options['human']).lstrip()
    bytes_used = prt_bytes(headers.get('x-container-bytes-used', 0),
                           options['human']).lstrip()
    items.extend([
        ('Account', conn.url.rsplit('/', 1)[-1]),
        ('Container', container),
        ('Objects', object_count),
        ('Bytes', bytes_used),
        ('Read ACL', headers.get('x-container-read', '')),
        ('Write ACL', headers.get('x-container-write', '')),
        ('Sync To', headers.get('x-container-sync-to', '')),
        ('Sync Key', headers.get('x-container-sync-key', ''))
    ])
    return items, headers

def stat_account(conn, options):
    items = []
    req_headers = split_request_headers(options.get('header', []))

    headers = conn.head_account(headers=req_headers)
    if options['verbose'] > 1:
        items.extend([
            ('StorageURL', conn.url),
            ('Auth Token', conn.token),
        ])
    container_count = int(headers.get('x-account-container-count', 0))
    object_count = prt_bytes(headers.get('x-account-object-count', 0),
                             options['human']).lstrip()
    bytes_used = prt_bytes(headers.get('x-account-bytes-used', 0),
                           options['human']).lstrip()
    items.extend([
        ('Account', conn.url.rsplit('/', 1)[-1]),
        ('Containers', container_count),
        ('Objects', object_count),
        ('Bytes', bytes_used),
    ])

    policies = set()
    for header_key, header_value in headers.items():
        if header_key.lower().startswith(POLICY_HEADER_PREFIX):
            policy_name = header_key.rsplit('-', 2)[0].split('-', 4)[-1]
            policies.add(policy_name)

    for policy in policies:
        container_count_header = (POLICY_HEADER_PREFIX + policy +
                                  '-container-count')
        if container_count_header in headers:
            items.append(
                ('Containers in policy "' + policy + '"',
                 prt_bytes(headers[container_count_header],
                           options['human']).lstrip())
            )
        items.extend((
            ('Objects in policy "' + policy + '"',
             prt_bytes(
                 headers.get(
                     POLICY_HEADER_PREFIX + policy + '-object-count', 0),
                 options['human']
             ).lstrip()),
            ('Bytes in policy "' + policy + '"',
             prt_bytes(
                 headers.get(
                     POLICY_HEADER_PREFIX + policy + '-bytes-used', 0),
                 options['human']
             ).lstrip()),
        ))

    return items, headers

def stat_account(conn, options, thread_manager):
    items_to_print = []

    headers = conn.head_account()
    if options.verbose > 1:
        items_to_print.extend((
            ('StorageURL', conn.url),
            ('Auth Token', conn.token),
        ))
    container_count = int(headers.get('x-account-container-count', 0))
    object_count = prt_bytes(headers.get('x-account-object-count', 0),
                             options.human).lstrip()
    bytes_used = prt_bytes(headers.get('x-account-bytes-used', 0),
                           options.human).lstrip()
    items_to_print.extend((
        ('Account', conn.url.rsplit('/', 1)[-1]),
        ('Containers', container_count),
        ('Objects', object_count),
        ('Bytes', bytes_used),
    ))
    policies = set()
    exclude_policy_headers = []
    ps_header_prefix = 'x-account-storage-policy-'
    for header_key, header_value in headers.items():
        if header_key.lower().startswith(ps_header_prefix):
            policy_name = header_key.rsplit('-', 2)[0].split('-', 4)[-1]
            policies.add(policy_name)
            exclude_policy_headers.append(header_key)
    for policy in policies:
        items_to_print.extend((
            ('Objects in policy "' + policy + '"',
             prt_bytes(headers.get(ps_header_prefix + policy + '-object-count',
                                   0), options.human).lstrip()),
            ('Bytes in policy "' + policy + '"',
             prt_bytes(headers.get(ps_header_prefix + policy + '-bytes-used',
                                   0), options.human).lstrip()),
        ))

    items_to_print.extend(thread_manager.headers_to_items(
        headers, meta_prefix='x-account-meta-',
        exclude_headers=([
            'content-length', 'date',
            'x-account-container-count',
            'x-account-object-count',
            'x-account-bytes-used'] + exclude_policy_headers)))
    # line up the items nicely
    offset = max(len(item) for item, value in items_to_print)
    thread_manager.print_items(items_to_print, offset=offset)

def stat_object(conn, options, args, thread_manager):
    headers = conn.head_object(args[0], args[1])
    if options.verbose > 1:
        path = '%s/%s/%s' % (conn.url, args[0], args[1])
        thread_manager.print_items((
            ('URL', path),
            ('Auth Token', conn.token),
        ))
    content_length = prt_bytes(headers.get('content-length', 0),
                               options.human).lstrip()
    thread_manager.print_items((
        ('Account', conn.url.rsplit('/', 1)[-1]),
        ('Container', args[0]),
        ('Object', args[1]),
        ('Content Type', headers.get('content-type')),
        ('Content Length', content_length),
        ('Last Modified', headers.get('last-modified')),
        ('ETag', headers.get('etag')),
        ('Manifest', headers.get('x-object-manifest')),
    ), skip_missing=True)
    thread_manager.print_headers(headers,
                                 meta_prefix='x-object-meta-',
                                 exclude_headers=(
                                     'content-type', 'content-length',
                                     'last-modified', 'etag', 'date',
                                     'x-object-manifest'))

def stat_object(conn, options, container, obj):
    headers = conn.head_object(container, obj)
    items = []
    if options['verbose'] > 1:
        path = '%s/%s/%s' % (conn.url, container, obj)
        items.extend([
            ('URL', path),
            ('Auth Token', conn.token)
        ])
    content_length = prt_bytes(headers.get('content-length', 0),
                               options['human']).lstrip()
    items.extend([
        ('Account', conn.url.rsplit('/', 1)[-1]),
        ('Container', container),
        ('Object', obj),
        ('Content Type', headers.get('content-type')),
        ('Content Length', content_length),
        ('Last Modified', headers.get('last-modified')),
        ('ETag', headers.get('etag')),
        ('Manifest', headers.get('x-object-manifest'))
    ])
    return items, headers

 def test_one_byte(self):
     bytes_ = 1
     raw = '1'
     human = '1'
     self.assertEqual(raw, u.prt_bytes(bytes_, False).lstrip())
     self.assertEqual(human, u.prt_bytes(bytes_, True).lstrip())

 def test_ten_meg(self):
     bytes_ = 10 * 2 ** 20
     human = '10M'
     self.assertEqual(human, u.prt_bytes(bytes_, True).lstrip())

 def test_one_meg(self):
     bytes_ = 2 ** 20
     raw = '1048576'
     human = '1.0M'
     self.assertEqual(raw, u.prt_bytes(bytes_, False).lstrip())
     self.assertEqual(human, u.prt_bytes(bytes_, True).lstrip())

 def test_just_a_hair_less_than_one_meg(self):
     bytes_ = (2 ** 20) - (2 ** 10) + 1
     raw = '1047553'
     human = '1.0M'
     self.assertEqual(raw, u.prt_bytes(bytes_, False).lstrip())
     self.assertEqual(human, u.prt_bytes(bytes_, True).lstrip())

 def test_a_bit_less_than_one_meg(self):
     bytes_ = (2 ** 20) - (2 ** 10)
     raw = '1047552'
     human = '1023K'
     self.assertEqual(raw, u.prt_bytes(bytes_, False).lstrip())
     self.assertEqual(human, u.prt_bytes(bytes_, True).lstrip())

 def test_a_decimal_k(self):
     bytes_ = (3 * 2 ** 10) + 512
     raw = '3584'
     human = '3.5K'
     self.assertEqual(raw, u.prt_bytes(bytes_, False).lstrip())
     self.assertEqual(human, u.prt_bytes(bytes_, True).lstrip())

 def test_one_k(self):
     bytes_ = 2 ** 10
     raw = '1024'
     human = '1.0K'
     self.assertEqual(raw, u.prt_bytes(bytes_, False).lstrip())
     self.assertEqual(human, u.prt_bytes(bytes_, True).lstrip())

 def test_less_than_one_k(self):
     bytes_ = (2 ** 10) - 1
     raw = '1023'
     human = '1023'
     self.assertEqual(raw, u.prt_bytes(bytes_, False).lstrip())
     self.assertEqual(human, u.prt_bytes(bytes_, True).lstrip())