
from __future__ import annotations

import unittest

from transformers import FunnelConfig, is_tf_available
from transformers.testing_utils import require_tf

from ...test_configuration_common import ConfigTester
from ...test_modeling_tf_common import TFModelTesterMixin, ids_tensor, random_attention_mask
from ...test_pipeline_mixin import PipelineTesterMixin


if is_tf_available():
 import tensorflow as tf

 from transformers import (
     TFFunnelBaseModel,
     TFFunnelForMaskedLM,
     TFFunnelForMultipleChoice,
     TFFunnelForPreTraining,
     TFFunnelForQuestionAnswering,
     TFFunnelForSequenceClassification,
     TFFunnelForTokenClassification,
     TFFunnelModel,
 )
class       _lowerCAmelCase  :

 """simple docstring"""

 def __init__(						self			:			Dict					, SCREAMING_SNAKE_CASE__			:			int					, SCREAMING_SNAKE_CASE__			:			Any=13					, SCREAMING_SNAKE_CASE__			:			Dict=7					, SCREAMING_SNAKE_CASE__			:			str=True					, SCREAMING_SNAKE_CASE__			:			Optional[int]=True					, SCREAMING_SNAKE_CASE__			:			Optional[Any]=True					, SCREAMING_SNAKE_CASE__			:			List[str]=True					, SCREAMING_SNAKE_CASE__			:			str=99					, SCREAMING_SNAKE_CASE__			:			str=[1, 1, 2]					, SCREAMING_SNAKE_CASE__			:			Optional[Any]=1					, SCREAMING_SNAKE_CASE__			:			List[Any]=32					, SCREAMING_SNAKE_CASE__			:			List[Any]=4					, SCREAMING_SNAKE_CASE__			:			Dict=8					, SCREAMING_SNAKE_CASE__			:			List[Any]=37					, SCREAMING_SNAKE_CASE__			:			List[str]="gelu_new"					, SCREAMING_SNAKE_CASE__			:			Optional[int]=0.1					, SCREAMING_SNAKE_CASE__			:			Any=0.1					, SCREAMING_SNAKE_CASE__			:			int=0.0					, SCREAMING_SNAKE_CASE__			:			Union[str, Any]=5_12					, SCREAMING_SNAKE_CASE__			:			Any=3					, SCREAMING_SNAKE_CASE__			:			Tuple=0.02					, SCREAMING_SNAKE_CASE__			:			List[str]=3					, SCREAMING_SNAKE_CASE__			:			Union[str, Any]=4					, SCREAMING_SNAKE_CASE__			:			Optional[Any]=None					, SCREAMING_SNAKE_CASE__			:			Dict=False					, ):






      """simple docstring"""



      UpperCamelCase						    =					parent
      UpperCamelCase						    =					batch_size
      UpperCamelCase						    =					seq_length
      UpperCamelCase						    =					is_training
      UpperCamelCase						    =					use_input_mask
      UpperCamelCase						    =					use_token_type_ids
      UpperCamelCase						    =					use_labels
      UpperCamelCase						    =					vocab_size
      UpperCamelCase						    =					block_sizes
      UpperCamelCase						    =					num_decoder_layers
      UpperCamelCase						    =					d_model
      UpperCamelCase						    =					n_head
      UpperCamelCase						    =					d_head
      UpperCamelCase						    =					d_inner
      UpperCamelCase						    =					hidden_act
      UpperCamelCase						    =					hidden_dropout
      UpperCamelCase						    =					attention_dropout
      UpperCamelCase						    =					activation_dropout
      UpperCamelCase						    =					max_position_embeddings
      UpperCamelCase						    =					type_vocab_size
      UpperCamelCase						    =					2
      UpperCamelCase						    =					num_labels
      UpperCamelCase						    =					num_choices
      UpperCamelCase						    =					scope
      UpperCamelCase						    =					initializer_std

      # Used in the tests to check the size of the first attention layer
      UpperCamelCase						    =					n_head
      # Used in the tests to check the size of the first hidden state
      UpperCamelCase						    =					self.d_model
      # Used in the tests to check the number of output hidden states/attentions
      UpperCamelCase						    =					sum(self.block_sizes   ) + (0 if base else self.num_decoder_layers)
      # FunnelModel adds two hidden layers: input embeddings and the sum of the upsampled encoder hidden state with
      # the last hidden state of the first block (which is the first hidden state of the decoder).
      if not base:
           UpperCamelCase						    =					self.num_hidden_layers + 2

 def      __lowerCAmelCase  (						self			:			Tuple   ):






      """simple docstring"""



      UpperCamelCase						    =					ids_tensor([self.batch_size, self.seq_length]					, self.vocab_size   )

      UpperCamelCase						    =					None
      if self.use_input_mask:
           UpperCamelCase						    =					random_attention_mask([self.batch_size, self.seq_length]   )

      UpperCamelCase						    =					None
      if self.use_token_type_ids:
           UpperCamelCase						    =					ids_tensor([self.batch_size, self.seq_length]					, self.type_vocab_size   )

      UpperCamelCase						    =					None
      UpperCamelCase						    =					None
      UpperCamelCase						    =					None
      if self.use_labels:
           UpperCamelCase						    =					ids_tensor([self.batch_size]					, self.type_sequence_label_size   )
           UpperCamelCase						    =					ids_tensor([self.batch_size, self.seq_length]					, self.num_labels   )
           UpperCamelCase						    =					ids_tensor([self.batch_size]					, self.num_choices   )

      UpperCamelCase						    =					FunnelConfig(
          vocab_size=self.vocab_size					, block_sizes=self.block_sizes					, num_decoder_layers=self.num_decoder_layers					, d_model=self.d_model					, n_head=self.n_head					, d_head=self.d_head					, d_inner=self.d_inner					, hidden_act=self.hidden_act					, hidden_dropout=self.hidden_dropout					, attention_dropout=self.attention_dropout					, activation_dropout=self.activation_dropout					, max_position_embeddings=self.max_position_embeddings					, type_vocab_size=self.type_vocab_size					, initializer_std=self.initializer_std					, )

      return (
          config,
          input_ids,
          token_type_ids,
          input_mask,
          sequence_labels,
          token_labels,
          choice_labels,
      )

 def      __lowerCAmelCase  (						self			:			List[Any]					, SCREAMING_SNAKE_CASE__			:			Optional[Any]					, SCREAMING_SNAKE_CASE__			:			Union[str, Any]					, SCREAMING_SNAKE_CASE__			:			int					, SCREAMING_SNAKE_CASE__			:			int					, SCREAMING_SNAKE_CASE__			:			Union[str, Any]					, SCREAMING_SNAKE_CASE__			:			Union[str, Any]					, SCREAMING_SNAKE_CASE__			:			int					, ):






      """simple docstring"""



      UpperCamelCase						    =					TFFunnelModel(config=_SCREAMING_SNAKE_CASE   )
      UpperCamelCase						    =					{'input_ids': input_ids, 'attention_mask': input_mask, 'token_type_ids': token_type_ids}
      UpperCamelCase						    =					model(_SCREAMING_SNAKE_CASE   )

      UpperCamelCase						    =					[input_ids, input_mask]
      UpperCamelCase						    =					model(_SCREAMING_SNAKE_CASE   )

      UpperCamelCase						    =					model(_SCREAMING_SNAKE_CASE   )
      self.parent.assertEqual(result.last_hidden_state.shape					, (self.batch_size, self.seq_length, self.d_model)   )

      UpperCamelCase						    =					False
      UpperCamelCase						    =					TFFunnelModel(config=_SCREAMING_SNAKE_CASE   )
      UpperCamelCase						    =					model(_SCREAMING_SNAKE_CASE   )
      self.parent.assertEqual(result.last_hidden_state.shape					, (self.batch_size, self.seq_length, self.d_model)   )

      UpperCamelCase						    =					False
      UpperCamelCase						    =					TFFunnelModel(config=_SCREAMING_SNAKE_CASE   )
      UpperCamelCase						    =					model(_SCREAMING_SNAKE_CASE   )
      self.parent.assertEqual(result.last_hidden_state.shape					, (self.batch_size, self.seq_length, self.d_model)   )

 def      __lowerCAmelCase  (						self			:			int					, SCREAMING_SNAKE_CASE__			:			List[str]					, SCREAMING_SNAKE_CASE__			:			List[str]					, SCREAMING_SNAKE_CASE__			:			Dict					, SCREAMING_SNAKE_CASE__			:			Any					, SCREAMING_SNAKE_CASE__			:			int					, SCREAMING_SNAKE_CASE__			:			Optional[int]					, SCREAMING_SNAKE_CASE__			:			int					, ):






      """simple docstring"""



      UpperCamelCase						    =					TFFunnelBaseModel(config=_SCREAMING_SNAKE_CASE   )
      UpperCamelCase						    =					{'input_ids': input_ids, 'attention_mask': input_mask, 'token_type_ids': token_type_ids}
      UpperCamelCase						    =					model(_SCREAMING_SNAKE_CASE   )

      UpperCamelCase						    =					[input_ids, input_mask]
      UpperCamelCase						    =					model(_SCREAMING_SNAKE_CASE   )

      UpperCamelCase						    =					model(_SCREAMING_SNAKE_CASE   )
      self.parent.assertEqual(result.last_hidden_state.shape					, (self.batch_size, 2, self.d_model)   )

      UpperCamelCase						    =					False
      UpperCamelCase						    =					TFFunnelBaseModel(config=_SCREAMING_SNAKE_CASE   )
      UpperCamelCase						    =					model(_SCREAMING_SNAKE_CASE   )
      self.parent.assertEqual(result.last_hidden_state.shape					, (self.batch_size, 3, self.d_model)   )

      UpperCamelCase						    =					False
      UpperCamelCase						    =					TFFunnelBaseModel(config=_SCREAMING_SNAKE_CASE   )
      UpperCamelCase						    =					model(_SCREAMING_SNAKE_CASE   )
      self.parent.assertEqual(result.last_hidden_state.shape					, (self.batch_size, 2, self.d_model)   )

 def      __lowerCAmelCase  (						self			:			Optional[int]					, SCREAMING_SNAKE_CASE__			:			Optional[Any]					, SCREAMING_SNAKE_CASE__			:			Optional[int]					, SCREAMING_SNAKE_CASE__			:			Optional[Any]					, SCREAMING_SNAKE_CASE__			:			str					, SCREAMING_SNAKE_CASE__			:			Optional[Any]					, SCREAMING_SNAKE_CASE__			:			int					, SCREAMING_SNAKE_CASE__			:			Dict					, ):






      """simple docstring"""



      UpperCamelCase						    =					TFFunnelForPreTraining(config=_SCREAMING_SNAKE_CASE   )
      UpperCamelCase						    =					{'input_ids': input_ids, 'attention_mask': input_mask, 'token_type_ids': token_type_ids}
      UpperCamelCase						    =					model(_SCREAMING_SNAKE_CASE   )
      self.parent.assertEqual(result.logits.shape					, (self.batch_size, self.seq_length)   )

 def      __lowerCAmelCase  (						self			:			Tuple					, SCREAMING_SNAKE_CASE__			:			Union[str, Any]					, SCREAMING_SNAKE_CASE__			:			Optional[Any]					, SCREAMING_SNAKE_CASE__			:			str					, SCREAMING_SNAKE_CASE__			:			Tuple					, SCREAMING_SNAKE_CASE__			:			Dict					, SCREAMING_SNAKE_CASE__			:			int					, SCREAMING_SNAKE_CASE__			:			List[str]					, ):






      """simple docstring"""



      UpperCamelCase						    =					TFFunnelForMaskedLM(config=_SCREAMING_SNAKE_CASE   )
      UpperCamelCase						    =					{'input_ids': input_ids, 'attention_mask': input_mask, 'token_type_ids': token_type_ids}
      UpperCamelCase						    =					model(_SCREAMING_SNAKE_CASE   )
      self.parent.assertEqual(result.logits.shape					, (self.batch_size, self.seq_length, self.vocab_size)   )

 def      __lowerCAmelCase  (						self			:			Union[str, Any]					, SCREAMING_SNAKE_CASE__			:			Any					, SCREAMING_SNAKE_CASE__			:			Dict					, SCREAMING_SNAKE_CASE__			:			Optional[Any]					, SCREAMING_SNAKE_CASE__			:			Tuple					, SCREAMING_SNAKE_CASE__			:			Union[str, Any]					, SCREAMING_SNAKE_CASE__			:			List[Any]					, SCREAMING_SNAKE_CASE__			:			int					, ):






      """simple docstring"""



      UpperCamelCase						    =					self.num_labels
      UpperCamelCase						    =					TFFunnelForSequenceClassification(config=_SCREAMING_SNAKE_CASE   )
      UpperCamelCase						    =					{'input_ids': input_ids, 'attention_mask': input_mask, 'token_type_ids': token_type_ids}
      UpperCamelCase						    =					model(_SCREAMING_SNAKE_CASE   )
      self.parent.assertEqual(result.logits.shape					, (self.batch_size, self.num_labels)   )

 def      __lowerCAmelCase  (						self			:			Optional[Any]					, SCREAMING_SNAKE_CASE__			:			List[str]					, SCREAMING_SNAKE_CASE__			:			str					, SCREAMING_SNAKE_CASE__			:			Optional[int]					, SCREAMING_SNAKE_CASE__			:			List[str]					, SCREAMING_SNAKE_CASE__			:			List[Any]					, SCREAMING_SNAKE_CASE__			:			Union[str, Any]					, SCREAMING_SNAKE_CASE__			:			Tuple					, ):






      """simple docstring"""



      UpperCamelCase						    =					self.num_choices
      UpperCamelCase						    =					TFFunnelForMultipleChoice(config=_SCREAMING_SNAKE_CASE   )
      UpperCamelCase						    =					tf.tile(tf.expand_dims(_SCREAMING_SNAKE_CASE					, 1   )					, (1, self.num_choices, 1)   )
      UpperCamelCase						    =					tf.tile(tf.expand_dims(_SCREAMING_SNAKE_CASE					, 1   )					, (1, self.num_choices, 1)   )
      UpperCamelCase						    =					tf.tile(tf.expand_dims(_SCREAMING_SNAKE_CASE					, 1   )					, (1, self.num_choices, 1)   )
      UpperCamelCase						    =					{
          'input_ids': multiple_choice_inputs_ids,
          'attention_mask': multiple_choice_input_mask,
          'token_type_ids': multiple_choice_token_type_ids,
      }
      UpperCamelCase						    =					model(_SCREAMING_SNAKE_CASE   )
      self.parent.assertEqual(result.logits.shape					, (self.batch_size, self.num_choices)   )

 def      __lowerCAmelCase  (						self			:			str					, SCREAMING_SNAKE_CASE__			:			int					, SCREAMING_SNAKE_CASE__			:			int					, SCREAMING_SNAKE_CASE__			:			Tuple					, SCREAMING_SNAKE_CASE__			:			int					, SCREAMING_SNAKE_CASE__			:			Tuple					, SCREAMING_SNAKE_CASE__			:			Optional[int]					, SCREAMING_SNAKE_CASE__			:			int					, ):






      """simple docstring"""



      UpperCamelCase						    =					self.num_labels
      UpperCamelCase						    =					TFFunnelForTokenClassification(config=_SCREAMING_SNAKE_CASE   )
      UpperCamelCase						    =					{'input_ids': input_ids, 'attention_mask': input_mask, 'token_type_ids': token_type_ids}
      UpperCamelCase						    =					model(_SCREAMING_SNAKE_CASE   )
      self.parent.assertEqual(result.logits.shape					, (self.batch_size, self.seq_length, self.num_labels)   )

 def      __lowerCAmelCase  (						self			:			Union[str, Any]					, SCREAMING_SNAKE_CASE__			:			int					, SCREAMING_SNAKE_CASE__			:			Optional[Any]					, SCREAMING_SNAKE_CASE__			:			Union[str, Any]					, SCREAMING_SNAKE_CASE__			:			str					, SCREAMING_SNAKE_CASE__			:			Any					, SCREAMING_SNAKE_CASE__			:			Any					, SCREAMING_SNAKE_CASE__			:			Union[str, Any]					, ):






      """simple docstring"""



      UpperCamelCase						    =					TFFunnelForQuestionAnswering(config=_SCREAMING_SNAKE_CASE   )
      UpperCamelCase						    =					{'input_ids': input_ids, 'attention_mask': input_mask, 'token_type_ids': token_type_ids}
      UpperCamelCase						    =					model(_SCREAMING_SNAKE_CASE   )
      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      __lowerCAmelCase  (						self			:			Union[str, Any]   ):






      """simple docstring"""



      UpperCamelCase						    =					self.prepare_config_and_inputs()
      (
          (
          UpperCamelCase   
      )    ,		(
          UpperCamelCase   
      )    ,		(
          UpperCamelCase   
      )    ,		(
          UpperCamelCase   
      )    ,		(
          UpperCamelCase   
      )    ,		(
          UpperCamelCase   
      )    ,		(
          UpperCamelCase   
      )    ,		   
      )						    =					config_and_inputs
      UpperCamelCase						    =					{'input_ids': input_ids, 'token_type_ids': token_type_ids, 'attention_mask': input_mask}
      return config, inputs_dict




@require_tf
class       _lowerCAmelCase  (		a_			,	a_			,	unittest.TestCase							):

 """simple docstring"""
 SCREAMING_SNAKE_CASE_				:					int       						=(
     (
         TFFunnelModel,
         TFFunnelForMaskedLM,
         TFFunnelForPreTraining,
         TFFunnelForQuestionAnswering,
         TFFunnelForTokenClassification,
     )
     if is_tf_available()
     else ()
 )
 SCREAMING_SNAKE_CASE_				:					Optional[int]       						=(
     {
         '''feature-extraction''': (TFFunnelBaseModel, TFFunnelModel),
         '''fill-mask''': TFFunnelForMaskedLM,
         '''question-answering''': TFFunnelForQuestionAnswering,
         '''text-classification''': TFFunnelForSequenceClassification,
         '''token-classification''': TFFunnelForTokenClassification,
         '''zero-shot''': TFFunnelForSequenceClassification,
     }
     if is_tf_available()
     else {}
 )
 SCREAMING_SNAKE_CASE_				:					Tuple       						=False
 SCREAMING_SNAKE_CASE_				:					List[Any]       						=False

 def      __lowerCAmelCase  (						self			:			Tuple   ):






      """simple docstring"""



      UpperCamelCase						    =					TFFunnelModelTester(self   )
      UpperCamelCase						    =					ConfigTester(self					, config_class=_SCREAMING_SNAKE_CASE   )

 def      __lowerCAmelCase  (						self			:			List[Any]   ):






      """simple docstring"""



      self.config_tester.run_common_tests()

 def      __lowerCAmelCase  (						self			:			List[Any]   ):






      """simple docstring"""



      UpperCamelCase						    =					self.model_tester.prepare_config_and_inputs()
      self.model_tester.create_and_check_model(*_SCREAMING_SNAKE_CASE   )

 def      __lowerCAmelCase  (						self			:			Dict   ):






      """simple docstring"""



      UpperCamelCase						    =					self.model_tester.prepare_config_and_inputs()
      self.model_tester.create_and_check_for_pretraining(*_SCREAMING_SNAKE_CASE   )

 def      __lowerCAmelCase  (						self			:			Dict   ):






      """simple docstring"""



      UpperCamelCase						    =					self.model_tester.prepare_config_and_inputs()
      self.model_tester.create_and_check_for_masked_lm(*_SCREAMING_SNAKE_CASE   )

 def      __lowerCAmelCase  (						self			:			int   ):






      """simple docstring"""



      UpperCamelCase						    =					self.model_tester.prepare_config_and_inputs()
      self.model_tester.create_and_check_for_token_classification(*_SCREAMING_SNAKE_CASE   )






 def      __lowerCAmelCase  (						self			:			str   ):






      """simple docstring"""



      UpperCamelCase						    =					self.model_tester.prepare_config_and_inputs()
      self.model_tester.create_and_check_for_question_answering(*_SCREAMING_SNAKE_CASE   )




@require_tf
class       _lowerCAmelCase  (		a_			,	unittest.TestCase							):

 """simple docstring"""
 SCREAMING_SNAKE_CASE_				:					List[Any]       						=(
     (TFFunnelBaseModel, TFFunnelForMultipleChoice, TFFunnelForSequenceClassification) if is_tf_available() else ()
 )
 SCREAMING_SNAKE_CASE_				:					List[str]       						=False
 SCREAMING_SNAKE_CASE_				:					Optional[Any]       						=False

 def      __lowerCAmelCase  (						self			:			List[str]   ):






      """simple docstring"""



      UpperCamelCase						    =					TFFunnelModelTester(self					, base=_SCREAMING_SNAKE_CASE   )
      UpperCamelCase						    =					ConfigTester(self					, config_class=_SCREAMING_SNAKE_CASE   )

 def      __lowerCAmelCase  (						self			:			Dict   ):






      """simple docstring"""



      self.config_tester.run_common_tests()

 def      __lowerCAmelCase  (						self			:			Union[str, Any]   ):






      """simple docstring"""



      UpperCamelCase						    =					self.model_tester.prepare_config_and_inputs()
      self.model_tester.create_and_check_base_model(*_SCREAMING_SNAKE_CASE   )

 def      __lowerCAmelCase  (						self			:			Dict   ):






      """simple docstring"""



      UpperCamelCase						    =					self.model_tester.prepare_config_and_inputs()
      self.model_tester.create_and_check_for_sequence_classification(*_SCREAMING_SNAKE_CASE   )






 def      __lowerCAmelCase  (						self			:			Tuple   ):






      """simple docstring"""



      UpperCamelCase						    =					self.model_tester.prepare_config_and_inputs()
      self.model_tester.create_and_check_for_multiple_choice(*_SCREAMING_SNAKE_CASE   )





'''simple docstring'''



import itertools
from dataclasses import dataclass
from typing import Optional

import pandas as pd
import pyarrow as pa

import datasets
from datasets.table import table_cast



@dataclass
class 				_snake_case					(   datasets.BuilderConfig			):
  SCREAMING_SNAKE_CASE			:       Optional[datasets.Features]				=     None



class 				_snake_case					(   datasets.ArrowBasedBuilder			):
  SCREAMING_SNAKE_CASE			:       Tuple				=     PandasConfig

  def   _SCREAMING_SNAKE_CASE				(				self	):





      '''simple docstring'''

      return datasets.DatasetInfo(features=self.config.features	)

  def   _SCREAMING_SNAKE_CASE				(				self      , _SCREAMING_SNAKE_CASE	):





      '''simple docstring'''

      if not self.config.data_files:
          raise ValueError(F'At least one data file must be specified, but got data_files={self.config.data_files}'	)
      lowerCAmelCase 						=							dl_manager.download_and_extract(self.config.data_files	)
      if isinstance(_SCREAMING_SNAKE_CASE      , (str, list, tuple)	):
          lowerCAmelCase 						=							data_files
          if isinstance(_SCREAMING_SNAKE_CASE      , _SCREAMING_SNAKE_CASE	):
              lowerCAmelCase 						=							[files]
          # Use `dl_manager.iter_files` to skip hidden files in an extracted archive
          lowerCAmelCase 						=							[dl_manager.iter_files(_SCREAMING_SNAKE_CASE	) for file in files]
          return [datasets.SplitGenerator(name=datasets.Split.TRAIN      , gen_kwargs={'files': files}	)]
      lowerCAmelCase 						=							[]
      for split_name, files in data_files.items():
          if isinstance(_SCREAMING_SNAKE_CASE      , _SCREAMING_SNAKE_CASE	):
              lowerCAmelCase 						=							[files]
          # Use `dl_manager.iter_files` to skip hidden files in an extracted archive
          lowerCAmelCase 						=							[dl_manager.iter_files(_SCREAMING_SNAKE_CASE	) for file in files]
          splits.append(datasets.SplitGenerator(name=_SCREAMING_SNAKE_CASE      , gen_kwargs={'files': files}	)	)
      return splits

  def   _SCREAMING_SNAKE_CASE				(				self      , _SCREAMING_SNAKE_CASE	):





      '''simple docstring'''

      if self.config.features is not None:
          # more expensive cast to support nested features with keys in a different order
          # allows str <-> int/float or str to Audio for example
          lowerCAmelCase 						=							table_cast(_SCREAMING_SNAKE_CASE      , self.config.features.arrow_schema	)
      return pa_table


  def   _SCREAMING_SNAKE_CASE				(				self      , _SCREAMING_SNAKE_CASE	):





      '''simple docstring'''

      for i, file in enumerate(itertools.chain.from_iterable(_SCREAMING_SNAKE_CASE	)	):
          with open(_SCREAMING_SNAKE_CASE      , 'rb'	) as f:
              lowerCAmelCase 						=							pa.Table.from_pandas(pd.read_pickle(_SCREAMING_SNAKE_CASE	)	)
              yield i, self._cast_table(_SCREAMING_SNAKE_CASE	)





