

'''simple docstring'''






import argparse
import os
import re

import packaging.version


lowerCAmelCase__											=	'''examples/'''
lowerCAmelCase__											=	{
    '''examples''': (re.compile(R'''^check_min_version\("[^"]+"\)\s*$''', re.MULTILINE), '''check_min_version("VERSION")\n'''),
    '''init''': (re.compile(R'''^__version__\s+=\s+"([^"]+)"\s*$''', re.MULTILINE), '''__version__ = "VERSION"\n'''),
    '''setup''': (re.compile(R'''^(\s*)version\s*=\s*"[^"]+",''', re.MULTILINE), R'''\1version="VERSION",'''),
    '''doc''': (re.compile(R'''^(\s*)release\s*=\s*"[^"]+"$''', re.MULTILINE), '''release = "VERSION"\n'''),
}
lowerCAmelCase__											=	{
    '''init''': '''src/transformers/__init__.py''',
    '''setup''': '''setup.py''',
}
lowerCAmelCase__											=	'''README.md'''


def 		_A     (    A__     ,				A__     ,				A__      ):






 """simple docstring"""



 with open(A__     ,				'''r'''     ,				encoding='''utf-8'''     ,				newline='''\n'''      ) as f:
  __lowercase							  = f.read()
 __lowercase  ,	__lowercase							  = REPLACE_PATTERNS[pattern]
 __lowercase							  = replace.replace('''VERSION'''     ,				A__      )
 __lowercase							  = re_pattern.sub(A__     ,				A__      )
 with open(A__     ,				'''w'''     ,				encoding='''utf-8'''     ,				newline='''\n'''      ) as f:
  f.write(A__      )


def 		_A     (    A__      ):






 """simple docstring"""



 for folder, directories, fnames in os.walk(A__      ):
  # Removing some of the folders with non-actively maintained examples from the walk
  if "research_projects" in directories:
   directories.remove('''research_projects'''      )
  if "legacy" in directories:
   directories.remove('''legacy'''      )
  for fname in fnames:
   if fname.endswith('''.py'''      ):
    update_version_in_file(os.path.join(A__     ,				A__      )     ,				A__     ,				pattern='''examples'''      )


def 		_A     (    A__     ,				A__=False      ):






 """simple docstring"""



 for pattern, fname in REPLACE_FILES.items():
  update_version_in_file(A__     ,				A__     ,				A__      )
 if not patch:
  update_version_in_examples(A__      )


def 		_A     (    ):






 """simple docstring"""



 __lowercase							  = '''🤗 Transformers currently provides the following architectures'''
 __lowercase							  = '''1. Want to contribute a new model?'''
 with open(A__     ,				'''r'''     ,				encoding='''utf-8'''     ,				newline='''\n'''      ) as f:
  __lowercase							  = f.readlines()

 # Find the start of the list.
 __lowercase							  = 0
 while not lines[start_index].startswith(_start_prompt      ):
  start_index += 1
 start_index += 1

 __lowercase							  = start_index
 # Update the lines in the model list.
 while not lines[index].startswith(_end_prompt      ):
  if lines[index].startswith('''1.'''      ):
   __lowercase							  = lines[index].replace(
       '''https://huggingface.co/docs/transformers/main/model_doc'''     ,				'''https://huggingface.co/docs/transformers/model_doc'''     ,				)
  index += 1

 with open(A__     ,				'''w'''     ,				encoding='''utf-8'''     ,				newline='''\n'''      ) as f:
  f.writelines(A__      )


def 		_A     (    ):






 """simple docstring"""



 with open(REPLACE_FILES['''init''']     ,				'''r'''      ) as f:
  __lowercase							  = f.read()
 __lowercase							  = REPLACE_PATTERNS['''init'''][0].search(A__      ).groups()[0]
 return packaging.version.parse(A__      )


def 		_A     (    A__=False      ):






 """simple docstring"""



 __lowercase							  = get_version()
 if patch and default_version.is_devrelease:
  raise ValueError('''Can\'t create a patch version from the dev branch, checkout a released version!'''      )
 if default_version.is_devrelease:
  __lowercase							  = default_version.base_version
 elif patch:
  __lowercase							  = F"{default_version.major}.{default_version.minor}.{default_version.micro + 1}"
 else:
  __lowercase							  = F"{default_version.major}.{default_version.minor + 1}.0"

 # Now let's ask nicely if that's the right one.
 __lowercase							  = input(F"Which version are you releasing? [{default_version}]"      )
 if len(A__      ) == 0:
  __lowercase							  = default_version

 print(F"Updating version to {version}."      )
 global_version_update(A__     ,				patch=A__      )
 if not patch:
  print('''Cleaning main README, don\'t forget to run `make fix-copies`.'''      )
  clean_main_ref_in_model_list()


def 		_A     (    ):






 """simple docstring"""



 __lowercase							  = get_version()
 __lowercase							  = F"{current_version.major}.{current_version.minor + 1}.0.dev0"
 __lowercase							  = current_version.base_version

 # Check with the user we got that right.
 __lowercase							  = input(F"Which version are we developing now? [{dev_version}]"      )
 if len(A__      ) == 0:
  __lowercase							  = dev_version

 print(F"Updating version to {version}."      )
 global_version_update(A__      )
 print('''Cleaning main README, don\'t forget to run `make fix-copies`.'''      )
 clean_main_ref_in_model_list()


if __name__ == "__main__":
 lowerCAmelCase__											=	argparse.ArgumentParser()
 parser.add_argument('''--post_release''', action='''store_true''', help='''Whether this is pre or post release.''')
 parser.add_argument('''--patch''', action='''store_true''', help='''Whether or not this is a patch release.''')
 lowerCAmelCase__											=	parser.parse_args()
 if not args.post_release:
  pre_release_work(patch=args.patch)
 elif args.patch:
  print('''Nothing to do after a patch :-)''')
 else:
  post_release_work()



from typing import List, Optional, TypeVar

from .arrow_dataset import Dataset, _concatenate_map_style_datasets, _interleave_map_style_datasets
from .dataset_dict import DatasetDict, IterableDatasetDict
from .info import DatasetInfo
from .iterable_dataset import IterableDataset, _concatenate_iterable_datasets, _interleave_iterable_datasets
from .splits import NamedSplit
from .utils import logging
from .utils.py_utils import Literal


__snake_case								=  logging.get_logger(__name__)


__snake_case								=  TypeVar("""DatasetType""", Dataset, IterableDataset)






def 							_lowercase							(     UpperCamelCase_	,	UpperCamelCase_ = None	,	UpperCamelCase_ = None	,	UpperCamelCase_ = None	,	UpperCamelCase_ = None	,	UpperCamelCase_ = "first_exhausted"	,	)		->		DatasetType:
					'''simple docstring'''


					from .arrow_dataset import Dataset
					from .iterable_dataset import IterableDataset

					if not datasets:
										raise ValueError('Unable to interleave an empty list of datasets.'		)
					for i, dataset in enumerate(UpperCamelCase_		):
										if not isinstance(UpperCamelCase_	,	(Dataset, IterableDataset)		):
															if isinstance(UpperCamelCase_	,	(DatasetDict, IterableDatasetDict)		):
																				if not dataset:
																									raise ValueError(
																									    F'Expected a list of Dataset objects or a list of IterableDataset objects, but element at position {i} '
																									    'is an empty dataset dictionary.'		)
																				raise ValueError(
																				    F'Dataset at position {i} has at least one split: {list(UpperCamelCase_		)}\n'
																				    F'Please pick one to interleave with the other datasets, for example: dataset[\'{next(iter(UpperCamelCase_		)		)}\']'		)
															raise ValueError(
															    F'Expected a list of Dataset objects or a list of IterableDataset objects, but element at position {i} is a {type(UpperCamelCase_		).__name__}.'		)
										if i == 0:
															SCREAMING_SNAKE_CASE__						, SCREAMING_SNAKE_CASE__													= (
															    (Dataset, IterableDataset) if isinstance(UpperCamelCase_	,	UpperCamelCase_		) else (IterableDataset, Dataset)
															)
										elif not isinstance(UpperCamelCase_	,	UpperCamelCase_		):
															raise ValueError(
															    F'Unable to interleave a {dataset_type.__name__} (at position 0) with a {other_type.__name__} (at position {i}). Expected a list of Dataset objects or a list of IterableDataset objects.'		)
					if stopping_strategy not in ["first_exhausted", "all_exhausted"]:
										raise ValueError(F'{stopping_strategy} is not supported. Please enter a valid stopping_strategy.'		)
					if dataset_type is Dataset:
										return _interleave_map_style_datasets(
										    UpperCamelCase_	,	UpperCamelCase_	,	UpperCamelCase_	,	info=UpperCamelCase_	,	split=UpperCamelCase_	,	stopping_strategy=UpperCamelCase_		)
					else:
										return _interleave_iterable_datasets(
										    UpperCamelCase_	,	UpperCamelCase_	,	UpperCamelCase_	,	info=UpperCamelCase_	,	split=UpperCamelCase_	,	stopping_strategy=UpperCamelCase_		)






def 							_lowercase							(     UpperCamelCase_	,	UpperCamelCase_ = None	,	UpperCamelCase_ = None	,	UpperCamelCase_ = 0	,	)		->		DatasetType:
					'''simple docstring'''


					if not dsets:
										raise ValueError('Unable to concatenate an empty list of datasets.'		)
					for i, dataset in enumerate(UpperCamelCase_		):
										if not isinstance(UpperCamelCase_	,	(Dataset, IterableDataset)		):
															if isinstance(UpperCamelCase_	,	(DatasetDict, IterableDatasetDict)		):
																				if not dataset:
																									raise ValueError(
																									    F'Expected a list of Dataset objects or a list of IterableDataset objects, but element at position {i} '
																									    'is an empty dataset dictionary.'		)
																				raise ValueError(
																				    F'Dataset at position {i} has at least one split: {list(UpperCamelCase_		)}\n'
																				    F'Please pick one to interleave with the other datasets, for example: dataset[\'{next(iter(UpperCamelCase_		)		)}\']'		)
															raise ValueError(
															    F'Expected a list of Dataset objects or a list of IterableDataset objects, but element at position {i} is a {type(UpperCamelCase_		).__name__}.'		)
										if i == 0:
															SCREAMING_SNAKE_CASE__						, SCREAMING_SNAKE_CASE__													= (
															    (Dataset, IterableDataset) if isinstance(UpperCamelCase_	,	UpperCamelCase_		) else (IterableDataset, Dataset)
															)
										elif not isinstance(UpperCamelCase_	,	UpperCamelCase_		):
															raise ValueError(
															    F'Unable to interleave a {dataset_type.__name__} (at position 0) with a {other_type.__name__} (at position {i}). Expected a list of Dataset objects or a list of IterableDataset objects.'		)
					if dataset_type is Dataset:
										return _concatenate_map_style_datasets(UpperCamelCase_	,	info=UpperCamelCase_	,	split=UpperCamelCase_	,	axis=UpperCamelCase_		)
					else:
										return _concatenate_iterable_datasets(UpperCamelCase_	,	info=UpperCamelCase_	,	split=UpperCamelCase_	,	axis=UpperCamelCase_		)





