





import math
from typing import Optional

import numpy as np

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


lowercase__						:      List[str]	=    logging.get_logger(__name__)

lowercase__						:      Optional[Any]	=    {
    'facebook/encodec_24khz': 'https://huggingface.co/facebook/encodec_24khz/resolve/main/config.json',
    'facebook/encodec_48khz': 'https://huggingface.co/facebook/encodec_48khz/resolve/main/config.json',
}
class     __lowerCAmelCase					(   __snake_case			):






       """simple docstring"""
       _snake_case     :					Union[str, Any]						    =   'encodec'





       def __init__(							self       :		Optional[int]	,			lowerCAmelCase__       :		str=[1.5, 3.0, 6.0, 12.0, 24.0]	,			lowerCAmelCase__       :		Any=24000	,			lowerCAmelCase__       :		List[str]=1	,			lowerCAmelCase__       :		int=False	,			lowerCAmelCase__       :		List[Any]=None	,			lowerCAmelCase__       :		Tuple=None	,			lowerCAmelCase__       :		Optional[int]=128	,			lowerCAmelCase__       :		Tuple=32	,			lowerCAmelCase__       :		Optional[Any]=1	,			lowerCAmelCase__       :		Optional[int]=[8, 5, 4, 2]	,			lowerCAmelCase__       :		List[Any]="weight_norm"	,			lowerCAmelCase__       :		Any=7	,			lowerCAmelCase__       :		Dict=7	,			lowerCAmelCase__       :		str=3	,			lowerCAmelCase__       :		Tuple=2	,			lowerCAmelCase__       :		Tuple=True	,			lowerCAmelCase__       :		int="reflect"	,			lowerCAmelCase__       :		Tuple=2	,			lowerCAmelCase__       :		Tuple=2	,			lowerCAmelCase__       :		str=1.0	,			lowerCAmelCase__       :		Dict=1024	,			lowerCAmelCase__       :		Any=None	,			lowerCAmelCase__       :		List[str]=True	,			**lowerCAmelCase__       :		Union[str, Any]	,			)   ->					str:

            '''simple docstring'''




            _UpperCamelCase       =	target_bandwidths
            _UpperCamelCase       =	sampling_rate
            _UpperCamelCase       =	audio_channels
            _UpperCamelCase       =	normalize
            _UpperCamelCase       =	chunk_length_s
            _UpperCamelCase       =	overlap
            _UpperCamelCase       =	hidden_size
            _UpperCamelCase       =	num_filters
            _UpperCamelCase       =	num_residual_layers
            _UpperCamelCase       =	upsampling_ratios
            _UpperCamelCase       =	norm_type
            _UpperCamelCase       =	kernel_size
            _UpperCamelCase       =	last_kernel_size
            _UpperCamelCase       =	residual_kernel_size
            _UpperCamelCase       =	dilation_growth_rate
            _UpperCamelCase       =	use_causal_conv
            _UpperCamelCase       =	pad_mode
            _UpperCamelCase       =	compress
            _UpperCamelCase       =	num_lstm_layers
            _UpperCamelCase       =	trim_right_ratio
            _UpperCamelCase       =	codebook_size
            _UpperCamelCase       =	codebook_dim if codebook_dim is not None else hidden_size
            _UpperCamelCase       =	use_conv_shortcut

            if self.norm_type not in ["weight_norm", "time_group_norm"]:
                 raise ValueError(
                     f"""self.norm_type must be one of `\"weight_norm\"`, `\"time_group_norm\"`), got {self.norm_type}"""					)

            super().__init__(**lowerCAmelCase__					)





       @property
       def snake_case__						(							self       :		Optional[int]					)   ->					Optional[int]:

            '''simple docstring'''




            if self.chunk_length_s is None:
                 return None
            else:
                 return int(self.chunk_length_s * self.sampling_rate					)





       @property
       def snake_case__						(							self       :		Optional[Any]					)   ->					Optional[int]:

            '''simple docstring'''




            if self.chunk_length_s is None or self.overlap is None:
                 return None
            else:
                 return max(1	,			int((1.0 - self.overlap) * self.chunk_length					)					)





       @property
       def snake_case__						(							self       :		Tuple					)   ->					int:

            '''simple docstring'''




            _UpperCamelCase       =	np.prod(self.upsampling_ratios					)
            return math.ceil(self.sampling_rate / hop_length					)







       @property
       def snake_case__						(							self       :		List[str]					)   ->					int:

            '''simple docstring'''




            return int(1000 * self.target_bandwidths[-1] // (self.frame_rate * 10)					)










'''simple docstring'''

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


lowercase__						:      List[Any]	=    logging.get_logger(__name__)

lowercase__						:      Tuple	=    {
    'microsoft/trocr-base-handwritten': (
        'https://huggingface.co/microsoft/trocr-base-handwritten/resolve/main/config.json'
    ),
    # See all TrOCR models at https://huggingface.co/models?filter=trocr
}
class     __lowerCAmelCase					(   __magic_name__			):






       """simple docstring"""
       _snake_case     :					int						    =   'trocr'
       _snake_case     :					List[str]						    =   ['past_key_values']
       _snake_case     :					Tuple						    =   {
           'num_attention_heads': 'decoder_attention_heads',
           'hidden_size': 'd_model',
           'num_hidden_layers': 'decoder_layers',
       }





       def __init__(							self       :		Tuple	,			lowerCAmelCase__       :		Union[str, Any]=50265	,			lowerCAmelCase__       :		List[Any]=1024	,			lowerCAmelCase__       :		List[str]=12	,			lowerCAmelCase__       :		int=16	,			lowerCAmelCase__       :		List[Any]=4096	,			lowerCAmelCase__       :		Optional[int]="gelu"	,			lowerCAmelCase__       :		int=512	,			lowerCAmelCase__       :		Optional[Any]=0.1	,			lowerCAmelCase__       :		Optional[int]=0.0	,			lowerCAmelCase__       :		Dict=0.0	,			lowerCAmelCase__       :		Tuple=2	,			lowerCAmelCase__       :		Dict=0.02	,			lowerCAmelCase__       :		Tuple=0.0	,			lowerCAmelCase__       :		int=True	,			lowerCAmelCase__       :		Optional[Any]=False	,			lowerCAmelCase__       :		Any=True	,			lowerCAmelCase__       :		Dict=True	,			lowerCAmelCase__       :		Optional[int]=1	,			lowerCAmelCase__       :		List[Any]=0	,			lowerCAmelCase__       :		Any=2	,			**lowerCAmelCase__       :		Optional[int]	,			)   ->					Any:

            '''simple docstring'''




            _UpperCamelCase       =	vocab_size
            _UpperCamelCase       =	d_model
            _UpperCamelCase       =	decoder_layers
            _UpperCamelCase       =	decoder_attention_heads
            _UpperCamelCase       =	decoder_ffn_dim
            _UpperCamelCase       =	activation_function
            _UpperCamelCase       =	max_position_embeddings
            _UpperCamelCase       =	dropout
            _UpperCamelCase       =	attention_dropout
            _UpperCamelCase       =	activation_dropout
            _UpperCamelCase       =	init_std
            _UpperCamelCase       =	decoder_layerdrop
            _UpperCamelCase       =	use_cache
            _UpperCamelCase       =	scale_embedding
            _UpperCamelCase       =	use_learned_position_embeddings
            _UpperCamelCase       =	layernorm_embedding

            super().__init__(
                pad_token_id=lowerCAmelCase__	,			bos_token_id=lowerCAmelCase__	,			eos_token_id=lowerCAmelCase__	,			decoder_start_token_id=lowerCAmelCase__	,			**lowerCAmelCase__	,			)



