





"""simple docstring"""






A 			=  '''ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/'''

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

				__a :						Any			       =  ''''''.join(bin(a_)[2:].zfill(8) for byte in data)

				__a :						List[str]			       =  len(a_) % 6 != 0

				if padding_needed:
								# The padding that will be added later
								__a :						List[str]			       =  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:
								__a :						int			       =  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     __A      (			a_						:str)		->		bytes:
				# Make sure encoded_data is either a string or a bytes-like object
				if not isinstance(a_   ,       a_) and not isinstance(a_   ,       a_):
								__a :						Optional[int]			       =  (
								    '''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:
												__a :						Any			       =  encoded_data.decode('''utf-8''')
								except UnicodeDecodeError:
												raise ValueError('''base64 encoded data should only contain ASCII characters''')

				__a :						List[str]			       =  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
								__a :						str			       =  encoded_data[:-padding]

								__a :						int			       =  ''''''.join(
								    bin(B64_CHARSET.index(a_))[2:].zfill(6) for char in encoded_data)[: -padding * 2]
				else:
								__a :						Dict			       =  ''''''.join(
								    bin(B64_CHARSET.index(a_))[2:].zfill(6) for char in encoded_data)

				__a :						Any			       =  [
				    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"""






from dataclasses import dataclass, field
from typing import ClassVar, Dict

from ..features import Features, Value
from .base import TaskTemplate




@dataclass(frozen=_UpperCamelCase							)
class 				__lowercase			(			_UpperCamelCase							):







					'''simple docstring'''




					__lowerCAmelCase  =  field(default='''language-modeling'''   ,      metadata={'''include_in_asdict_even_if_is_default''': True}							)

					__lowerCAmelCase  =  Features({'''text''': Value('''string'''							)}							)
					__lowerCAmelCase  =  Features({}							)
					__lowerCAmelCase  =  "text"







					@property
					def  _lowerCamelCase		(						self     ):
									return {self.text_column: "text"}