code: def parse_size(size, binary=False):
      """
      Parse a human readable data size and return the number of bytes.
      Match humanfriendly.parse_size
  
      :param size: The human readable file size to parse (a string).
      :param binary: :data:`True` to use binary multiples of bytes (base-2) for
                     ambiguous unit symbols and names, :data:`False` to use
                     decimal multiples of bytes (base-10).
      :returns: The corresponding size in bytes (an integer).
      :raises: :exc:`InvalidSize` when the input can't be parsed.
  
      This function knows how to parse sizes in bytes, kilobytes, megabytes,
      gigabytes, terabytes and petabytes. Some examples:
          >>> parse_size('42')
          42
          >>> parse_size('13b')
          13
          >>> parse_size('5 bytes')
          5
          >>> parse_size('1 KB')
          1000
          >>> parse_size('1 kilobyte')
          1000
          >>> parse_size('1 KiB')
          1024
          >>> parse_size('1 KB', binary=True)
          1024
          >>> parse_size('1.5 GB')
          1500000000
          >>> parse_size('1.5 GB', binary=True)
          1610612736
      """
  
      def tokenize(text):
          tokenized_input = []
          for token in re.split(r"(\d+(?:\.\d+)?)", text):
              token = token.strip()
              if re.match(r"\d+\.\d+", token):
                  tokenized_input.append(float(token))
              elif token.isdigit():
                  tokenized_input.append(int(token))
              elif token:
                  tokenized_input.append(token)
          return tokenized_input
  
      tokens = tokenize(str(size))
      if tokens and isinstance(tokens[0], (int, float)):
          disk_size_units_b = (
              ("B", "bytes"),
              ("KiB", "kibibyte"),
              ("MiB", "mebibyte"),
              ("GiB", "gibibyte"),
              ("TiB", "tebibyte"),
              ("PiB", "pebibyte"),
          )
          disk_size_units_d = (
              ("B", "bytes"),
              ("KB", "kilobyte"),
              ("MB", "megabyte"),
              ("GB", "gigabyte"),
              ("TB", "terabyte"),
              ("PB", "petabyte"),
          )
          disk_size_units_b = [
              (1024**i, s[0], s[1])
              for i, s in enumerate(disk_size_units_b)
          ]
          k = 1024 if binary else 1000
          disk_size_units_d = [
              (k**i, s[0], s[1])
              for i, s in enumerate(disk_size_units_d)
          ]
          disk_size_units = (
              (disk_size_units_b + disk_size_units_d)
              if binary
              else (disk_size_units_d + disk_size_units_b)
          )
  
          # Get the normalized unit (if any) from the tokenized input.
          normalized_unit = (
              tokens[1].lower()
              if len(tokens) == 2 and isinstance(tokens[1], str)
              else ""
          )
          # If the input contains only a number, it's assumed to be the number of
          # bytes. The second token can also explicitly reference the unit bytes.
          if len(tokens) == 1 or normalized_unit.startswith("b"):
              return int(tokens[0])
          # Otherwise we expect two tokens: A number and a unit.
          if normalized_unit:
              # Convert plural units to singular units, for details:
              # https://github.com/xolox/python-humanfriendly/issues/26
              normalized_unit = normalized_unit.rstrip("s")
              for k, low, high in disk_size_units:
                  # First we check for unambiguous symbols (KiB, MiB, GiB, etc)
                  # and names (kibibyte, mebibyte, gibibyte, etc) because their
                  # handling is always the same.
                  if normalized_unit in (low.lower(), high.lower()):
                      return int(tokens[0] * k)
                  # Now we will deal with ambiguous prefixes (K, M, G, etc),
                  # symbols (KB, MB, GB, etc) and names (kilobyte, megabyte,
                  # gigabyte, etc) according to the caller's preference.
                  if normalized_unit in (
                      low.lower(),
                      high.lower(),
                  ) or normalized_unit.startswith(low.lower()):
                      return int(tokens[0] * k)
  
      raise ValueError(
          "Failed to parse size! (input {} was tokenized as {})".format(
              size, tokens
          )
      )
  
imports: import fnmatch
  import hashlib
  import json
  import os
  import re
  import sys
  from typing import Optional, Union, Sequence, Dict
  from zlib import crc32
  import six
  from pathlib2 import Path
  from six.moves.urllib.parse import quote, urlparse, urlunparse
  from ..debugging.log import LoggerRoot
label_desc: Use image node_id 11 for calling a global function with example usage: parse_size(size, binary) and returns: tokenized_input, int, int, int