





import importlib
import inspect
from functools import wraps
from typing import TYPE_CHECKING, Optional, Union

from .download.streaming_download_manager import (
    xbasename,
    xdirname,
    xet_parse,
    xexists,
    xgetsize,
    xglob,
    xgzip_open,
    xisdir,
    xisfile,
    xjoin,
    xlistdir,
    xnumpy_load,
    xopen,
    xpandas_read_csv,
    xpandas_read_excel,
    xPath,
    xrelpath,
    xsio_loadmat,
    xsplit,
    xsplitext,
    xwalk,
    xxml_dom_minidom_parse,
)
from .utils.logging import get_logger
from .utils.patching import patch_submodule
from .utils.py_utils import get_imports


__A    :   Any          =       get_logger(__name__)


if TYPE_CHECKING:
				from .builder import DatasetBuilder





def 						__SCREAMING_SNAKE_CASE  (    UpperCamelCase__      ,      UpperCamelCase__ = None			)  ->    Any:







			'''simple docstring'''

			UpperCAmelCase       		=    importlib.import_module(UpperCamelCase__			)

			# TODO(QL): always update the module to add subsequent new authentication
			if hasattr(UpperCamelCase__      ,      '''_patched_for_streaming'''			) and module._patched_for_streaming:
						return

			def wrap_auth(UpperCamelCase__			):
						@wraps(UpperCamelCase__			)
						def wrapper(*UpperCamelCase__      ,      **UpperCamelCase__			):
									return function(*UpperCamelCase__      ,      use_auth_token=UpperCamelCase__      ,      **UpperCamelCase__			)

						UpperCAmelCase       		=    '''wrap_auth'''
						return wrapper

			# open files in a streaming fashion
			patch_submodule(UpperCamelCase__      ,      '''open'''      ,      wrap_auth(UpperCamelCase__			)			).start()
			patch_submodule(UpperCamelCase__      ,      '''os.listdir'''      ,      wrap_auth(UpperCamelCase__			)			).start()
			patch_submodule(UpperCamelCase__      ,      '''os.walk'''      ,      wrap_auth(UpperCamelCase__			)			).start()
			patch_submodule(UpperCamelCase__      ,      '''glob.glob'''      ,      wrap_auth(UpperCamelCase__			)			).start()
			# allow to navigate in remote zip files
			patch_submodule(UpperCamelCase__      ,      '''os.path.join'''      ,      UpperCamelCase__			).start()
			patch_submodule(UpperCamelCase__      ,      '''os.path.dirname'''      ,      UpperCamelCase__			).start()
			patch_submodule(UpperCamelCase__      ,      '''os.path.basename'''      ,      UpperCamelCase__			).start()
			patch_submodule(UpperCamelCase__      ,      '''os.path.relpath'''      ,      UpperCamelCase__			).start()
			patch_submodule(UpperCamelCase__      ,      '''os.path.split'''      ,      UpperCamelCase__			).start()
			patch_submodule(UpperCamelCase__      ,      '''os.path.splitext'''      ,      UpperCamelCase__			).start()
			# allow checks on paths
			patch_submodule(UpperCamelCase__      ,      '''os.path.exists'''      ,      wrap_auth(UpperCamelCase__			)			).start()
			patch_submodule(UpperCamelCase__      ,      '''os.path.isdir'''      ,      wrap_auth(UpperCamelCase__			)			).start()
			patch_submodule(UpperCamelCase__      ,      '''os.path.isfile'''      ,      wrap_auth(UpperCamelCase__			)			).start()
			patch_submodule(UpperCamelCase__      ,      '''os.path.getsize'''      ,      wrap_auth(UpperCamelCase__			)			).start()
			patch_submodule(UpperCamelCase__      ,      '''pathlib.Path'''      ,      UpperCamelCase__			).start()
			# file readers
			patch_submodule(UpperCamelCase__      ,      '''gzip.open'''      ,      wrap_auth(UpperCamelCase__			)			).start()
			patch_submodule(UpperCamelCase__      ,      '''numpy.load'''      ,      wrap_auth(UpperCamelCase__			)			).start()
			patch_submodule(UpperCamelCase__      ,      '''pandas.read_csv'''      ,      wrap_auth(UpperCamelCase__			)      ,      attrs=['''__version__''']			).start()
			patch_submodule(UpperCamelCase__      ,      '''pandas.read_excel'''      ,      wrap_auth(UpperCamelCase__			)      ,      attrs=['''__version__''']			).start()
			patch_submodule(UpperCamelCase__      ,      '''scipy.io.loadmat'''      ,      wrap_auth(UpperCamelCase__			)      ,      attrs=['''__version__''']			).start()
			patch_submodule(UpperCamelCase__      ,      '''xml.etree.ElementTree.parse'''      ,      wrap_auth(UpperCamelCase__			)			).start()
			patch_submodule(UpperCamelCase__      ,      '''xml.dom.minidom.parse'''      ,      wrap_auth(UpperCamelCase__			)			).start()
			UpperCAmelCase       		=    True






def 						__SCREAMING_SNAKE_CASE  (    UpperCamelCase__			)  ->    List[str]:







			'''simple docstring'''

			extend_module_for_streaming(builder.__module__      ,      use_auth_token=builder.use_auth_token			)
			# if needed, we also have to extend additional internal imports (like wmt14 -> wmt_utils)
			if not builder.__module__.startswith('''datasets.'''			):  # check that it's not a packaged builder like csv
						for imports in get_imports(inspect.getfile(builder.__class__			)			):
									if imports[0] == "internal":
												UpperCAmelCase       		=    imports[1]
												UpperCAmelCase       		=    '''.'''.join(builder.__module__.split('''.'''			)[:-1] + [internal_import_name]			)
												extend_module_for_streaming(UpperCamelCase__      ,      use_auth_token=builder.use_auth_token			)

    # builders can inherit from other builders that might use streaming functionality
    # (for example, ImageFolder and AudioFolder inherit from FolderBuilder which implements examples generation)
    # but these parents builders are not patched automatically as they are not instantiated, so we patch them here
			from .builder import DatasetBuilder

			UpperCAmelCase       		=    [
			    cls.__module__
			    for cls in type(UpperCamelCase__			).__mro__[1:]  # make sure it's not the same module we've already patched
			    if issubclass(cls      ,      UpperCamelCase__			) and cls.__module__ != DatasetBuilder.__module__
			]  # check it's not a standard builder from datasets.builder
			for module in parent_builder_modules:
						extend_module_for_streaming(UpperCamelCase__      ,      use_auth_token=builder.use_auth_token			)










import json
import os
import tempfile
import unittest

from transformers.modelcard import ModelCard

class      A_	(unittest.TestCase      ):
	def 					_lowercase    (   self		):






				'''simple docstring'''







				UpperCAmelCase       		=    {
				    '''model_details''': {
				        '''Organization''': '''testing''',
				        '''Model date''': '''today''',
				        '''Model version''': '''v2.1, Developed by Test Corp in 2019.''',
				        '''Architecture''': '''Convolutional Neural Network.''',
				    },
				    '''metrics''': '''BLEU and ROUGE-1''',
				    '''evaluation_data''': {
				        '''Datasets''': {'''BLEU''': '''My-great-dataset-v1''', '''ROUGE-1''': '''My-short-dataset-v2.1'''},
				        '''Preprocessing''': '''See details on https://arxiv.org/pdf/1810.03993.pdf''',
				    },
				    '''training_data''': {
				        '''Dataset''': '''English Wikipedia dump dated 2018-12-01''',
				        '''Preprocessing''': (
				            '''Using SentencePiece vocabulary of size 52k tokens. See details on'''
				            ''' https://arxiv.org/pdf/1810.03993.pdf'''
				        ),
				    },
				    '''quantitative_analyses''': {'''BLEU''': 55.1, '''ROUGE-1''': 7_6},
				}
	def 					_lowercase    (   self		):






				'''simple docstring'''







				UpperCAmelCase       		=    ModelCard.from_dict(self.inputs_dict		)
				self.assertTrue(hasattr(_A							, '''model_details'''		)		)
				self.assertTrue(hasattr(_A							, '''intended_use'''		)		)
				self.assertTrue(hasattr(_A							, '''factors'''		)		)
				self.assertTrue(hasattr(_A							, '''metrics'''		)		)
				self.assertTrue(hasattr(_A							, '''evaluation_data'''		)		)
				self.assertTrue(hasattr(_A							, '''training_data'''		)		)
				self.assertTrue(hasattr(_A							, '''quantitative_analyses'''		)		)
				self.assertTrue(hasattr(_A							, '''ethical_considerations'''		)		)
				self.assertTrue(hasattr(_A							, '''caveats_and_recommendations'''		)		)
	def 					_lowercase    (   self		):






				'''simple docstring'''







				UpperCAmelCase       		=    ModelCard.from_dict(self.inputs_dict		)
				UpperCAmelCase       		=    json.loads(modelcard.to_json_string()		)
				for key, value in self.inputs_dict.items():
							self.assertEqual(obj[key]							, _A		)
	def 					_lowercase    (   self		):






				'''simple docstring'''







				UpperCAmelCase       		=    ModelCard.from_dict(self.inputs_dict		)

				with tempfile.TemporaryDirectory() as tmpdirname:
							UpperCAmelCase       		=    os.path.join(_A							, '''modelcard.json'''		)
							model_card_first.to_json_file(_A		)
							UpperCAmelCase       		=    ModelCard.from_json_file(_A		)

				self.assertEqual(model_card_second.to_dict()							, model_card_first.to_dict()		)







	def 					_lowercase    (   self		):






				'''simple docstring'''







				UpperCAmelCase       		=    ModelCard.from_dict(self.inputs_dict		)

				with tempfile.TemporaryDirectory() as tmpdirname:
							model_card_first.save_pretrained(_A		)
							UpperCAmelCase       		=    ModelCard.from_pretrained(_A		)

				self.assertEqual(model_card_second.to_dict()							, model_card_first.to_dict()		)



