"""simple docstring"""






import importlib.util
import weakref
from functools import partialmethod

from .dependency_versions_check import dep_version_check
from .utils import is_accelerate_available, is_torch_available, logging


if is_torch_available():
						import torch

lowerCAmelCase__  :  str											=     logging.get_logger(__name__)



def   a_						( ):
				return importlib.util.find_spec('deepspeed'	) is not None


if is_accelerate_available() and is_deepspeed_available():
						from accelerate.utils.deepspeed import HfDeepSpeedConfig as DeepSpeedConfig
else:
						# Inherits from a dummy `object` if accelerate is not available, so that python succeeds to import this file.
						# Deepspeed glue code will never inherit this dummy object as it checks if accelerate is available.
						from builtins import object as DeepSpeedConfig
class     snake_case	(			__UpperCAmelCase    ):




					"""simple docstring"""

					def __init__(    self       :     Optional[Any]   ,lowerCamelCase__       :     int      ):
									# set global weakref object
									set_hf_deepspeed_config(self      )
									dep_version_check('accelerate'      )
									dep_version_check('deepspeed'      )
									super().__init__(lowerCamelCase__      )






class     snake_case	(			__UpperCAmelCase    ):




					"""simple docstring"""

					def __init__(    self       :     Dict   ,lowerCamelCase__       :     List[str]      ):
									super().__init__(lowerCamelCase__      )
									UpperCAmelCase__					=							None
									UpperCAmelCase__					=							[]







					def 		__lowerCAmelCase						(    self       :     List[str]      ):
									if self._dtype is None:
													raise ValueError('trainer_config_process() wasn\'t called yet to tell dtype'      )
									return self._dtype







					def 		__lowerCAmelCase						(    self       :     Union[str, Any]   ,lowerCamelCase__       :     Dict      ):
									UpperCAmelCase__					=							self.get_value(lowerCamelCase__      )
									if val is None:
													return False
									else:
													return val == "auto"







					def 		__lowerCAmelCase						(    self       :     Optional[Any]   ,lowerCamelCase__       :     Optional[Any]   ,lowerCamelCase__       :     List[Any]   ,lowerCamelCase__       :     Tuple=None   ,lowerCamelCase__       :     Any=True      ):
									UpperCAmelCase__				,     UpperCAmelCase__					=							self.find_config_node(lowerCamelCase__      )
									if config is None:
													return

									if config.get(lowerCamelCase__      ) == "auto":
													UpperCAmelCase__					=							hf_val
													return

									if not must_match:
													return

									UpperCAmelCase__					=							config.get(lowerCamelCase__      )
									if ds_val is not None and ds_val != hf_val:
													self.mismatches.append(f'''- ds {ds_key_long}={ds_val} vs hf {hf_key}={hf_val}'''      )

					snake_case__       =			partialmethod(__UpperCAmelCase				,   must_match=__UpperCAmelCase    )







					def 		__lowerCAmelCase						(    self       :     Any   ,lowerCamelCase__       :     Union[str, Any]      ):
									UpperCAmelCase__					=							args.world_size * args.per_device_train_batch_size * args.gradient_accumulation_steps
									self.fill_match(
									    'train_micro_batch_size_per_gpu'   ,args.per_device_train_batch_size   ,'per_device_train_batch_size'      )
									self.fill_match('gradient_accumulation_steps'   ,args.gradient_accumulation_steps   ,'gradient_accumulation_steps'      )
									self.fill_match('train_batch_size'   ,lowerCamelCase__   ,'train_batch_size (calculated)'      )
									self.fill_match('gradient_clipping'   ,args.max_grad_norm   ,'max_grad_norm'      )

									self.fill_match('optimizer.params.lr'   ,args.learning_rate   ,'learning_rate'      )
									self.fill_match('optimizer.params.betas'   ,[args.adam_betaa, args.adam_betaa]   ,'adam_beta1+adam_beta2'      )
									self.fill_match('optimizer.params.eps'   ,args.adam_epsilon   ,'adam_epsilon'      )
									self.fill_match('optimizer.params.weight_decay'   ,args.weight_decay   ,'weight_decay'      )

									self.fill_only('scheduler.params.warmup_min_lr'   ,0      )  # not a trainer arg
									self.fill_match('scheduler.params.warmup_max_lr'   ,args.learning_rate   ,'learning_rate'      )
									# total_num_steps - will get set in trainer_config_finalize

									# fp16
									if args.fpaa or args.fpaa_full_eval:
													UpperCAmelCase__					=							'apex' if args.fpaa_backend == 'apex' else 'amp'
									else:
													UpperCAmelCase__					=							None

									if args.save_on_each_node:
													# deepspeed uses shared storage by default. Let's override this setting if save_on_each_node == True
													UpperCAmelCase__					=							self.config.get('checkpoint'   ,{}      )
													UpperCAmelCase__					=							args.save_on_each_node

									# amp: similar to the pytorch native amp - it has a bunch of optional params but we won't set
									# any here unless the user did the work
									self.fill_match(
									    'fp16.enabled'   ,((args.fpaa or args.fpaa_full_eval) and fpaa_backend == 'amp')   ,'fp16|fp16_full_eval+fp16_backend(amp)'   ,)

									# apex: delegates amp work to apex (which needs to be available), but it cannot be used with any
									# ZeRO features
									self.fill_match('amp.enabled'   ,fpaa_backend == 'apex'   ,'fp16+fp16_backend(apex)'      )
									self.fill_match('amp.opt_level'   ,args.fpaa_opt_level   ,'fp16_opt_level'      )

									self.fill_match('bf16.enabled'   ,(args.bfaa or args.bfaa_full_eval)   ,'bf16|bf16_full_eval'      )

									# deepspeed's default mode is fp16 unless there is a config that says differently
									if self.is_true('bf16.enabled'      ):
													UpperCAmelCase__					=							torch.bfloataa
									elif self.is_false('fp16.enabled'      ):
													UpperCAmelCase__					=							torch.floataa
									else:
													UpperCAmelCase__					=							torch.floataa







					def 		__lowerCAmelCase						(    self       :     Any   ,lowerCamelCase__       :     Optional[Any]   ,lowerCamelCase__       :     Optional[int]   ,lowerCamelCase__       :     List[Any]      ):
									UpperCAmelCase__					=							[
									    'zero_optimization.reduce_bucket_size',
									    'zero_optimization.stage3_prefetch_bucket_size',
									    'zero_optimization.stage3_param_persistence_threshold',
									]
									UpperCAmelCase__					=							[x for x in hidden_size_based_keys if self.is_auto(lowerCamelCase__      )]

									if len(lowerCamelCase__      ) > 0:
													if hasattr(model.config   ,'hidden_size'      ):
																	UpperCAmelCase__					=							model.config.hidden_size
													elif hasattr(model.config   ,'hidden_sizes'      ):
																	# if there are many hidden sizes pick the largest one
																	UpperCAmelCase__					=							max(model.config.hidden_sizes      )
													else:
																	raise ValueError(
																	    'The model\'s config file has neither `hidden_size` nor `hidden_sizes` entry, '
																	    'therefore it\'s not possible to automatically fill out the following `auto` entries '
																	    f'''in the DeepSpeed config file: {hidden_size_auto_keys}. You can fix that by replacing '''
																	    '`auto` values for these keys with an integer value of your choice.'      )

													self.fill_only('zero_optimization.reduce_bucket_size'   ,hidden_size * hidden_size      )
													if self.is_zeroa():
																	# automatically assign the optimal config values based on model config
																	self.fill_only('zero_optimization.stage3_prefetch_bucket_size'   ,0.9 * hidden_size * hidden_size      )
																	self.fill_only('zero_optimization.stage3_param_persistence_threshold'   ,10 * hidden_size      )

        # scheduler
									self.fill_match('scheduler.params.total_num_steps'   ,lowerCamelCase__   ,'num_training_steps (calculated)'      )
									self.fill_match('scheduler.params.warmup_num_steps'   ,args.get_warmup_steps(lowerCamelCase__      )   ,'warmup_steps'      )

									if len(self.mismatches      ) > 0:
													UpperCAmelCase__					=							'\n'.join(self.mismatches      )
													raise ValueError(
													    'Please correct the following DeepSpeed config values that mismatch TrainingArguments'
													    f''' values:\n{mismatches}\nThe easiest method is to set these DeepSpeed config values to \'auto\'.'''      )






lowerCAmelCase__  :  List[str]											=     None



def   a_						( lowerCamelCase	):
				# this is a special weakref global object to allow us to get to Deepspeed config from APIs
				# that don't have an easy way to get to the Deepspeed config outside of the Trainer domain.
				global _hf_deepspeed_config_weak_ref
				# will go away automatically when HfDeepSpeedConfig is destroyed (when TrainingArguments is destroyed)
				UpperCAmelCase__					=							weakref.ref(lowerCamelCase	)



def   a_						( ):
				# useful for unit tests to ensure the global state doesn't leak - call from `tearDown` method
				global _hf_deepspeed_config_weak_ref
				UpperCAmelCase__					=							None



def   a_						( ):
				if _hf_deepspeed_config_weak_ref is not None and _hf_deepspeed_config_weak_ref() is not None:
								return _hf_deepspeed_config_weak_ref().is_zeroa()
				else:
								return False



def   a_						( ):
				if _hf_deepspeed_config_weak_ref is not None and _hf_deepspeed_config_weak_ref() is not None:
								return _hf_deepspeed_config_weak_ref().config
				else:
								return None



def   a_						( lowerCamelCase ,      lowerCamelCase ,      lowerCamelCase ,      lowerCamelCase ,      lowerCamelCase	):
				from accelerate.utils import DummyOptim, DummyScheduler

				UpperCAmelCase__					=							hf_deepspeed_config.config

				# Optimizer + Scheduler
				# Currently supported combos:
				# 1. DS scheduler + DS optimizer: Yes
				# 2. HF scheduler + HF optimizer: Yes
				# 3. DS scheduler + HF optimizer: Yes
				# 4. HF scheduler + DS optimizer: No
				#
				# Unless Offload is enabled in which case it's:
				# 1. DS scheduler + DS optimizer: Yes
				# 2. HF scheduler + HF optimizer: Mostly*
				# 3. DS scheduler + HF optimizer: Mostly*
				# 4. HF scheduler + DS optimizer: No
				#
				# Mostly*: All non-native DeepSpeed optimizers that have both CPU and GPU implementation should work (except LAMB)

				UpperCAmelCase__					=							None
				if "optimizer" in config:
								if args.adafactor:
												raise ValueError(
												    '--adafactor was passed, but also found `optimizer` configured in the DeepSpeed config. '
												    'Only one optimizer can be configured.'	)
								UpperCAmelCase__					=							DummyOptim(params=lowerCamelCase	)
				else:
								if hf_deepspeed_config.is_offload():
												logger.info(
												    'Detected ZeRO Offload and non-DeepSpeed optimizers: This combination should work as long as the'
												    ' custom optimizer has both CPU and GPU implementation (except LAMB)'	)

								# ds supports Adam, OneBitAdam, and Lamb optimizers and can import other optimizers from torch.
								# But trainer uses AdamW by default.
								UpperCAmelCase__					=							trainer.create_optimizer()
								# To use other optimizers requires voiding warranty with: `zero_allow_untested_optimizer`
								UpperCAmelCase__					=							True

				UpperCAmelCase__					=							None
				if "scheduler" in config:
								UpperCAmelCase__					=							DummyScheduler(lowerCamelCase	)
				else:
								if isinstance(lowerCamelCase ,      lowerCamelCase	):
												raise ValueError(
												    'Found `optimizer` configured in the DeepSpeed config, but no `scheduler`. '
												    'Please configure a scheduler in the DeepSpeed config.'	)
								UpperCAmelCase__					=							trainer.create_scheduler(num_training_steps=lowerCamelCase ,      optimizer=lowerCamelCase	)

				return optimizer, lr_scheduler



def   a_						( lowerCamelCase ,      lowerCamelCase ,      lowerCamelCase=False	):
				from deepspeed.utils import logger as ds_logger

				UpperCAmelCase__					=							trainer.model
				UpperCAmelCase__					=							trainer.args

				UpperCAmelCase__					=							trainer.accelerator.state.deepspeed_plugin.hf_ds_config

				# resume config update - some bits like `model` and `num_training_steps` only become available during train
				hf_deepspeed_config.trainer_config_finalize(lowerCamelCase ,      lowerCamelCase ,      lowerCamelCase	)

				# set the Deepspeed log level consistent with the Trainer
				ds_logger.setLevel(args.get_process_log_level()	)

				if inference:
								# only Z3 makes sense for the inference
								if not hf_deepspeed_config.is_zeroa():
												raise ValueError('ZeRO inference only makes sense with ZeRO Stage 3 - please adjust your config'	)

								# in case the training config is re-used for inference
								hf_deepspeed_config.del_config_sub_tree('optimizer'	)
								hf_deepspeed_config.del_config_sub_tree('lr_scheduler'	)
								UpperCAmelCase__				,     UpperCAmelCase__					=							None, None
								UpperCAmelCase__					=							None
				else:
								UpperCAmelCase__					=							None  # important for when deepspeed_init is used as re-init
								UpperCAmelCase__					=							list(filter(lambda lowerCamelCase	: p.requires_grad ,      model.parameters()	)	)
								UpperCAmelCase__				,     UpperCAmelCase__					=							deepspeed_optim_sched(
								    lowerCamelCase ,      lowerCamelCase ,      lowerCamelCase ,      lowerCamelCase ,      lowerCamelCase	)

				# keep for quick debug:
				# from pprint import pprint; pprint(config)

				return optimizer, lr_scheduler







def   a_						( lowerCamelCase ,      lowerCamelCase	):
				# it's possible that the user is trying to resume from model_path, which doesn't necessarily
				# contain a deepspeed checkpoint. e.g. examples just check if the dir exists and assume it's
				# a resume from a checkpoint and not just a local pretrained weight. So we check here if the
				# path contains what looks like a deepspeed checkpoint
				import glob

				UpperCAmelCase__					=							sorted(glob.glob(f'''{checkpoint_path}/global_step*'''	)	)

				if len(lowerCamelCase	) > 0:
								logger.info(f'''Attempting to resume from {checkpoint_path}'''	)
								# this magically updates self.optimizer and self.lr_scheduler
								UpperCAmelCase__				,     UpperCAmelCase__					=							deepspeed_engine.load_checkpoint(
								    lowerCamelCase ,      load_optimizer_states=lowerCamelCase ,      load_lr_scheduler_states=lowerCamelCase	)
								if load_path is None:
												raise ValueError(f'''[deepspeed] failed to resume from checkpoint {checkpoint_path}'''	)
				else:
								raise ValueError(f'''Can\'t find a valid checkpoint at {checkpoint_path}'''	)




"""simple docstring"""






import argparse
import os
import sys
import urllib.request
import zipfile


lowerCAmelCase__  :  Optional[Any]											=     ['CoLA', 'SST', 'MRPC', 'QQP', 'STS', 'MNLI', 'SNLI', 'QNLI', 'RTE', 'WNLI', 'diagnostic']
lowerCAmelCase__  :  Optional[Any]											=     {
    'CoLA': 'https://firebasestorage.googleapis.com/v0/b/mtl-sentence-representations.appspot.com/o/data%2FCoLA.zip?alt=media&token=46d5e637-3411-4188-bc44-5809b5bfb5f4',
    'SST': 'https://firebasestorage.googleapis.com/v0/b/mtl-sentence-representations.appspot.com/o/data%2FSST-2.zip?alt=media&token=aabc5f6b-e466-44a2-b9b4-cf6337f84ac8',
    'MRPC': 'https://firebasestorage.googleapis.com/v0/b/mtl-sentence-representations.appspot.com/o/data%2Fmrpc_dev_ids.tsv?alt=media&token=ec5c0836-31d5-48f4-b431-7480817f1adc',
    'QQP': 'https://firebasestorage.googleapis.com/v0/b/mtl-sentence-representations.appspot.com/o/data%2FQQP.zip?alt=media&token=700c6acf-160d-4d89-81d1-de4191d02cb5',
    'STS': 'https://firebasestorage.googleapis.com/v0/b/mtl-sentence-representations.appspot.com/o/data%2FSTS-B.zip?alt=media&token=bddb94a7-8706-4e0d-a694-1109e12273b5',
    'MNLI': 'https://firebasestorage.googleapis.com/v0/b/mtl-sentence-representations.appspot.com/o/data%2FMNLI.zip?alt=media&token=50329ea1-e339-40e2-809c-10c40afff3ce',
    'SNLI': 'https://firebasestorage.googleapis.com/v0/b/mtl-sentence-representations.appspot.com/o/data%2FSNLI.zip?alt=media&token=4afcfbb2-ff0c-4b2d-a09a-dbf07926f4df',
    'QNLI': 'https://firebasestorage.googleapis.com/v0/b/mtl-sentence-representations.appspot.com/o/data%2FQNLIv2.zip?alt=media&token=6fdcf570-0fc5-4631-8456-9505272d1601',
    'RTE': 'https://firebasestorage.googleapis.com/v0/b/mtl-sentence-representations.appspot.com/o/data%2FRTE.zip?alt=media&token=5efa7e85-a0bb-4f19-8ea2-9e1840f077fb',
    'WNLI': 'https://firebasestorage.googleapis.com/v0/b/mtl-sentence-representations.appspot.com/o/data%2FWNLI.zip?alt=media&token=068ad0a0-ded7-4bd7-99a5-5e00222e0faf',
    'diagnostic': 'https://storage.googleapis.com/mtl-sentence-representations.appspot.com/tsvsWithoutLabels%2FAX.tsv?GoogleAccessId=firebase-adminsdk-0khhl@mtl-sentence-representations.iam.gserviceaccount.com&Expires=2498860800&Signature=DuQ2CSPt2Yfre0C%2BiISrVYrIFaZH1Lc7hBVZDD4ZyR7fZYOMNOUGpi8QxBmTNOrNPjR3z1cggo7WXFfrgECP6FBJSsURv8Ybrue8Ypt%2FTPxbuJ0Xc2FhDi%2BarnecCBFO77RSbfuz%2Bs95hRrYhTnByqu3U%2FYZPaj3tZt5QdfpH2IUROY8LiBXoXS46LE%2FgOQc%2FKN%2BA9SoscRDYsnxHfG0IjXGwHN%2Bf88q6hOmAxeNPx6moDulUF6XMUAaXCSFU%2BnRO2RDL9CapWxj%2BDl7syNyHhB7987hZ80B%2FwFkQ3MEs8auvt5XW1%2Bd4aCU7ytgM69r8JDCwibfhZxpaa4gd50QXQ%3D%3D',
}

lowerCAmelCase__  :  Dict											=     'https://dl.fbaipublicfiles.com/senteval/senteval_data/msr_paraphrase_train.txt'
lowerCAmelCase__  :  List[str]											=     'https://dl.fbaipublicfiles.com/senteval/senteval_data/msr_paraphrase_test.txt'



def   a_						( lowerCamelCase ,      lowerCamelCase	):
				print(f'''Downloading and extracting {task}...'''	)
				UpperCAmelCase__					=							f'''{task}.zip'''
				urllib.request.urlretrieve(TASKaPATH[task] ,      lowerCamelCase	)
				with zipfile.ZipFile(lowerCamelCase	) as zip_ref:
								zip_ref.extractall(lowerCamelCase	)
				os.remove(lowerCamelCase	)
				print('\tCompleted!'	)



def   a_						( lowerCamelCase ,      lowerCamelCase	):
				print('Processing MRPC...'	)
				UpperCAmelCase__					=							os.path.join(lowerCamelCase ,      'MRPC'	)
				if not os.path.isdir(lowerCamelCase	):
								os.mkdir(lowerCamelCase	)
				if path_to_data:
								UpperCAmelCase__					=							os.path.join(lowerCamelCase ,      'msr_paraphrase_train.txt'	)
								UpperCAmelCase__					=							os.path.join(lowerCamelCase ,      'msr_paraphrase_test.txt'	)
				else:
								print('Local MRPC data not specified, downloading data from %s' % MRPC_TRAIN	)
								UpperCAmelCase__					=							os.path.join(lowerCamelCase ,      'msr_paraphrase_train.txt'	)
								UpperCAmelCase__					=							os.path.join(lowerCamelCase ,      'msr_paraphrase_test.txt'	)
								urllib.request.urlretrieve(lowerCamelCase ,      lowerCamelCase	)
								urllib.request.urlretrieve(lowerCamelCase ,      lowerCamelCase	)
				if not os.path.isfile(lowerCamelCase	):
								raise ValueError(f'''Train data not found at {mrpc_train_file}'''	)
				if not os.path.isfile(lowerCamelCase	):
								raise ValueError(f'''Test data not found at {mrpc_test_file}'''	)
				urllib.request.urlretrieve(TASKaPATH['MRPC'] ,      os.path.join(lowerCamelCase ,      'dev_ids.tsv'	)	)

				UpperCAmelCase__					=							[]
				with open(os.path.join(lowerCamelCase ,      'dev_ids.tsv'	) ,      encoding='utf8'	) as ids_fh:
								for row in ids_fh:
												dev_ids.append(row.strip().split('\t'	)	)

				with open(lowerCamelCase ,      encoding='utf8'	) as data_fh, open(
				    os.path.join(lowerCamelCase ,      'train.tsv'	) ,      'w' ,      encoding='utf8'	) as train_fh, open(os.path.join(lowerCamelCase ,      'dev.tsv'	) ,      'w' ,      encoding='utf8'	) as dev_fh:
								UpperCAmelCase__					=							data_fh.readline()
								train_fh.write(lowerCamelCase	)
								dev_fh.write(lowerCamelCase	)
								for row in data_fh:
												UpperCAmelCase__				,     UpperCAmelCase__				,     UpperCAmelCase__				,     UpperCAmelCase__				,     UpperCAmelCase__					=							row.strip().split('\t'	)
												if [ida, ida] in dev_ids:
																dev_fh.write('%s\t%s\t%s\t%s\t%s\n' % (label, ida, ida, sa, sa)	)
												else:
																train_fh.write('%s\t%s\t%s\t%s\t%s\n' % (label, ida, ida, sa, sa)	)

				with open(lowerCamelCase ,      encoding='utf8'	) as data_fh, open(
				    os.path.join(lowerCamelCase ,      'test.tsv'	) ,      'w' ,      encoding='utf8'	) as test_fh:
								UpperCAmelCase__					=							data_fh.readline()
								test_fh.write('index\t#1 ID\t#2 ID\t#1 String\t#2 String\n'	)
								for idx, row in enumerate(lowerCamelCase	):
												UpperCAmelCase__				,     UpperCAmelCase__				,     UpperCAmelCase__				,     UpperCAmelCase__				,     UpperCAmelCase__					=							row.strip().split('\t'	)
												test_fh.write('%d\t%s\t%s\t%s\t%s\n' % (idx, ida, ida, sa, sa)	)
				print('\tCompleted!'	)



def   a_						( lowerCamelCase	):
				print('Downloading and extracting diagnostic...'	)
				if not os.path.isdir(os.path.join(lowerCamelCase ,      'diagnostic'	)	):
								os.mkdir(os.path.join(lowerCamelCase ,      'diagnostic'	)	)
				UpperCAmelCase__					=							os.path.join(lowerCamelCase ,      'diagnostic' ,      'diagnostic.tsv'	)
				urllib.request.urlretrieve(TASKaPATH['diagnostic'] ,      lowerCamelCase	)
				print('\tCompleted!'	)
				return



def   a_						( lowerCamelCase	):
				UpperCAmelCase__					=							task_names.split(','	)
				if "all" in task_names:
								UpperCAmelCase__					=							TASKS
				else:
								UpperCAmelCase__					=							[]
								for task_name in task_names:
												if task_name not in TASKS:
																raise ValueError(f'''Task {task_name} not found!'''	)
												tasks.append(lowerCamelCase	)
				return tasks



def   a_						( lowerCamelCase	):
				UpperCAmelCase__					=							argparse.ArgumentParser()
				parser.add_argument('--data_dir' ,      help='directory to save data to' ,      type=lowerCamelCase ,      default='glue_data'	)
				parser.add_argument(
				    '--tasks' ,      help='tasks to download data for as a comma separated string' ,      type=lowerCamelCase ,      default='all'	)
				parser.add_argument(
				    '--path_to_mrpc' ,      help='path to directory containing extracted MRPC data, msr_paraphrase_train.txt and msr_paraphrase_text.txt' ,      type=lowerCamelCase ,      default='' ,      )
				UpperCAmelCase__					=							parser.parse_args(lowerCamelCase	)

				if not os.path.isdir(args.data_dir	):
								os.mkdir(args.data_dir	)
				UpperCAmelCase__					=							get_tasks(args.tasks	)

				for task in tasks:
								if task == "MRPC":
												format_mrpc(args.data_dir ,      args.path_to_mrpc	)
								elif task == "diagnostic":
												download_diagnostic(args.data_dir	)
								else:
												download_and_extract(lowerCamelCase ,      args.data_dir	)


if __name__ == "__main__":
						sys.exit(main(sys.argv[1:]))



