def size_to_bytes(n) -> int:
""" Convert size like 1024M, 1024MB, 1024Gi, 1024GiB, or 1024 (bytes) to binary bytes """
# autodetect suffix (eg, 1024M or 1024Gi)
matches = re.findall("(\d+)([a-zA-Z](i)?)?", str(n))
n, unit, si = matches[0]
units = {
"E": DecimalUnits.EB,
"P": DecimalUnits.PB,
"T": DecimalUnits.TB,
"G": DecimalUnits.GB,
"M": DecimalUnits.MB,
"K": DecimalUnits.KB,
"Ei": BinaryUnits.EB,
"Pi": BinaryUnits.PB,
"Ti": BinaryUnits.TB,
"Gi": BinaryUnits.GB,
"Mi": BinaryUnits.MB,
"Ki": BinaryUnits.KB,
}
n = int(n)
# value considered in bytes
if not unit:
return n
unit = units[unit]
value_bytes, _ = convert_units(n, unit=unit, to=BinaryUnits.B)
return int(value_bytes)
def get_unit_formatter(unit):
if unit == 'dynamic':
unit = None
else:
unit = get_unit(unit)
return lambda n: format_units(unit, *convert_units(n, to=unit))
def test_megabyte(self):
assert convert_units(1, dunits.YB,
dunits.MB) == (dunits.YB / 1000**2, 'MB')
def test_exabyte(self):
assert convert_units(dunits.EB,
si=True) == (dunits.EB / dunits.EB, 'EB')
assert convert_units(dunits.ZB - 1,
si=True) == ((dunits.ZB - 1) / dunits.EB, 'EB')
def test_yottabyte(self):
assert convert_units(dunits.YB,
si=True) == (dunits.YB / dunits.YB, 'YB')
def test_megabyte(self):
assert convert_units(dunits.MB,
si=True) == (dunits.MB / dunits.MB, 'MB')
assert convert_units(dunits.GB - 1,
si=True) == ((dunits.GB - 1) / dunits.MB, 'MB')
def test_terabyte(self):
assert convert_units(dunits.TB,
si=True) == (dunits.TB / dunits.TB, 'TB')
assert convert_units(dunits.PB - 1,
si=True) == ((dunits.PB - 1) / dunits.TB, 'TB')
def test_yottabyte(self):
assert convert_units(1, dunits.YB,
dunits.YB) == (dunits.YB / 1000**8, 'YB')
def test_byte(self):
assert convert_units(bunits.B) == (bunits.B, 'B')
assert convert_units(bunits.KB - 1) == (bunits.KB - 1, 'B')
assert convert_units(dunits.B, si=True) == (dunits.B, 'B')
assert convert_units(dunits.KB - 1, si=True) == (dunits.KB - 1, 'B')
def test_exabyte(self):
assert convert_units(1, dunits.YB,
dunits.EB) == (dunits.YB / 1000**6, 'EB')
def test_zettabyte(self):
assert convert_units(1, dunits.YB,
dunits.ZB) == (dunits.YB / 1000**7, 'ZB')
def test_petabyte(self):
assert convert_units(1, dunits.YB,
dunits.PB) == (dunits.YB / 1000**5, 'PB')
def test_terabyte(self):
assert convert_units(1, dunits.YB,
dunits.TB) == (dunits.YB / 1000**4, 'TB')
def test_gigabyte(self):
assert convert_units(1, dunits.YB,
dunits.GB) == (dunits.YB / 1000**3, 'GB')
def test_yobibyte(self):
assert convert_units(bunits.YB) == (bunits.YB / bunits.YB, 'YiB')
def test_kibibyte(self):
assert convert_units(bunits.KB) == (bunits.KB / bunits.KB, 'KiB')
assert convert_units(bunits.MB - 1) == ((bunits.MB - 1) / bunits.KB,
'KiB')
def test_kilobyte(self):
assert convert_units(dunits.KB,
si=True) == (dunits.KB / dunits.KB, 'KB')
assert convert_units(dunits.MB - 1,
si=True) == ((dunits.MB - 1) / dunits.KB, 'KB')
def test_mebibyte(self):
assert convert_units(bunits.MB) == (bunits.MB / bunits.MB, 'MiB')
assert convert_units(bunits.GB - 1) == ((bunits.GB - 1) / bunits.MB,
'MiB')
def test_gigabyte(self):
assert convert_units(dunits.GB,
si=True) == (dunits.GB / dunits.GB, 'GB')
assert convert_units(dunits.TB - 1,
si=True) == ((dunits.TB - 1) / dunits.GB, 'GB')
def test_gibibyte(self):
assert convert_units(bunits.GB) == (bunits.GB / bunits.GB, 'GiB')
assert convert_units(bunits.TB - 1) == ((bunits.TB - 1) / bunits.GB,
'GiB')
def test_petabyte(self):
assert convert_units(dunits.PB,
si=True) == (dunits.PB / dunits.PB, 'PB')
assert convert_units(dunits.EB - 1,
si=True) == ((dunits.EB - 1) / dunits.PB, 'PB')
def test_tebibyte(self):
assert convert_units(bunits.TB) == (bunits.TB / bunits.TB, 'TiB')
assert convert_units(bunits.PB - 1) == ((bunits.PB - 1) / bunits.TB,
'TiB')
def test_zettabyte(self):
assert convert_units(dunits.ZB,
si=True) == (dunits.ZB / dunits.ZB, 'ZB')
assert convert_units(dunits.YB - 1,
si=True) == ((dunits.YB - 1) / dunits.ZB, 'ZB')
def test_pebibyte(self):
assert convert_units(bunits.PB) == (bunits.PB / bunits.PB, 'PiB')
assert convert_units(bunits.EB - 1) == ((bunits.EB - 1) / bunits.PB,
'PiB')
def test_to(self):
with pytest.raises(ValueError):
convert_units(1, to=5)
def test_exbibyte(self):
assert convert_units(bunits.EB) == (bunits.EB / bunits.EB, 'EiB')
assert convert_units(bunits.ZB - 1) == ((bunits.ZB - 1) / bunits.EB,
'EiB')
def kilobytes_to_bytes(kb):
return convert_units(kb, unit=KILOBYTE, to=BYTE)[0]
def test_zebibyte(self):
assert convert_units(bunits.ZB) == (bunits.ZB / bunits.ZB, 'ZiB')
assert convert_units(bunits.YB - 1) == ((bunits.YB - 1) / bunits.ZB,
'ZiB')
def pypinfo(
ctx,
project,
fields,
auth,
run,
json,
indent,
timeout,
limit,
days,
start_date,
end_date,
month,
where,
order,
all_installers,
percent,
markdown,
verbose,
):
"""Valid fields are:\n
project | version | file | pyversion | percent3 | percent2 | impl | impl-version |\n
openssl | date | month | year | country | installer | installer-version |\n
setuptools-version | system | system-release | distro | distro-version | cpu
"""
if auth:
set_credentials(auth)
click.echo('Credentials location set to "{}".'.format(get_credentials()))
return
if verbose:
click.echo('Credentials location set to "{}".'.format(get_credentials()), err=True)
if project is None and not fields:
click.echo(ctx.get_help())
return
parsed_fields = []
for field in fields:
parsed = FIELD_MAP.get(field)
if parsed is None:
raise ValueError('"{}" is an unsupported field.'.format(field))
parsed_fields.append(parsed)
order_name = order
order = FIELD_MAP.get(order)
if order:
order_name = order.name
parsed_fields.insert(0, order)
if month:
start_date, end_date = month_ends(month)
built_query = build_query(
project,
parsed_fields,
limit=limit,
days=days,
start_date=start_date,
end_date=end_date,
where=where,
order=order_name,
pip=not all_installers,
)
if run:
client = create_client(get_credentials())
query_job = client.query(built_query, job_config=create_config())
query_rows = query_job.result(timeout=timeout // 1000)
# Cached
from_cache = not not query_job.cache_hit
# Processed
bytes_processed = query_job.total_bytes_processed or 0
processed_amount, processed_unit = convert_units(bytes_processed)
# Billed
bytes_billed = query_job.total_bytes_billed or 0
billed_amount, billed_unit = convert_units(bytes_billed)
# Cost
billing_tier = query_job.billing_tier or 1
estimated_cost = Decimal(TIER_COST * billing_tier) / TB * Decimal(bytes_billed)
estimated_cost = str(estimated_cost.quantize(TO_CENTS, rounding=ROUND_UP))
rows = parse_query_result(query_job, query_rows)
if len(rows) == 1 and not json:
# Only headers returned
click.echo("No data returned, check project name")
return
if percent:
rows = add_percentages(rows, include_sign=not json)
# Only for tables, and if more than the header row + a single data row
if len(rows) > 2 and not json:
rows = add_download_total(rows)
if not json:
click.echo('Served from cache: {}'.format(from_cache))
click.echo('Data processed: {:.2f} {}'.format(processed_amount, processed_unit))
click.echo('Data billed: {:.2f} {}'.format(billed_amount, billed_unit))
click.echo('Estimated cost: ${}'.format(estimated_cost))
click.echo()
click.echo(tabulate(rows, markdown))
else:
query_info = {
'cached': from_cache,
'bytes_processed': bytes_processed,
'bytes_billed': bytes_billed,
'estimated_cost': estimated_cost,
}
click.echo(format_json(rows, query_info, indent))
else:
click.echo(built_query)
def test_kilobyte(self):
assert convert_units(1, dunits.YB,
dunits.KB) == (dunits.YB / 1000**1, 'KB')
