






"""simple docstring"""





import os
from dataclasses import dataclass, field
from io import BytesIO
from typing import TYPE_CHECKING, Any, ClassVar, Dict, Optional, Union

import numpy as np
import pyarrow as pa

from .. import config
from ..download.streaming_download_manager import xopen, xsplitext
from ..table import array_cast
from ..utils.py_utils import no_op_if_value_is_null, string_to_dict


if TYPE_CHECKING:
							from .features import FeatureType


__lowerCamelCase		,					__lowerCamelCase		,					__lowerCamelCase							=  False, False, False



@dataclass
class       __A		:
					UpperCAmelCase__								=				None
					UpperCAmelCase__								=				True
					UpperCAmelCase__								=				True
					UpperCAmelCase__								=				None
					# Automatically constructed
					UpperCAmelCase__								=				"dict"
					UpperCAmelCase__								=				pa.struct({"bytes": pa.binary(), "path": pa.string()}			)
					UpperCAmelCase__								=				field(default="Audio"     ,init=lowerCAmelCase__     ,repr=lowerCAmelCase__			)

					def __call__(			self  :      Union[str, Any]					)			->							Optional[int]:
											return self.pa_type

					def   lowerCamelCase__   (			self  :      int     ,		__snake_case  :      List[str]					)			->							int:
											try:
																	import soundfile as sf  # soundfile is a dependency of librosa, needed to decode audio files.
											except ImportError as err:
																	raise ImportError("""To support encoding audio data, please install \'soundfile\'."""					) from err
											if isinstance(__UpperCAmelCase     ,		__UpperCAmelCase					):
																	return {"bytes": None, "path": value}
											elif isinstance(__UpperCAmelCase     ,		__UpperCAmelCase					):
																	return {"bytes": value, "path": None}
											elif "array" in value:
																	# convert the audio array to wav bytes
																	__magic_name__:	str							=       BytesIO()
																	sf.write(__UpperCAmelCase     ,		value["""array"""]     ,		value["""sampling_rate"""]     ,		format="""wav"""					)
																	return {"bytes": buffer.getvalue(), "path": None}
											elif value.get("""path"""					) is not None and os.path.isfile(value["""path"""]					):
																	# we set "bytes": None to not duplicate the data if they're already available locally
																	if value["path"].endswith("""pcm"""					):
																							# "PCM" only has raw audio bytes
																							if value.get("""sampling_rate"""					) is None:
																													# At least, If you want to convert "PCM-byte" to "WAV-byte", you have to know sampling rate
																													raise KeyError("""To use PCM files, please specify a \'sampling_rate\' in Audio object"""					)
																							if value.get("""bytes"""					):
																													# If we already had PCM-byte, we don`t have to make "read file, make bytes" (just use it!)
																													__magic_name__:	str							=       np.frombuffer(value["""bytes"""]     ,		dtype=np.intaa					).astype(np.floataa					) / 3_2_7_6_7
																							else:
																													__magic_name__:	Optional[Any]							=       np.memmap(value["""path"""]     ,		dtype="""h"""     ,		mode="""r"""					).astype(np.floataa					) / 3_2_7_6_7

																							__magic_name__:	Tuple							=       BytesIO(bytes()					)
																							sf.write(__UpperCAmelCase     ,		__UpperCAmelCase     ,		value["""sampling_rate"""]     ,		format="""wav"""					)
																							return {"bytes": buffer.getvalue(), "path": None}
																	else:
																							return {"bytes": None, "path": value.get("""path"""					)}
											elif value.get("""bytes"""					) is not None or value.get("""path"""					) is not None:
																	# store the audio bytes, and path is used to infer the audio format using the file extension
																	return {"bytes": value.get("""bytes"""					), "path": value.get("""path"""					)}
											else:
																	raise ValueError(
																	    F'An audio sample should have one of \'path\' or \'bytes\' but they are missing or None in {value}.'					)

					def   lowerCamelCase__   (			self  :      str     ,		__snake_case  :      Any     ,		__snake_case  :      Any = None					)			->							str:
											if not self.decode:
																	raise RuntimeError("""Decoding is disabled for this feature. Please use Audio(decode=True) instead."""					)

											__magic_name__,			__magic_name__:	Optional[int]							=       (value["""path"""], BytesIO(value["""bytes"""]					)) if value["""bytes"""] is not None else (value["""path"""], None)
											if path is None and file is None:
																	raise ValueError(F'An audio sample should have one of \'path\' or \'bytes\' but both are None in {value}.'					)

											try:
																	import librosa
																	import soundfile as sf
											except ImportError as err:
																	raise ImportError("""To support decoding audio files, please install \'librosa\' and \'soundfile\'."""					) from err

											__magic_name__:	Optional[int]							=       xsplitext(__UpperCAmelCase					)[1][1:].lower() if path is not None else None
											if not config.IS_OPUS_SUPPORTED and audio_format == "opus":
																	raise RuntimeError(
																	    """Decoding \'opus\' files requires system library \'libsndfile\'>=1.0.31, """
																	    """You can try to update `soundfile` python library: `pip install \"soundfile>=0.12.1\"`. """					)
											elif not config.IS_MP3_SUPPORTED and audio_format == "mp3":
																	raise RuntimeError(
																	    """Decoding \'mp3\' files requires system library \'libsndfile\'>=1.1.0, """
																	    """You can try to update `soundfile` python library: `pip install \"soundfile>=0.12.1\"`. """					)

											if file is None:
																	__magic_name__:	Dict							=       token_per_repo_id or {}
																	__magic_name__:	Optional[Any]							=       path.split("""::"""					)[-1]
																	try:
																							__magic_name__:	int							=       string_to_dict(__UpperCAmelCase     ,		config.HUB_DATASETS_URL					)["""repo_id"""]
																							__magic_name__:	Optional[int]							=       token_per_repo_id[repo_id]
																	except (ValueError, KeyError):
																							__magic_name__:	Union[str, Any]							=       None

																	with xopen(__UpperCAmelCase     ,		"""rb"""     ,		use_auth_token=__UpperCAmelCase					) as f:
																							__magic_name__,			__magic_name__:	int							=       sf.read(__UpperCAmelCase					)

											else:
																	__magic_name__,			__magic_name__:	str							=       sf.read(__UpperCAmelCase					)

											__magic_name__:	List[Any]							=       array.T
											if self.mono:
																	__magic_name__:	Union[str, Any]							=       librosa.to_mono(__UpperCAmelCase					)
											if self.sampling_rate and self.sampling_rate != sampling_rate:
																	__magic_name__:	Optional[Any]							=       librosa.resample(__UpperCAmelCase     ,		orig_sr=__UpperCAmelCase     ,		target_sr=self.sampling_rate					)
																	__magic_name__:	Union[str, Any]							=       self.sampling_rate

											return {"path": path, "array": array, "sampling_rate": sampling_rate}

					def   lowerCamelCase__   (			self  :      str					)			->							Tuple:
											from .features import Value

											if self.decode:
																	raise ValueError("""Cannot flatten a decoded Audio feature."""					)
											return {
											    "bytes": Value("""binary"""					),
											    "path": Value("""string"""					),
											}

					def   lowerCamelCase__   (			self  :      Optional[int]     ,		__snake_case  :      List[str]					)			->							List[Any]:
											if pa.types.is_string(storage.type					):
																	__magic_name__:	Union[str, Any]							=       pa.array([None] * len(__UpperCAmelCase					)     ,		type=pa.binary()					)
																	__magic_name__:	Any							=       pa.StructArray.from_arrays([bytes_array, storage]     ,		["""bytes""", """path"""]     ,		mask=storage.is_null()					)
											elif pa.types.is_binary(storage.type					):
																	__magic_name__:	Any							=       pa.array([None] * len(__UpperCAmelCase					)     ,		type=pa.string()					)
																	__magic_name__:	Optional[int]							=       pa.StructArray.from_arrays([storage, path_array]     ,		["""bytes""", """path"""]     ,		mask=storage.is_null()					)
											elif pa.types.is_struct(storage.type					) and storage.type.get_all_field_indices("""array"""					):
																	__magic_name__:	List[str]							=       pa.array([Audio().encode_example(__UpperCAmelCase					) if x is not None else None for x in storage.to_pylist()]					)
											elif pa.types.is_struct(storage.type					):
																	if storage.type.get_field_index("""bytes"""					) >= 0:
																							__magic_name__:	int							=       storage.field("""bytes"""					)
																	else:
																							__magic_name__:	List[str]							=       pa.array([None] * len(__UpperCAmelCase					)     ,		type=pa.binary()					)
																	if storage.type.get_field_index("""path"""					) >= 0:
																							__magic_name__:	Tuple							=       storage.field("""path"""					)
																	else:
																							__magic_name__:	str							=       pa.array([None] * len(__UpperCAmelCase					)     ,		type=pa.string()					)
																	__magic_name__:	Dict							=       pa.StructArray.from_arrays([bytes_array, path_array]     ,		["""bytes""", """path"""]     ,		mask=storage.is_null()					)
											return array_cast(__UpperCAmelCase     ,		self.pa_type					)






					def   lowerCamelCase__   (			self  :      Optional[int]     ,		__snake_case  :      List[str]					)			->							List[Any]:

											@no_op_if_value_is_null
											def path_to_bytes(__snake_case  :      List[Any]					):
																	with xopen(__UpperCAmelCase     ,		"""rb"""					) as f:
																							__magic_name__:	int							=       f.read()
																	return bytes_

											__magic_name__:	List[str]							=       pa.array(
											    [
											        (path_to_bytes(x["""path"""]					) if x["""bytes"""] is None else x["""bytes"""]) if x is not None else None
											        for x in storage.to_pylist()
											    ]     ,		type=pa.binary()     ,		)
											__magic_name__:	str							=       pa.array(
											    [os.path.basename(__UpperCAmelCase					) if path is not None else None for path in storage.field("""path"""					).to_pylist()]     ,		type=pa.string()     ,		)
											__magic_name__:	Union[str, Any]							=       pa.StructArray.from_arrays([bytes_array, path_array]     ,		["""bytes""", """path"""]     ,		mask=bytes_array.is_null()					)
											return array_cast(__UpperCAmelCase     ,		self.pa_type					)








from ...configuration_utils import PretrainedConfig
from ...utils import logging


a_								=       logging.get_logger(__name__)

a_								=       {
    """google/canine-s""": """https://huggingface.co/google/canine-s/resolve/main/config.json""",
    # See all CANINE models at https://huggingface.co/models?filter=canine
}



class 			__lowerCAmelCase  (						lowerCAmelCase__ ):
 lowerCAmelCase__							       =	"""canine"""




 def __init__(    self						,					__UpperCAmelCase=768						,					__UpperCAmelCase=12						,					__UpperCAmelCase=12						,					__UpperCAmelCase=3072						,					__UpperCAmelCase="gelu"						,					__UpperCAmelCase=0.1						,					__UpperCAmelCase=0.1						,					__UpperCAmelCase=16384						,					__UpperCAmelCase=16						,					__UpperCAmelCase=0.02						,					__UpperCAmelCase=1E-1_2						,					__UpperCAmelCase=0						,					__UpperCAmelCase=0Xe_000						,					__UpperCAmelCase=0Xe_001						,					__UpperCAmelCase=4						,					__UpperCAmelCase=4						,					__UpperCAmelCase=8						,					__UpperCAmelCase=16384						,					__UpperCAmelCase=128						,					**__UpperCAmelCase						,					):



    '''simple docstring'''
    super().__init__(pad_token_id=__UpperCAmelCase						,					bos_token_id=__UpperCAmelCase						,					eos_token_id=__UpperCAmelCase						,					**__UpperCAmelCase					)

    __lowerCamelCase    				=     max_position_embeddings
    __lowerCamelCase    				=     hidden_size
    __lowerCamelCase    				=     num_hidden_layers
    __lowerCamelCase    				=     num_attention_heads
    __lowerCamelCase    				=     intermediate_size
    __lowerCamelCase    				=     hidden_act
    __lowerCamelCase    				=     hidden_dropout_prob
    __lowerCamelCase    				=     attention_probs_dropout_prob
    __lowerCamelCase    				=     initializer_range
    __lowerCamelCase    				=     type_vocab_size
    __lowerCamelCase    				=     layer_norm_eps

    # Character config:
    __lowerCamelCase    				=     downsampling_rate
    __lowerCamelCase    				=     upsampling_kernel_size
    __lowerCamelCase    				=     num_hash_functions
    __lowerCamelCase    				=     num_hash_buckets
    __lowerCamelCase    				=     local_transformer_stride






