


'''simple docstring'''



# Copyright 2021 The HuggingFace Team. All rights reserved.
#
# 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.

import argparse

from ...utils.dataclasses import (
    ComputeEnvironment,
    DistributedType,
    DynamoBackend,
    PrecisionType,
    SageMakerDistributedType,
)
from ..menu import BulletMenu


_lowercase    :    Union[str, Any]			     =  [
    """EAGER""",
    """AOT_EAGER""",
    """INDUCTOR""",
    """NVFUSER""",
    """AOT_NVFUSER""",
    """AOT_CUDAGRAPHS""",
    """OFI""",
    """FX2TRT""",
    """ONNXRT""",
    """IPEX""",
]


def    lowerCamelCase__   ( A     :    Union[str, Any]   ,     A     :    Tuple=None   ,     A     :    Any=None   ,     A     :    List[Any]=None  ):




						'''simple docstring'''






						UpperCAmelCase         =			True
						while ask_again:
												UpperCAmelCase         =			input(A  )
												try:
																		if default is not None and len(A  ) == 0:
																								return default
																		return convert_value(A  ) if convert_value is not None else result
												except Exception:
																		if error_message is not None:
																								print(A  )


def    lowerCamelCase__   ( A     :    Dict   ,     A     :    Union[str, Any]=[]   ,     A     :    int=None   ,     A     :    List[Any]=0  ):




						'''simple docstring'''






						UpperCAmelCase         =			BulletMenu(A   ,     A  )
						UpperCAmelCase         =			menu.run(default_choice=A  )
						return convert_value(A  ) if convert_value is not None else result


def    lowerCamelCase__   ( A     :    List[Any]  ):




						'''simple docstring'''






						UpperCAmelCase         =			int(A  )
						return ComputeEnvironment(['''LOCAL_MACHINE''', '''AMAZON_SAGEMAKER'''][value]  )


def    lowerCamelCase__   ( A     :    Dict  ):




						'''simple docstring'''






						UpperCAmelCase         =			int(A  )
						return DistributedType(['''NO''', '''MULTI_CPU''', '''MULTI_XPU''', '''MULTI_GPU''', '''MULTI_NPU''', '''TPU'''][value]  )


def    lowerCamelCase__   ( A     :    Tuple  ):




						'''simple docstring'''






						UpperCAmelCase         =			int(A  )
						return DynamoBackend(DYNAMO_BACKENDS[value]  ).value


def    lowerCamelCase__   ( A     :    Optional[Any]  ):




						'''simple docstring'''






						UpperCAmelCase         =			int(A  )
						return PrecisionType(['''no''', '''fp16''', '''bf16''', '''fp8'''][value]  )


def    lowerCamelCase__   ( A     :    Any  ):




						'''simple docstring'''






						UpperCAmelCase         =			int(A  )
						return SageMakerDistributedType(['''NO''', '''DATA_PARALLEL''', '''MODEL_PARALLEL'''][value]  )


def    lowerCamelCase__   ( A     :    Union[str, Any]  ):




						'''simple docstring'''






						return {"yes": True, "no": False}[value.lower()]






class  UpperCamelCase__(     argparse.RawDescriptionHelpFormatter ):




				def   a__(	self    :				Dict   ,					lowerCAmelCase    :				Optional[Any]   ,					lowerCAmelCase    :				Optional[Any]   ,					lowerCAmelCase    :				Tuple   ,					lowerCAmelCase    :				List[str]   )->  int:

										"""simple docstring"""




										UpperCAmelCase         =			super()._format_usage(lowerCAmelCase   ,					lowerCAmelCase   ,					lowerCAmelCase   ,					lowerCAmelCase   )
										UpperCAmelCase         =			usage.replace('''<command> [<args>] '''   ,					''''''   )
										return usage









'''simple docstring'''



import math
from typing import Optional

import numpy as np

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


_lowercase    :    Union[str, Any]			     =  logging.get_logger(__name__)

_lowercase    :    List[str]			     =  {
    """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  UpperCamelCase__(     lowerCAmelCase ):
				__magic_name__       :   List[str]							= "encodec"




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

										"""simple docstring"""




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





				@property
				def   a__(	self    :				int   )->  int:

										"""simple docstring"""




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





