



'''simple docstring'''


_lowerCamelCase	:       str      	=	"ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/"







def 				__lowerCamelCase				(   A__    )       ->	bytes:






   """simple docstring"""
   # Make sure the supplied data is a bytes-like object
   if not isinstance(A__    ,						A__    ):
      UpperCamelCase					=  F"""a bytes-like object is required, not '{data.__class__.__name__}'"""
      raise TypeError(A__    )

   UpperCamelCase					=  ''.join(bin(A__    )[2:].zfill(8    ) for byte in data    )

   UpperCamelCase					=  len(A__    ) % 6 != 0

   if padding_needed:
      # The padding that will be added later
      UpperCamelCase					=  B'=' * ((6 - len(A__    ) % 6) // 2)

      # Append binary_stream with arbitrary binary digits (0's by default) to make its
      # length a multiple of 6.
      binary_stream += "0" * (6 - len(A__    ) % 6)
   else:
      UpperCamelCase					=  B''

   # Encode every 6 binary digits to their corresponding Base64 character
   return (
       "".join(
           B64_CHARSET[int(binary_stream[index : index + 6]    ,						2    )]
           for index in range(0    ,						len(A__    )    ,						6    )    ).encode()
       + padding
   )







def 				__lowerCamelCase				(   A__    )       ->	bytes:






   """simple docstring"""
   # Make sure encoded_data is either a string or a bytes-like object
   if not isinstance(A__    ,						A__    ) and not isinstance(A__    ,						A__    ):
      UpperCamelCase					=  (
          'argument should be a bytes-like object or ASCII string, '
          F"""not '{encoded_data.__class__.__name__}'"""
      )
      raise TypeError(A__    )

   # In case encoded_data is a bytes-like object, make sure it contains only
   # ASCII characters so we convert it to a string object
   if isinstance(A__    ,						A__    ):
      try:
         UpperCamelCase					=  encoded_data.decode('utf-8'    )
      except UnicodeDecodeError:
         raise ValueError('base64 encoded data should only contain ASCII characters'    )

   UpperCamelCase					=  encoded_data.count('='    )

   # Check if the encoded string contains non base64 characters
   if padding:
      assert all(
          char in B64_CHARSET for char in encoded_data[:-padding]    ), "Invalid base64 character(s) found."
   else:
      assert all(
          char in B64_CHARSET for char in encoded_data    ), "Invalid base64 character(s) found."

   # Check the padding
   assert len(A__    ) % 4 == 0 and padding < 3, "Incorrect padding"

   if padding:
      # Remove padding if there is one
      UpperCamelCase					=  encoded_data[:-padding]

      UpperCamelCase					=  ''.join(
          bin(B64_CHARSET.index(A__    )    )[2:].zfill(6    ) for char in encoded_data    )[: -padding * 2]
   else:
      UpperCamelCase					=  ''.join(
          bin(B64_CHARSET.index(A__    )    )[2:].zfill(6    ) for char in encoded_data    )

   UpperCamelCase					=  [
       int(binary_stream[index : index + 8]    ,						2    )
       for index in range(0    ,						len(A__    )    ,						8    )
   ]

   return bytes(A__    )


if __name__ == "__main__":
   import doctest

   doctest.testmod()






'''simple docstring'''


_lowerCamelCase	:       int      	=	"0.21.0"

from .accelerator import Accelerator
from .big_modeling import (
    cpu_offload,
    cpu_offload_with_hook,
    disk_offload,
    dispatch_model,
    init_empty_weights,
    init_on_device,
    load_checkpoint_and_dispatch,
)
from .data_loader import skip_first_batches
from .launchers import debug_launcher, notebook_launcher
from .state import PartialState
from .utils import (
    DeepSpeedPlugin,
    DistributedDataParallelKwargs,
    DistributedType,
    FullyShardedDataParallelPlugin,
    GradScalerKwargs,
    InitProcessGroupKwargs,
    find_executable_batch_size,
    infer_auto_device_map,
    is_rich_available,
    load_checkpoint_in_model,
    synchronize_rng_states,
)


if is_rich_available():
   from .utils import rich

