


import unittest

from transformers import XLMConfig, is_torch_available
from transformers.testing_utils import require_torch, slow, torch_device

from ...generation.test_utils import GenerationTesterMixin
from ...test_configuration_common import ConfigTester
from ...test_modeling_common import ModelTesterMixin, ids_tensor, random_attention_mask
from ...test_pipeline_mixin import PipelineTesterMixin


if is_torch_available():
 import torch

 from transformers import (
     XLMForMultipleChoice,
     XLMForQuestionAnswering,
     XLMForQuestionAnsweringSimple,
     XLMForSequenceClassification,
     XLMForTokenClassification,
     XLMModel,
     XLMWithLMHeadModel,
 )
 from transformers.models.xlm.modeling_xlm import XLM_PRETRAINED_MODEL_ARCHIVE_LIST





class   __a			:
 def __init__(   self				, lowerCAmelCase__				, lowerCAmelCase__=13				, lowerCAmelCase__=7				, lowerCAmelCase__=True				, lowerCAmelCase__=True				, lowerCAmelCase__=True				, lowerCAmelCase__=True				, lowerCAmelCase__=True				, lowerCAmelCase__=False				, lowerCAmelCase__=False				, lowerCAmelCase__=False				, lowerCAmelCase__=2				, lowerCAmelCase__=99				, lowerCAmelCase__=0				, lowerCAmelCase__=32				, lowerCAmelCase__=5				, lowerCAmelCase__=4				, lowerCAmelCase__=0.1				, lowerCAmelCase__=0.1				, lowerCAmelCase__=512				, lowerCAmelCase__=2				, lowerCAmelCase__=0.0_2				, lowerCAmelCase__=2				, lowerCAmelCase__=4				, lowerCAmelCase__="last"				, lowerCAmelCase__=True				, lowerCAmelCase__=None				, lowerCAmelCase__=0				, )					->				int:




        '''simple docstring'''
        lowercase__:   str  			=   parent
        lowercase__:   int  			=   batch_size
        lowercase__:   List[str]  			=   seq_length
        lowercase__:   Optional[int]  			=   is_training
        lowercase__:   Optional[int]  			=   use_input_lengths
        lowercase__:   List[str]  			=   use_token_type_ids
        lowercase__:   Tuple  			=   use_labels
        lowercase__:   str  			=   gelu_activation
        lowercase__:   Union[str, Any]  			=   sinusoidal_embeddings
        lowercase__:   Optional[int]  			=   causal
        lowercase__:   int  			=   asm
        lowercase__:   Union[str, Any]  			=   n_langs
        lowercase__:   Optional[int]  			=   vocab_size
        lowercase__:   int  			=   n_special
        lowercase__:   Dict  			=   hidden_size
        lowercase__:   Optional[int]  			=   num_hidden_layers
        lowercase__:   List[Any]  			=   num_attention_heads
        lowercase__:   Optional[Any]  			=   hidden_dropout_prob
        lowercase__:   List[Any]  			=   attention_probs_dropout_prob
        lowercase__:   str  			=   max_position_embeddings
        lowercase__:   Any  			=   type_sequence_label_size
        lowercase__:   List[Any]  			=   initializer_range
        lowercase__:   List[Any]  			=   num_labels
        lowercase__:   Optional[Any]  			=   num_choices
        lowercase__:   List[Any]  			=   summary_type
        lowercase__:   Union[str, Any]  			=   use_proj
        lowercase__:   Optional[Any]  			=   scope
        lowercase__:   Tuple  			=   bos_token_id
 def 		SCREAMING_SNAKE_CASE__   (   self )					->				Optional[Any]:




        '''simple docstring'''
        lowercase__:   Dict  			=   ids_tensor([self.batch_size, self.seq_length]				, self.vocab_size )
        lowercase__:   Union[str, Any]  			=   random_attention_mask([self.batch_size, self.seq_length] )

        lowercase__:   str  			=   None
        if self.use_input_lengths:
               lowercase__:   Dict  			=   (
                   ids_tensor([self.batch_size]				, vocab_size=2 ) + self.seq_length - 2
               )  # small variation of seq_length

        lowercase__:   str  			=   None
        if self.use_token_type_ids:
               lowercase__:   Tuple  			=   ids_tensor([self.batch_size, self.seq_length]				, self.n_langs )

        lowercase__:   List[str]  			=   None
        lowercase__:   str  			=   None
        lowercase__:   List[str]  			=   None
        if self.use_labels:
               lowercase__:   Optional[int]  			=   ids_tensor([self.batch_size]				, self.type_sequence_label_size )
               lowercase__:   Tuple  			=   ids_tensor([self.batch_size, self.seq_length]				, self.num_labels )
               lowercase__:   Tuple  			=   ids_tensor([self.batch_size]				, 2 ).float()
               lowercase__:   str  			=   ids_tensor([self.batch_size]				, self.num_choices )

        lowercase__:   Optional[Any]  			=   self.get_config()

        return (
            config,
            input_ids,
            token_type_ids,
            input_lengths,
            sequence_labels,
            token_labels,
            is_impossible_labels,
            choice_labels,
            input_mask,
        )
 def 		SCREAMING_SNAKE_CASE__   (   self )					->				List[str]:




        '''simple docstring'''
        return XLMConfig(
            vocab_size=self.vocab_size				, n_special=self.n_special				, emb_dim=self.hidden_size				, n_layers=self.num_hidden_layers				, n_heads=self.num_attention_heads				, dropout=self.hidden_dropout_prob				, attention_dropout=self.attention_probs_dropout_prob				, gelu_activation=self.gelu_activation				, sinusoidal_embeddings=self.sinusoidal_embeddings				, asm=self.asm				, causal=self.causal				, n_langs=self.n_langs				, max_position_embeddings=self.max_position_embeddings				, initializer_range=self.initializer_range				, summary_type=self.summary_type				, use_proj=self.use_proj				, num_labels=self.num_labels				, bos_token_id=self.bos_token_id				, )
 def 		SCREAMING_SNAKE_CASE__   (   self				, lowerCAmelCase__				, lowerCAmelCase__				, lowerCAmelCase__				, lowerCAmelCase__				, lowerCAmelCase__				, lowerCAmelCase__				, lowerCAmelCase__				, lowerCAmelCase__				, lowerCAmelCase__				, )					->				Any:




        '''simple docstring'''
        lowercase__:   Union[str, Any]  			=   XLMModel(config=lowerCAmelCase__ )
        model.to(lowerCAmelCase__ )
        model.eval()
        lowercase__:   Optional[int]  			=   model(lowerCAmelCase__				, lengths=lowerCAmelCase__				, langs=lowerCAmelCase__ )
        lowercase__:   Dict  			=   model(lowerCAmelCase__				, langs=lowerCAmelCase__ )
        lowercase__:   Union[str, Any]  			=   model(lowerCAmelCase__ )
        self.parent.assertEqual(result.last_hidden_state.shape				, (self.batch_size, self.seq_length, self.hidden_size) )
 def 		SCREAMING_SNAKE_CASE__   (   self				, lowerCAmelCase__				, lowerCAmelCase__				, lowerCAmelCase__				, lowerCAmelCase__				, lowerCAmelCase__				, lowerCAmelCase__				, lowerCAmelCase__				, lowerCAmelCase__				, lowerCAmelCase__				, )					->				List[Any]:




        '''simple docstring'''
        lowercase__:   int  			=   XLMWithLMHeadModel(lowerCAmelCase__ )
        model.to(lowerCAmelCase__ )
        model.eval()

        lowercase__:   int  			=   model(lowerCAmelCase__				, token_type_ids=lowerCAmelCase__				, labels=lowerCAmelCase__ )
        self.parent.assertEqual(result.loss.shape				, () )
        self.parent.assertEqual(result.logits.shape				, (self.batch_size, self.seq_length, self.vocab_size) )
 def 		SCREAMING_SNAKE_CASE__   (   self				, lowerCAmelCase__				, lowerCAmelCase__				, lowerCAmelCase__				, lowerCAmelCase__				, lowerCAmelCase__				, lowerCAmelCase__				, lowerCAmelCase__				, lowerCAmelCase__				, lowerCAmelCase__				, )					->				str:




        '''simple docstring'''
        lowercase__:   str  			=   XLMForQuestionAnsweringSimple(lowerCAmelCase__ )
        model.to(lowerCAmelCase__ )
        model.eval()

        lowercase__:   Optional[Any]  			=   model(lowerCAmelCase__ )

        lowercase__:   Dict  			=   model(lowerCAmelCase__				, start_positions=lowerCAmelCase__				, end_positions=lowerCAmelCase__ )
        lowercase__:   Optional[int]  			=   outputs
        self.parent.assertEqual(result.start_logits.shape				, (self.batch_size, self.seq_length) )
        self.parent.assertEqual(result.end_logits.shape				, (self.batch_size, self.seq_length) )
 def 		SCREAMING_SNAKE_CASE__   (   self				, lowerCAmelCase__				, lowerCAmelCase__				, lowerCAmelCase__				, lowerCAmelCase__				, lowerCAmelCase__				, lowerCAmelCase__				, lowerCAmelCase__				, lowerCAmelCase__				, lowerCAmelCase__				, )					->				Optional[Any]:




        '''simple docstring'''
        lowercase__:   Any  			=   XLMForQuestionAnswering(lowerCAmelCase__ )
        model.to(lowerCAmelCase__ )
        model.eval()

        lowercase__:   List[Any]  			=   model(lowerCAmelCase__ )

        lowercase__:   List[str]  			=   model(
            lowerCAmelCase__				, start_positions=lowerCAmelCase__				, end_positions=lowerCAmelCase__				, cls_index=lowerCAmelCase__				, is_impossible=lowerCAmelCase__				, p_mask=lowerCAmelCase__				, )

        lowercase__:   Any  			=   model(
            lowerCAmelCase__				, start_positions=lowerCAmelCase__				, end_positions=lowerCAmelCase__				, cls_index=lowerCAmelCase__				, is_impossible=lowerCAmelCase__				, )

        ((lowercase__)			,						):   Dict  			=   result_with_labels.to_tuple()

        lowercase__:   List[str]  			=   model(lowerCAmelCase__				, start_positions=lowerCAmelCase__				, end_positions=lowerCAmelCase__ )

        ((lowercase__)			,						):   Dict  			=   result_with_labels.to_tuple()

        self.parent.assertEqual(result_with_labels.loss.shape				, () )
        self.parent.assertEqual(result.start_top_log_probs.shape				, (self.batch_size, model.config.start_n_top) )
        self.parent.assertEqual(result.start_top_index.shape				, (self.batch_size, model.config.start_n_top) )
        self.parent.assertEqual(
            result.end_top_log_probs.shape				, (self.batch_size, model.config.start_n_top * model.config.end_n_top) )
        self.parent.assertEqual(
            result.end_top_index.shape				, (self.batch_size, model.config.start_n_top * model.config.end_n_top) )
        self.parent.assertEqual(result.cls_logits.shape				, (self.batch_size,) )
 def 		SCREAMING_SNAKE_CASE__   (   self				, lowerCAmelCase__				, lowerCAmelCase__				, lowerCAmelCase__				, lowerCAmelCase__				, lowerCAmelCase__				, lowerCAmelCase__				, lowerCAmelCase__				, lowerCAmelCase__				, lowerCAmelCase__				, )					->				List[str]:




        '''simple docstring'''
        lowercase__:   Optional[int]  			=   XLMForSequenceClassification(lowerCAmelCase__ )
        model.to(lowerCAmelCase__ )
        model.eval()

        lowercase__:   Union[str, Any]  			=   model(lowerCAmelCase__ )
        lowercase__:   Tuple  			=   model(lowerCAmelCase__				, labels=lowerCAmelCase__ )
        self.parent.assertEqual(result.loss.shape				, () )
        self.parent.assertEqual(result.logits.shape				, (self.batch_size, self.type_sequence_label_size) )
 def 		SCREAMING_SNAKE_CASE__   (   self				, lowerCAmelCase__				, lowerCAmelCase__				, lowerCAmelCase__				, lowerCAmelCase__				, lowerCAmelCase__				, lowerCAmelCase__				, lowerCAmelCase__				, lowerCAmelCase__				, lowerCAmelCase__				, )					->				Any:




        '''simple docstring'''
        lowercase__:   Union[str, Any]  			=   self.num_labels
        lowercase__:   List[str]  			=   XLMForTokenClassification(lowerCAmelCase__ )
        model.to(lowerCAmelCase__ )
        model.eval()

        lowercase__:   Dict  			=   model(lowerCAmelCase__				, attention_mask=lowerCAmelCase__				, labels=lowerCAmelCase__ )
        self.parent.assertEqual(result.logits.shape				, (self.batch_size, self.seq_length, self.num_labels) )
 def 		SCREAMING_SNAKE_CASE__   (   self				, lowerCAmelCase__				, lowerCAmelCase__				, lowerCAmelCase__				, lowerCAmelCase__				, lowerCAmelCase__				, lowerCAmelCase__				, lowerCAmelCase__				, lowerCAmelCase__				, lowerCAmelCase__				, )					->				Tuple:




        '''simple docstring'''
        lowercase__:   Union[str, Any]  			=   self.num_choices
        lowercase__:   Tuple  			=   XLMForMultipleChoice(config=lowerCAmelCase__ )
        model.to(lowerCAmelCase__ )
        model.eval()
        lowercase__:   str  			=   input_ids.unsqueeze(1 ).expand(-1				, self.num_choices				, -1 ).contiguous()
        lowercase__:   Any  			=   token_type_ids.unsqueeze(1 ).expand(-1				, self.num_choices				, -1 ).contiguous()
        lowercase__:   str  			=   input_mask.unsqueeze(1 ).expand(-1				, self.num_choices				, -1 ).contiguous()
        lowercase__:   str  			=   model(
            lowerCAmelCase__				, attention_mask=lowerCAmelCase__				, token_type_ids=lowerCAmelCase__				, labels=lowerCAmelCase__				, )
        self.parent.assertEqual(result.logits.shape				, (self.batch_size, self.num_choices) )
 def 		SCREAMING_SNAKE_CASE__   (   self )					->				int:




        '''simple docstring'''
        lowercase__:   Optional[int]  			=   self.prepare_config_and_inputs()
        (
            (
            lowercase__
        )			,						(
            lowercase__
        )			,						(
            lowercase__
        )			,						(
            lowercase__
        )			,						(
            lowercase__
        )			,						(
            lowercase__
        )			,						(
            lowercase__
        )			,						(
            lowercase__
        )			,						(
            lowercase__
        )			,						
        ):   Optional[int]  			=   config_and_inputs
        lowercase__:   int  			=   {'input_ids': input_ids, 'token_type_ids': token_type_ids, 'lengths': input_lengths}
        return config, inputs_dict





@require_torch
class   __a			(    __UpperCamelCase       ,       __UpperCamelCase       ,       __UpperCamelCase       ,       unittest.TestCase      ):
 __lowercase :							List[Any]        = (
     (
         XLMModel,
         XLMWithLMHeadModel,
         XLMForQuestionAnswering,
         XLMForSequenceClassification,
         XLMForQuestionAnsweringSimple,
         XLMForTokenClassification,
         XLMForMultipleChoice,
     )
     if is_torch_available()
     else ()
 )
 __lowercase :							int        = (
     (XLMWithLMHeadModel,) if is_torch_available() else ()
 )  # TODO (PVP): Check other models whether language generation is also applicable
 __lowercase :							int        = (
     {
         'feature-extraction': XLMModel,
         'fill-mask': XLMWithLMHeadModel,
         'question-answering': XLMForQuestionAnsweringSimple,
         'text-classification': XLMForSequenceClassification,
         'text-generation': XLMWithLMHeadModel,
         'token-classification': XLMForTokenClassification,
         'zero-shot': XLMForSequenceClassification,
     }
     if is_torch_available()
     else {}
 )
 def 		SCREAMING_SNAKE_CASE__   (   self				, lowerCAmelCase__				, lowerCAmelCase__				, lowerCAmelCase__				, lowerCAmelCase__				, lowerCAmelCase__ )					->				Optional[Any]:




        '''simple docstring'''
        if (
            pipeline_test_casse_name == "QAPipelineTests"
            and tokenizer_name is not None
            and not tokenizer_name.endswith('Fast' )
        ):
               # `QAPipelineTests` fails for a few models when the slower tokenizer are used.
               # (The slower tokenizers were never used for pipeline tests before the pipeline testing rework)
               # TODO: check (and possibly fix) the `QAPipelineTests` with slower tokenizer
               return True

        return False
 def 		SCREAMING_SNAKE_CASE__   (   self				, lowerCAmelCase__				, lowerCAmelCase__				, lowerCAmelCase__=False )					->				Tuple:




        '''simple docstring'''
        lowercase__:   List[Any]  			=   super()._prepare_for_class(lowerCAmelCase__				, lowerCAmelCase__				, return_labels=lowerCAmelCase__ )

        if return_labels:
               if model_class.__name__ == "XLMForQuestionAnswering":
                      lowercase__:   List[Any]  			=   torch.zeros(
                          self.model_tester.batch_size				, dtype=torch.long				, device=lowerCAmelCase__ )
                      lowercase__:   List[Any]  			=   torch.zeros(
                          self.model_tester.batch_size				, dtype=torch.long				, device=lowerCAmelCase__ )

        return inputs_dict
 def 		SCREAMING_SNAKE_CASE__   (   self )					->				Dict:




        '''simple docstring'''
        lowercase__:   int  			=   XLMModelTester(self )
        lowercase__:   Tuple  			=   ConfigTester(self				, config_class=lowerCAmelCase__				, emb_dim=37 )
 def 		SCREAMING_SNAKE_CASE__   (   self )					->				Dict:




        '''simple docstring'''
        self.config_tester.run_common_tests()
 def 		SCREAMING_SNAKE_CASE__   (   self )					->				List[str]:




        '''simple docstring'''
        lowercase__:   Any  			=   self.model_tester.prepare_config_and_inputs()
        self.model_tester.create_and_check_xlm_model(*lowerCAmelCase__ )
 def 		SCREAMING_SNAKE_CASE__   (   self )					->				Optional[Any]:




        '''simple docstring'''
        lowercase__:   List[str]  			=   self.model_tester.prepare_config_and_inputs()
        self.model_tester.create_and_check_xlm_lm_head(*lowerCAmelCase__ )
 def 		SCREAMING_SNAKE_CASE__   (   self )					->				List[str]:




        '''simple docstring'''
        lowercase__:   Dict  			=   self.model_tester.prepare_config_and_inputs()
        self.model_tester.create_and_check_xlm_simple_qa(*lowerCAmelCase__ )
 def 		SCREAMING_SNAKE_CASE__   (   self )					->				int:




        '''simple docstring'''
        lowercase__:   Optional[Any]  			=   self.model_tester.prepare_config_and_inputs()
        self.model_tester.create_and_check_xlm_qa(*lowerCAmelCase__ )
 def 		SCREAMING_SNAKE_CASE__   (   self )					->				List[str]:




        '''simple docstring'''
        lowercase__:   List[Any]  			=   self.model_tester.prepare_config_and_inputs()
        self.model_tester.create_and_check_xlm_sequence_classif(*lowerCAmelCase__ )
 def 		SCREAMING_SNAKE_CASE__   (   self )					->				Dict:




        '''simple docstring'''
        lowercase__:   List[str]  			=   self.model_tester.prepare_config_and_inputs()
        self.model_tester.create_and_check_xlm_token_classif(*lowerCAmelCase__ )
 def 		SCREAMING_SNAKE_CASE__   (   self )					->				str:




        '''simple docstring'''
        lowercase__:   Any  			=   self.model_tester.prepare_config_and_inputs()
        self.model_tester.create_and_check_xlm_for_multiple_choice(*lowerCAmelCase__ )
 def 		SCREAMING_SNAKE_CASE__   (   self				, lowerCAmelCase__				, lowerCAmelCase__				, lowerCAmelCase__				, lowerCAmelCase__				, lowerCAmelCase__				, lowerCAmelCase__=False				, lowerCAmelCase__=1 )					->				int:




        '''simple docstring'''
        self.assertIsInstance(lowerCAmelCase__				, lowerCAmelCase__ )
        self.assertListEqual(
            [isinstance(lowerCAmelCase__				, lowerCAmelCase__ ) for iter_attentions in attentions]				, [True] * len(lowerCAmelCase__ ) )
        self.assertEqual(len(lowerCAmelCase__ )				, (max_length - min_length) * num_beam_groups )

        for idx, iter_attentions in enumerate(lowerCAmelCase__ ):
               # adds PAD dummy token
               lowercase__:   Optional[Any]  			=   min_length + idx + 1
               lowercase__:   List[str]  			=   min_length + idx + 1

               lowercase__:   str  			=   (
                   batch_size * num_beam_groups,
                   config.num_attention_heads,
                   tgt_len,
                   src_len,
               )
               # check attn size
               self.assertListEqual(
                   [layer_attention.shape for layer_attention in iter_attentions]				, [expected_shape] * len(lowerCAmelCase__ ) )
 def 		SCREAMING_SNAKE_CASE__   (   self				, lowerCAmelCase__				, lowerCAmelCase__				, lowerCAmelCase__				, lowerCAmelCase__				, lowerCAmelCase__				, lowerCAmelCase__=False				, lowerCAmelCase__=1 )					->				Tuple:




        '''simple docstring'''
        self.assertIsInstance(lowerCAmelCase__				, lowerCAmelCase__ )
        self.assertListEqual(
            [isinstance(lowerCAmelCase__				, lowerCAmelCase__ ) for iter_hidden_states in hidden_states]				, [True] * len(lowerCAmelCase__ )				, )
        self.assertEqual(len(lowerCAmelCase__ )				, (max_length - min_length) * num_beam_groups )

        for idx, iter_hidden_states in enumerate(lowerCAmelCase__ ):
               # adds PAD dummy token
               lowercase__:   int  			=   min_length + idx + 1
               lowercase__:   str  			=   (batch_size * num_beam_groups, seq_len, config.hidden_size)
               # check hidden size
               self.assertListEqual(
                   [layer_hidden_states.shape for layer_hidden_states in iter_hidden_states]				, [expected_shape] * len(lowerCAmelCase__ )				, )
        pass
 @slow
 def 		SCREAMING_SNAKE_CASE__   (   self )					->				Optional[int]:




        '''simple docstring'''
        for model_name in XLM_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
               lowercase__:   Dict  			=   XLMModel.from_pretrained(lowerCAmelCase__ )
               self.assertIsNotNone(lowerCAmelCase__ )





@require_torch
class   __a			(    unittest.TestCase      ):
 @slow
 def 		SCREAMING_SNAKE_CASE__   (   self )					->				int:




        '''simple docstring'''
        lowercase__:   List[str]  			=   XLMWithLMHeadModel.from_pretrained('xlm-mlm-en-2048' )
        model.to(lowerCAmelCase__ )
        lowercase__:   List[str]  			=   torch.tensor([[14, 447]]				, dtype=torch.long				, device=lowerCAmelCase__ )  # the president
        lowercase__:   int  			=   [
            14,
            447,
            14,
            447,
            14,
            447,
            14,
            447,
            14,
            447,
            14,
            447,
            14,
            447,
            14,
            447,
            14,
            447,
            14,
            447,
        ]  # the president the president the president the president the president the president the president the president the president the president
        # TODO(PVP): this and other input_ids I tried for generation give pretty bad results. Not sure why. Model might just not be made for auto-regressive inference
        lowercase__:   int  			=   model.generate(lowerCAmelCase__				, do_sample=lowerCAmelCase__ )
        self.assertListEqual(output_ids[0].cpu().numpy().tolist()				, lowerCAmelCase__ )






from typing import TYPE_CHECKING

from ...utils import (
    OptionalDependencyNotAvailable,
    _LazyModule,
    is_torch_available,
)


__lowerCAmelCase		       =							{
    '''configuration_encodec''': [
        '''ENCODEC_PRETRAINED_CONFIG_ARCHIVE_MAP''',
        '''EncodecConfig''',
    ],
    '''feature_extraction_encodec''': ['''EncodecFeatureExtractor'''],
}

try:
 if not is_torch_available():
  raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
 pass
else:
 __lowerCAmelCase		       =							[
     '''ENCODEC_PRETRAINED_MODEL_ARCHIVE_LIST''',
     '''EncodecModel''',
     '''EncodecPreTrainedModel''',
 ]

if TYPE_CHECKING:
 from .configuration_encodec import (
     ENCODEC_PRETRAINED_CONFIG_ARCHIVE_MAP,
     EncodecConfig,
 )
 from .feature_extraction_encodec import EncodecFeatureExtractor

 try:
  if not is_torch_available():
   raise OptionalDependencyNotAvailable()
 except OptionalDependencyNotAvailable:
  pass
 else:
  from .modeling_encodec import (
      ENCODEC_PRETRAINED_MODEL_ARCHIVE_LIST,
      EncodecModel,
      EncodecPreTrainedModel,
  )

else:
 import sys

 __lowerCAmelCase		       =							_LazyModule(__name__, globals()['''__file__'''], _import_structure, module_spec=__spec__)


