





"""simple docstring"""





import math
from typing import Optional

import numpy as np

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


_UpperCamelCase							=      logging.get_logger(__name__)

_UpperCamelCase							=      {
    '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 		SCREAMING_SNAKE_CASE_							(    snake_case__   ):
				"""simple docstring"""
				__snake_case   :       List[Any]	 =		"""encodec"""




				def __init__(     self  :Any						,    __lowercase  :Union[str, Any]=[1.5, 3.0, 6.0, 12.0, 24.0]						,    __lowercase  :str=2_4000						,    __lowercase  :int=1						,    __lowercase  :str=False						,    __lowercase  :Tuple=None						,    __lowercase  :Tuple=None						,    __lowercase  :int=128						,    __lowercase  :Union[str, Any]=32						,    __lowercase  :Any=1						,    __lowercase  :Optional[int]=[8, 5, 4, 2]						,    __lowercase  :List[str]="weight_norm"						,    __lowercase  :Optional[Any]=7						,    __lowercase  :str=7						,    __lowercase  :str=3						,    __lowercase  :Tuple=2						,    __lowercase  :List[Any]=True						,    __lowercase  :Any="reflect"						,    __lowercase  :List[Any]=2						,    __lowercase  :Any=2						,    __lowercase  :Dict=1.0						,    __lowercase  :Tuple=1024						,    __lowercase  :Union[str, Any]=None						,    __lowercase  :Dict=True						,    **__lowercase  :List[str]						,    ):
											__lowerCamelCase      :      str         =target_bandwidths
											__lowerCamelCase      :      str         =sampling_rate
											__lowerCamelCase      :      Any         =audio_channels
											__lowerCamelCase      :      str         =normalize
											__lowerCamelCase      :      str         =chunk_length_s
											__lowerCamelCase      :      str         =overlap
											__lowerCamelCase      :      Any         =hidden_size
											__lowerCamelCase      :      Tuple         =num_filters
											__lowerCamelCase      :      Dict         =num_residual_layers
											__lowerCamelCase      :      List[str]         =upsampling_ratios
											__lowerCamelCase      :      Any         =norm_type
											__lowerCamelCase      :      str         =kernel_size
											__lowerCamelCase      :      Union[str, Any]         =last_kernel_size
											__lowerCamelCase      :      Optional[int]         =residual_kernel_size
											__lowerCamelCase      :      str         =dilation_growth_rate
											__lowerCamelCase      :      str         =use_causal_conv
											__lowerCamelCase      :      Optional[Any]         =pad_mode
											__lowerCamelCase      :      str         =compress
											__lowerCamelCase      :      int         =num_lstm_layers
											__lowerCamelCase      :      List[Any]         =trim_right_ratio
											__lowerCamelCase      :      List[str]         =codebook_size
											__lowerCamelCase      :      Any         =codebook_dim if codebook_dim is not None else hidden_size
											__lowerCamelCase      :      List[Any]         =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__(**__lowercase			)




				@property
				def 					__lowercase  (     self  :Any			):
											if self.chunk_length_s is None:
																		return None
											else:
																		return int(self.chunk_length_s * self.sampling_rate			)




				@property
				def 					__lowercase  (     self  :Optional[Any]			):
											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 					__lowercase  (     self  :Any			):
											__lowerCamelCase      :      List[str]         =np.prod(self.upsampling_ratios			)
											return math.ceil(self.sampling_rate / hop_length			)




				@property
				def 					__lowercase  (     self  :str			):
											return int(1000 * self.target_bandwidths[-1] // (self.frame_rate * 10)			)











"""simple docstring"""





import math
from datetime import datetime, timedelta



def 				lowerCAmelCase_			(      SCREAMING_SNAKE_CASE       :							int   ):


							'''simple docstring'''







							__lowerCamelCase      :      Any         =year % 19
							__lowerCamelCase      :      Optional[Any]         =year % 4
							__lowerCamelCase      :      Tuple         =year % 7
							__lowerCamelCase      :      Optional[int]         =math.floor(year / 100   )
							__lowerCamelCase      :      List[str]         =math.floor((13 + 8 * leap_day_inhibits) / 25   )
							__lowerCamelCase      :      Any         =leap_day_inhibits / 4
							__lowerCamelCase      :      Optional[Any]         =(
							    15 - lunar_orbit_correction + leap_day_inhibits - leap_day_reinstall_number
							) % 30
							__lowerCamelCase      :      Optional[Any]         =(4 + leap_day_inhibits - leap_day_reinstall_number) % 7

							# days to be added to March 21
							__lowerCamelCase      :      Any         =(19 * metonic_cycle + secular_moon_shift) % 30

							# PHM -> Paschal Full Moon
							__lowerCamelCase      :      str         =(
							    2 * julian_leap_year
							    + 4 * non_leap_year
							    + 6 * days_to_add
							    + century_starting_point
							) % 7

							if days_to_add == 29 and days_from_phm_to_sunday == 6:
														return datetime(SCREAMING_SNAKE_CASE    ,						4    ,						19   )
							elif days_to_add == 28 and days_from_phm_to_sunday == 6:
														return datetime(SCREAMING_SNAKE_CASE    ,						4    ,						18   )
							else:
														return datetime(SCREAMING_SNAKE_CASE    ,						3    ,						22   ) + timedelta(
														    days=int(days_to_add + days_from_phm_to_sunday   )   )


if __name__ == "__main__":
							for year in (1994, 2000, 2010, 2021, 2023):
														_UpperCamelCase							=      'will be' if year > datetime.now().year else 'was'
														print(f'''Easter in {year} {tense} {gauss_easter(year)}''')




