



'''simple docstring'''


lowercase_      :				List[str]   					=    '''ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/'''







def      SCREAMING_SNAKE_CASE				(				lowercase_    :      bytes						):
						# Make sure the supplied data is a bytes-like object
						if not isinstance(lowercase_ ,  lowercase_						):
												lowercase        =							F"""a bytes-like object is required, not '{data.__class__.__name__}'"""
												raise TypeError(lowercase_						)

						lowercase        =							"""""".join(bin(lowercase_						)[2:].zfill(8						) for byte in data						)

						lowercase        =							len(lowercase_						) % 6 != 0

						if padding_needed:
												# The padding that will be added later
												lowercase        =							B"""=""" * ((6 - len(lowercase_						) % 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(lowercase_						) % 6)
						else:
												lowercase        =							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(lowercase_						) ,  6						)						).encode()
						    + padding
						)







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

						# 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(lowercase_ ,  lowercase_						):
												try:
																		lowercase        =							encoded_data.decode("""utf-8"""						)
												except UnicodeDecodeError:
																		raise ValueError("""base64 encoded data should only contain ASCII characters"""						)

						lowercase        =							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(lowercase_						) % 4 == 0 and padding < 3, "Incorrect padding"

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

												lowercase        =							"""""".join(
												    bin(B64_CHARSET.index(lowercase_						)						)[2:].zfill(6						) for char in encoded_data						)[: -padding * 2]
						else:
												lowercase        =							"""""".join(
												    bin(B64_CHARSET.index(lowercase_						)						)[2:].zfill(6						) for char in encoded_data						)

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

						return bytes(lowercase_						)


if __name__ == "__main__":
						import doctest

						doctest.testmod()







'''simple docstring'''


# coding=utf-8
# Copyright 2023 The HuggingFace Inc. team.
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
#     http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.

# this script dumps information about the environment

import os
import platform
import sys


lowercase_      :				List[str]   					=    '''3'''

print('''Python version:''', sys.version)

print('''OS platform:''', platform.platform())
print('''OS architecture:''', platform.machine())

try:
						import torch

						print('''Torch version:''', torch.__version__)
						print('''Cuda available:''', torch.cuda.is_available())
						print('''Cuda version:''', torch.version.cuda)
						print('''CuDNN version:''', torch.backends.cudnn.version())
						print('''Number of GPUs available:''', torch.cuda.device_count())
except ImportError:
						print('''Torch version:''', None)

try:
						import transformers

						print('''transformers version:''', transformers.__version__)
except ImportError:
						print('''transformers version:''', None)


