

'''simple docstring'''

from typing import List, Optional, Union

import numpy as np
import torch
import torchaudio.compliance.kaldi as ta_kaldi

from ...feature_extraction_sequence_utils import SequenceFeatureExtractor
from ...feature_extraction_utils import BatchFeature
from ...utils import PaddingStrategy, TensorType, logging


A_				  =							logging.get_logger(__name__)





class 							_snake_case       (				A__  ):
   _A				:   Optional[int]			      =    ['''input_features''', '''attention_mask''']
   def __init__(       self	:					str   ,SCREAMING_SNAKE_CASE__	:					List[str]=80   ,SCREAMING_SNAKE_CASE__	:					Optional[Any]=16_000   ,SCREAMING_SNAKE_CASE__	:					Dict=80   ,SCREAMING_SNAKE_CASE__	:					int=0.0   ,SCREAMING_SNAKE_CASE__	:					Tuple=True   ,SCREAMING_SNAKE_CASE__	:					Any=True   ,SCREAMING_SNAKE_CASE__	:					Tuple=True   ,**SCREAMING_SNAKE_CASE__	:					List[str]   ,):
     super().__init__(feature_size=UpperCamelCase_   ,sampling_rate=UpperCamelCase_   ,padding_value=UpperCamelCase_   ,**UpperCamelCase_							)
     SCREAMING_SNAKE_CASE:Union[str, Any]  					=    num_mel_bins
     SCREAMING_SNAKE_CASE:int  					=    do_ceptral_normalize
     SCREAMING_SNAKE_CASE:List[str]  					=    normalize_means
     SCREAMING_SNAKE_CASE:Union[str, Any]  					=    normalize_vars
     SCREAMING_SNAKE_CASE:Union[str, Any]  					=    True
   def 			__UpperCamelCase  (       self	:					Tuple   ,SCREAMING_SNAKE_CASE__	:					str   ,):
     SCREAMING_SNAKE_CASE:List[Any]  					=    waveform * (2**15)  # Kaldi compliance: 16-bit signed integers
     SCREAMING_SNAKE_CASE:Optional[int]  					=    torch.from_numpy(UpperCamelCase_							).unsqueeze(0							)
     SCREAMING_SNAKE_CASE:Tuple  					=    ta_kaldi.fbank(UpperCamelCase_   ,num_mel_bins=self.num_mel_bins   ,sample_frequency=self.sampling_rate							)
     return features.numpy()
   @staticmethod
   def 			__UpperCamelCase  (       SCREAMING_SNAKE_CASE__	:					int   ,SCREAMING_SNAKE_CASE__	:					int   ,SCREAMING_SNAKE_CASE__	:					List[Any] = True   ,SCREAMING_SNAKE_CASE__	:					List[str] = True   ,SCREAMING_SNAKE_CASE__	:					Union[str, Any] = 0.0   ,):


     if normalize_means:
       SCREAMING_SNAKE_CASE:Optional[Any]  					=    x[:input_length].mean(axis=0							)
       SCREAMING_SNAKE_CASE:Optional[Any]  					=    np.subtract(UpperCamelCase_   ,UpperCamelCase_							)
     if normalize_vars:
       SCREAMING_SNAKE_CASE:Union[str, Any]  					=    x[:input_length].std(axis=0							)
       SCREAMING_SNAKE_CASE:List[str]  					=    np.divide(UpperCamelCase_   ,UpperCamelCase_							)

     if input_length < x.shape[0]:
       SCREAMING_SNAKE_CASE:int  					=    padding_value

     # make sure array is in float32
     SCREAMING_SNAKE_CASE:List[str]  					=    x.astype(np.floataa							)

     return x
   def 			__UpperCamelCase  (       self	:					Optional[int]   ,SCREAMING_SNAKE_CASE__	:					Optional[int]   ,SCREAMING_SNAKE_CASE__	:					Tuple = None							):
     SCREAMING_SNAKE_CASE:Union[str, Any]  					=    attention_mask.sum(-1							) if attention_mask is not None else [x.shape[0] for x in input_features]
     return [
         self.utterance_cmvn(UpperCamelCase_   ,UpperCamelCase_   ,self.normalize_means   ,self.normalize_vars   ,self.padding_value							)
         for x, n in zip(UpperCamelCase_   ,UpperCamelCase_							)
     ]







   def __call__(       self	:					List[Any]   ,SCREAMING_SNAKE_CASE__	:					Optional[Any]   ,SCREAMING_SNAKE_CASE__	:					Dict = False   ,SCREAMING_SNAKE_CASE__	:					Optional[int] = None   ,SCREAMING_SNAKE_CASE__	:					Any = False   ,SCREAMING_SNAKE_CASE__	:					Optional[Any] = None   ,SCREAMING_SNAKE_CASE__	:					Any = None   ,SCREAMING_SNAKE_CASE__	:					Dict = None   ,SCREAMING_SNAKE_CASE__	:					Any = None   ,**SCREAMING_SNAKE_CASE__	:					Union[str, Any]   ,):


     if sampling_rate is not None:
       if sampling_rate != self.sampling_rate:
         raise ValueError(
             F'''The model corresponding to this feature extractor: {self} was trained using a sampling rate of'''
             F''' {self.sampling_rate}. Please make sure that the provided `raw_speech` input was sampled with'''
             F''' {self.sampling_rate} and not {sampling_rate}.'''							)
     else:
       logger.warning(
           "It is strongly recommended to pass the `sampling_rate` argument to this function. "
           "Failing to do so can result in silent errors that might be hard to debug."							)

     SCREAMING_SNAKE_CASE:Dict  					=    isinstance(UpperCamelCase_   ,np.ndarray							) and len(raw_speech.shape							) > 1
     if is_batched_numpy and len(raw_speech.shape							) > 2:
       raise ValueError(F'''Only mono-channel audio is supported for input to {self}'''							)
     SCREAMING_SNAKE_CASE:Tuple  					=    is_batched_numpy or (
         isinstance(UpperCamelCase_   ,(list, tuple)							) and (isinstance(raw_speech[0]   ,(np.ndarray, tuple, list)							))
     )

     if is_batched:
       SCREAMING_SNAKE_CASE:str  					=    [np.asarray(UpperCamelCase_   ,dtype=np.floataa							) for speech in raw_speech]
     elif not is_batched and not isinstance(UpperCamelCase_   ,np.ndarray							):
       SCREAMING_SNAKE_CASE:int  					=    np.asarray(UpperCamelCase_   ,dtype=np.floataa							)
     elif isinstance(UpperCamelCase_   ,np.ndarray							) and raw_speech.dtype is np.dtype(np.floataa							):
       SCREAMING_SNAKE_CASE:Optional[Any]  					=    raw_speech.astype(np.floataa							)

     # always return batch
     if not is_batched:
       SCREAMING_SNAKE_CASE:str  					=    [raw_speech]

     # extract fbank features
     SCREAMING_SNAKE_CASE:Tuple  					=    [self._extract_fbank_features(UpperCamelCase_							) for waveform in raw_speech]

     # convert into correct format for padding
     SCREAMING_SNAKE_CASE:Optional[Any]  					=    BatchFeature({"input_features": features}							)

     SCREAMING_SNAKE_CASE:Union[str, Any]  					=    self.pad(
         UpperCamelCase_   ,padding=UpperCamelCase_   ,max_length=UpperCamelCase_   ,truncation=UpperCamelCase_   ,pad_to_multiple_of=UpperCamelCase_   ,return_attention_mask=UpperCamelCase_   ,**UpperCamelCase_   ,)

     # make sure list is in array format
     SCREAMING_SNAKE_CASE:Dict  					=    padded_inputs.get("input_features"							)
     if isinstance(input_features[0]   ,UpperCamelCase_							):
       SCREAMING_SNAKE_CASE:str  					=    [np.asarray(UpperCamelCase_   ,dtype=np.floataa							) for feature in input_features]

     SCREAMING_SNAKE_CASE:Tuple  					=    padded_inputs.get("attention_mask"							)
     if attention_mask is not None:
       SCREAMING_SNAKE_CASE:Optional[int]  					=    [np.asarray(UpperCamelCase_   ,dtype=np.intaa							) for array in attention_mask]

     # Utterance-level cepstral mean and variance normalization
     if self.do_ceptral_normalize:
       SCREAMING_SNAKE_CASE:Any  					=    (
           np.array(UpperCamelCase_   ,dtype=np.intaa							)
           if self._get_padding_strategies(UpperCamelCase_   ,max_length=UpperCamelCase_							) is not PaddingStrategy.DO_NOT_PAD
           else None
       )
       SCREAMING_SNAKE_CASE:Any  					=    self.normalize(
           padded_inputs["input_features"]   ,attention_mask=UpperCamelCase_							)

     if return_tensors is not None:
       SCREAMING_SNAKE_CASE:Any  					=    padded_inputs.convert_to_tensors(UpperCamelCase_							)

     return padded_inputs










'''simple docstring'''
import io
import json

import fsspec
import pytest

from datasets import Dataset, DatasetDict, Features, NamedSplit, Value
from datasets.io.json import JsonDatasetReader, JsonDatasetWriter

from ..utils import assert_arrow_memory_doesnt_increase, assert_arrow_memory_increases


def 			a      (			__a ,					__a   )  ->	Optional[int]:



					'''simple docstring'''






					assert isinstance(__a ,					__a   )
					assert dataset.num_rows == 4
					assert dataset.num_columns == 3
					assert dataset.column_names == ["col_1", "col_2", "col_3"]
					for feature, expected_dtype in expected_features.items():
										assert dataset.features[feature].dtype == expected_dtype


@pytest.mark.parametrize('''keep_in_memory''' ,					[False, True]   )
def 			a      (			__a ,					__a ,					__a   )  ->	Optional[Any]:



					'''simple docstring'''






					UpperCamelCase__   :Union[str, Any]												= tmp_path / '''cache'''
					UpperCamelCase__   :Dict												= {'''col_1''': '''string''', '''col_2''': '''int64''', '''col_3''': '''float64'''}
					with assert_arrow_memory_increases() if keep_in_memory else assert_arrow_memory_doesnt_increase():
										UpperCamelCase__   :Tuple												= JsonDatasetReader(__a ,					cache_dir=__a ,					keep_in_memory=__a   ).read()
					_check_json_dataset(__a ,					__a   )


@pytest.mark.parametrize(
    '''features''' ,					[
        None,
        {'''col_1''': '''string''', '''col_2''': '''int64''', '''col_3''': '''float64'''},
        {'''col_1''': '''string''', '''col_2''': '''string''', '''col_3''': '''string'''},
        {'''col_1''': '''int32''', '''col_2''': '''int32''', '''col_3''': '''int32'''},
        {'''col_1''': '''float32''', '''col_2''': '''float32''', '''col_3''': '''float32'''},
    ] ,					)
def 			a      (			__a ,					__a ,					__a   )  ->	Any:



					'''simple docstring'''






					UpperCamelCase__   :Union[str, Any]												= tmp_path / '''cache'''
					UpperCamelCase__   :Optional[Any]												= {'''col_1''': '''string''', '''col_2''': '''int64''', '''col_3''': '''float64'''}
					UpperCamelCase__   :Optional[Any]												= features.copy() if features else default_expected_features
					UpperCamelCase__   :Tuple												= (
					    Features({feature: Value(__a   ) for feature, dtype in features.items()}   ) if features is not None else None
					)
					UpperCamelCase__   :int												= JsonDatasetReader(__a ,					features=__a ,					cache_dir=__a   ).read()
					_check_json_dataset(__a ,					__a   )


@pytest.mark.parametrize(
    '''features''' ,					[
        None,
        {'''col_3''': '''float64''', '''col_1''': '''string''', '''col_2''': '''int64'''},
    ] ,					)
def 			a      (			__a ,					__a ,					__a   )  ->	Tuple:



					'''simple docstring'''






					UpperCamelCase__   :int												= tmp_path / '''cache'''
					UpperCamelCase__   :str												= {'''col_3''': '''float64''', '''col_1''': '''string''', '''col_2''': '''int64'''}
					UpperCamelCase__   :Any												= features.copy() if features else default_expected_features
					UpperCamelCase__   :Union[str, Any]												= (
					    Features({feature: Value(__a   ) for feature, dtype in features.items()}   ) if features is not None else None
					)
					UpperCamelCase__   :Any												= JsonDatasetReader(__a ,					features=__a ,					cache_dir=__a   ).read()
					assert isinstance(__a ,					__a   )
					assert dataset.num_rows == 2
					assert dataset.num_columns == 3
					assert dataset.column_names == ["col_3", "col_1", "col_2"]
					for feature, expected_dtype in expected_features.items():
										assert dataset.features[feature].dtype == expected_dtype


def 			a      (			__a ,					__a   )  ->	List[Any]:



					'''simple docstring'''






					UpperCamelCase__   :Any												= {'''col_2''': '''int64''', '''col_3''': '''float64''', '''col_1''': '''string'''}
					UpperCamelCase__   :int												= features.copy()
					UpperCamelCase__   :List[Any]												= (
					    Features({feature: Value(__a   ) for feature, dtype in features.items()}   ) if features is not None else None
					)
					UpperCamelCase__   :Optional[int]												= tmp_path / '''cache'''
					UpperCamelCase__   :Dict												= JsonDatasetReader(__a ,					features=__a ,					cache_dir=__a   ).read()
					assert isinstance(__a ,					__a   )
					assert dataset.num_rows == 2
					assert dataset.num_columns == 3
					assert dataset.column_names == ["col_2", "col_3", "col_1"]
					for feature, expected_dtype in expected_features.items():
										assert dataset.features[feature].dtype == expected_dtype


@pytest.mark.parametrize('''split''' ,					[None, NamedSplit('''train'''   ), '''train''', '''test''']   )
def 			a      (			__a ,					__a ,					__a   )  ->	List[Any]:



					'''simple docstring'''






					UpperCamelCase__   :Union[str, Any]												= tmp_path / '''cache'''
					UpperCamelCase__   :Optional[Any]												= {'''col_1''': '''string''', '''col_2''': '''int64''', '''col_3''': '''float64'''}
					UpperCamelCase__   :List[Any]												= JsonDatasetReader(__a ,					cache_dir=__a ,					split=__a   ).read()
					_check_json_dataset(__a ,					__a   )
					assert dataset.split == split if split else "train"


@pytest.mark.parametrize('''path_type''' ,					[str, list]   )
def 			a      (			__a ,					__a ,					__a   )  ->	Any:



					'''simple docstring'''






					if issubclass(__a ,					__a   ):
										UpperCamelCase__   :Union[str, Any]												= jsonl_path
					elif issubclass(__a ,					__a   ):
										UpperCamelCase__   :int												= [jsonl_path]
					UpperCamelCase__   :Dict												= tmp_path / '''cache'''
					UpperCamelCase__   :Any												= {'''col_1''': '''string''', '''col_2''': '''int64''', '''col_3''': '''float64'''}
					UpperCamelCase__   :List[str]												= JsonDatasetReader(__a ,					cache_dir=__a   ).read()
					_check_json_dataset(__a ,					__a   )


def 			a      (			__a ,					__a ,					__a=("train",)   )  ->	Optional[Any]:



					'''simple docstring'''






					assert isinstance(__a ,					__a   )
					for split in splits:
										UpperCamelCase__   :Optional[int]												= dataset_dict[split]
										assert dataset.num_rows == 4
										assert dataset.num_columns == 3
										assert dataset.column_names == ["col_1", "col_2", "col_3"]
										for feature, expected_dtype in expected_features.items():
															assert dataset.features[feature].dtype == expected_dtype


@pytest.mark.parametrize('''keep_in_memory''' ,					[False, True]   )
def 			a      (			__a ,					__a ,					__a   )  ->	List[str]:



					'''simple docstring'''






					UpperCamelCase__   :List[str]												= tmp_path / '''cache'''
					UpperCamelCase__   :Dict												= {'''col_1''': '''string''', '''col_2''': '''int64''', '''col_3''': '''float64'''}
					with assert_arrow_memory_increases() if keep_in_memory else assert_arrow_memory_doesnt_increase():
										UpperCamelCase__   :str												= JsonDatasetReader({'''train''': jsonl_path} ,					cache_dir=__a ,					keep_in_memory=__a   ).read()
					_check_json_datasetdict(__a ,					__a   )


@pytest.mark.parametrize(
    '''features''' ,					[
        None,
        {'''col_1''': '''string''', '''col_2''': '''int64''', '''col_3''': '''float64'''},
        {'''col_1''': '''string''', '''col_2''': '''string''', '''col_3''': '''string'''},
        {'''col_1''': '''int32''', '''col_2''': '''int32''', '''col_3''': '''int32'''},
        {'''col_1''': '''float32''', '''col_2''': '''float32''', '''col_3''': '''float32'''},
    ] ,					)
def 			a      (			__a ,					__a ,					__a   )  ->	int:



					'''simple docstring'''






					UpperCamelCase__   :Tuple												= tmp_path / '''cache'''
					UpperCamelCase__   :Any												= {'''col_1''': '''string''', '''col_2''': '''int64''', '''col_3''': '''float64'''}
					UpperCamelCase__   :Optional[int]												= features.copy() if features else default_expected_features
					UpperCamelCase__   :str												= (
					    Features({feature: Value(__a   ) for feature, dtype in features.items()}   ) if features is not None else None
					)
					UpperCamelCase__   :Dict												= JsonDatasetReader({'''train''': jsonl_path} ,					features=__a ,					cache_dir=__a   ).read()
					_check_json_datasetdict(__a ,					__a   )


@pytest.mark.parametrize('''split''' ,					[None, NamedSplit('''train'''   ), '''train''', '''test''']   )
def 			a      (			__a ,					__a ,					__a   )  ->	str:



					'''simple docstring'''






					if split:
										UpperCamelCase__   :List[str]												= {split: jsonl_path}
					else:
										UpperCamelCase__   :int												= '''train'''
										UpperCamelCase__   :int												= {'''train''': jsonl_path, '''test''': jsonl_path}
					UpperCamelCase__   :Any												= tmp_path / '''cache'''
					UpperCamelCase__   :Union[str, Any]												= {'''col_1''': '''string''', '''col_2''': '''int64''', '''col_3''': '''float64'''}
					UpperCamelCase__   :Any												= JsonDatasetReader(__a ,					cache_dir=__a   ).read()
					_check_json_datasetdict(__a ,					__a ,					splits=list(path.keys()   )   )
					assert all(dataset[split].split == split for split in path.keys()   )


def 			a      (			__a   )  ->	Union[str, Any]:



					'''simple docstring'''






					return json.load(__a   )


def 			a      (			__a   )  ->	int:



					'''simple docstring'''






					return [json.loads(__a   ) for line in buffer]







class    lowercase	:

		"""simple docstring"""

		@pytest.mark.parametrize('''lines, load_json_function'''    ,   [(True, load_json_lines), (False, load_json)]							)
		def     lowerCAmelCase__				(		self    ,   UpperCamelCase_    ,   UpperCamelCase_    ,   UpperCamelCase_							):

							'''simple docstring'''


							with io.BytesIO() as buffer:
												JsonDatasetWriter(UpperCamelCase_    ,   UpperCamelCase_    ,   lines=UpperCamelCase_							).write()
												buffer.seek(0							)
												UpperCamelCase__   :List[Any]												= load_json_function(UpperCamelCase_							)
							assert isinstance(UpperCamelCase_    ,   UpperCamelCase_							)
							assert isinstance(exported_content[0]    ,   UpperCamelCase_							)
							assert len(UpperCamelCase_							) == 10




		@pytest.mark.parametrize(
		    '''orient, container, keys, len_at'''    ,   [
		        ('''records''', list, {'''tokens''', '''labels''', '''answers''', '''id'''}, None),
		        ('''split''', dict, {'''columns''', '''data'''}, '''data'''),
		        ('''index''', dict, set('''0123456789'''							), None),
		        ('''columns''', dict, {'''tokens''', '''labels''', '''answers''', '''id'''}, '''tokens'''),
		        ('''values''', list, None, None),
		        ('''table''', dict, {'''schema''', '''data'''}, '''data'''),
		    ]    ,   )
		def     lowerCAmelCase__				(		self    ,   UpperCamelCase_    ,   UpperCamelCase_    ,   UpperCamelCase_    ,   UpperCamelCase_    ,   UpperCamelCase_							):

							'''simple docstring'''


							with io.BytesIO() as buffer:
												JsonDatasetWriter(UpperCamelCase_    ,   UpperCamelCase_    ,   lines=UpperCamelCase_    ,   orient=UpperCamelCase_							).write()
												buffer.seek(0							)
												UpperCamelCase__   :Optional[int]												= load_json(UpperCamelCase_							)
							assert isinstance(UpperCamelCase_    ,   UpperCamelCase_							)
							if keys:
												if container is dict:
																	assert exported_content.keys() == keys
												else:
																	assert exported_content[0].keys() == keys
							else:
												assert not hasattr(UpperCamelCase_    ,   '''keys'''							) and not hasattr(exported_content[0]    ,   '''keys'''							)
							if len_at:
												assert len(exported_content[len_at]							) == 10
							else:
												assert len(UpperCamelCase_							) == 10




		@pytest.mark.parametrize('''lines, load_json_function'''    ,   [(True, load_json_lines), (False, load_json)]							)
		def     lowerCAmelCase__				(		self    ,   UpperCamelCase_    ,   UpperCamelCase_    ,   UpperCamelCase_							):

							'''simple docstring'''


							with io.BytesIO() as buffer:
												JsonDatasetWriter(UpperCamelCase_    ,   UpperCamelCase_    ,   lines=UpperCamelCase_    ,   num_proc=2							).write()
												buffer.seek(0							)
												UpperCamelCase__   :Union[str, Any]												= load_json_function(UpperCamelCase_							)
							assert isinstance(UpperCamelCase_    ,   UpperCamelCase_							)
							assert isinstance(exported_content[0]    ,   UpperCamelCase_							)
							assert len(UpperCamelCase_							) == 10




		@pytest.mark.parametrize(
		    '''orient, container, keys, len_at'''    ,   [
		        ('''records''', list, {'''tokens''', '''labels''', '''answers''', '''id'''}, None),
		        ('''split''', dict, {'''columns''', '''data'''}, '''data'''),
		        ('''index''', dict, set('''0123456789'''							), None),
		        ('''columns''', dict, {'''tokens''', '''labels''', '''answers''', '''id'''}, '''tokens'''),
		        ('''values''', list, None, None),
		        ('''table''', dict, {'''schema''', '''data'''}, '''data'''),
		    ]    ,   )
		def     lowerCAmelCase__				(		self    ,   UpperCamelCase_    ,   UpperCamelCase_    ,   UpperCamelCase_    ,   UpperCamelCase_    ,   UpperCamelCase_							):

							'''simple docstring'''


							with io.BytesIO() as buffer:
												JsonDatasetWriter(UpperCamelCase_    ,   UpperCamelCase_    ,   lines=UpperCamelCase_    ,   orient=UpperCamelCase_    ,   num_proc=2							).write()
												buffer.seek(0							)
												UpperCamelCase__   :int												= load_json(UpperCamelCase_							)
							assert isinstance(UpperCamelCase_    ,   UpperCamelCase_							)
							if keys:
												if container is dict:
																	assert exported_content.keys() == keys
												else:
																	assert exported_content[0].keys() == keys
							else:
												assert not hasattr(UpperCamelCase_    ,   '''keys'''							) and not hasattr(exported_content[0]    ,   '''keys'''							)
							if len_at:
												assert len(exported_content[len_at]							) == 10
							else:
												assert len(UpperCamelCase_							) == 10




		def     lowerCAmelCase__				(		self    ,   UpperCamelCase_							):

							'''simple docstring'''


							with pytest.raises(UpperCamelCase_							):
												with io.BytesIO() as buffer:
																	JsonDatasetWriter(UpperCamelCase_    ,   UpperCamelCase_    ,   num_proc=0							)




		@pytest.mark.parametrize('''compression, extension'''    ,   [('''gzip''', '''gz'''), ('''bz2''', '''bz2'''), ('''xz''', '''xz''')]							)
		def     lowerCAmelCase__				(		self    ,   UpperCamelCase_    ,   UpperCamelCase_    ,   UpperCamelCase_    ,   UpperCamelCase_    ,   UpperCamelCase_							):

							'''simple docstring'''


							UpperCamelCase__   :Tuple												= tmp_path_factory.mktemp('''data'''							) / F'''test.json.{extension}'''
							UpperCamelCase__   :Union[str, Any]												= str(shared_datadir / F'''test_file.json.{extension}'''							)
							JsonDatasetWriter(UpperCamelCase_    ,   UpperCamelCase_    ,   compression=UpperCamelCase_							).write()

							with fsspec.open(UpperCamelCase_    ,   '''rb'''    ,   compression='''infer'''							) as f:
												UpperCamelCase__   :Dict												= f.read()
							with fsspec.open(UpperCamelCase_    ,   '''rb'''    ,   compression='''infer'''							) as f:
												UpperCamelCase__   :int												= f.read()
							assert exported_content == original_content