"""simple docstring"""




import gc
import random
import tempfile
import unittest

import numpy as np
import torch
from PIL import Image
from transformers import CLIPTextConfig, CLIPTextModel, CLIPTokenizer

from diffusers import (
    AutoencoderKL,
    DDIMInverseScheduler,
    DDIMScheduler,
    DPMSolverMultistepInverseScheduler,
    DPMSolverMultistepScheduler,
    StableDiffusionDiffEditPipeline,
    UNetaDConditionModel,
)
from diffusers.utils import load_image, slow
from diffusers.utils.testing_utils import enable_full_determinism, floats_tensor, require_torch_gpu, torch_device

from ..pipeline_params import TEXT_GUIDED_IMAGE_INPAINTING_BATCH_PARAMS, TEXT_GUIDED_IMAGE_INPAINTING_PARAMS
from ..test_pipelines_common import PipelineLatentTesterMixin, PipelineTesterMixin


enable_full_determinism()




class 			_a						(				__lowercase     ,    __lowercase     ,    unittest.TestCase    ):
				UpperCamelCase								=   StableDiffusionDiffEditPipeline
				UpperCamelCase								=   TEXT_GUIDED_IMAGE_INPAINTING_PARAMS - {'''height''', '''width''', '''image'''} | {'''image_latents'''}
				UpperCamelCase								=   TEXT_GUIDED_IMAGE_INPAINTING_BATCH_PARAMS - {'''image'''} | {'''image_latents'''}
				UpperCamelCase								=   frozenset(
				    []    )  # TO-DO: update image_params once pipeline is refactored with VaeImageProcessor.preprocess
				UpperCamelCase								=   frozenset([]    )






				def     snake_case     (			self		:   Tuple							)     ->				Optional[Any]:




										'''simple docstring'''



										torch.manual_seed(0							)
										_UpperCamelCase      : Union[str, Any]         =   UNetaDConditionModel(
										    block_out_channels=(3_2, 6_4),			layers_per_block=2,			sample_size=3_2,			in_channels=4,			out_channels=4,			down_block_types=('''DownBlock2D''', '''CrossAttnDownBlock2D'''),			up_block_types=('''CrossAttnUpBlock2D''', '''UpBlock2D'''),			cross_attention_dim=3_2,			attention_head_dim=(2, 4),			use_linear_projection=_a,			)
										_UpperCamelCase      : Optional[int]         =   DDIMScheduler(
										    beta_start=0.00_085,			beta_end=0.012,			beta_schedule='''scaled_linear''',			clip_sample=_a,			set_alpha_to_one=_a,			)
										_UpperCamelCase      : Optional[Any]         =   DDIMInverseScheduler(
										    beta_start=0.00_085,			beta_end=0.012,			beta_schedule='''scaled_linear''',			clip_sample=_a,			set_alpha_to_zero=_a,			)
										torch.manual_seed(0							)
										_UpperCamelCase      : List[str]         =   AutoencoderKL(
										    block_out_channels=[3_2, 6_4],			in_channels=3,			out_channels=3,			down_block_types=['''DownEncoderBlock2D''', '''DownEncoderBlock2D'''],			up_block_types=['''UpDecoderBlock2D''', '''UpDecoderBlock2D'''],			latent_channels=4,			sample_size=1_2_8,			)
										torch.manual_seed(0							)
										_UpperCamelCase      : List[str]         =   CLIPTextConfig(
										    bos_token_id=0,			eos_token_id=2,			hidden_size=3_2,			intermediate_size=3_7,			layer_norm_eps=1e-0_5,			num_attention_heads=4,			num_hidden_layers=5,			pad_token_id=1,			vocab_size=1_0_0_0,			hidden_act='''gelu''',			projection_dim=5_1_2,			)
										_UpperCamelCase      : int         =   CLIPTextModel(_a							)
										_UpperCamelCase      : Optional[Any]         =   CLIPTokenizer.from_pretrained('''hf-internal-testing/tiny-random-clip'''							)

										_UpperCamelCase      : str         =   {
										    '''unet''': unet,
										    '''scheduler''': scheduler,
										    '''inverse_scheduler''': inverse_scheduler,
										    '''vae''': vae,
										    '''text_encoder''': text_encoder,
										    '''tokenizer''': tokenizer,
										    '''safety_checker''': None,
										    '''feature_extractor''': None,
										}

										return components






				def     snake_case     (			self		:   Union[str, Any],			lowerCAmelCase__		:   Any,			lowerCAmelCase__		:   Dict=0							)     ->				Union[str, Any]:




										'''simple docstring'''



										_UpperCamelCase      : Tuple         =   floats_tensor((1, 1_6, 1_6),			rng=random.Random(_a							)							).to(_a							)
										_UpperCamelCase      : Optional[Any]         =   floats_tensor((1, 2, 4, 1_6, 1_6),			rng=random.Random(_a							)							).to(_a							)
										if str(_a							).startswith('''mps'''							):
																_UpperCamelCase      : str         =   torch.manual_seed(_a							)
										else:
																_UpperCamelCase      : int         =   torch.Generator(device=_a							).manual_seed(_a							)
										_UpperCamelCase      : int         =   {
										    '''prompt''': '''a dog and a newt''',
										    '''mask_image''': mask,
										    '''image_latents''': latents,
										    '''generator''': generator,
										    '''num_inference_steps''': 2,
										    '''inpaint_strength''': 1.0,
										    '''guidance_scale''': 6.0,
										    '''output_type''': '''numpy''',
										}

										return inputs






				def     snake_case     (			self		:   Union[str, Any],			lowerCAmelCase__		:   List[Any],			lowerCAmelCase__		:   List[str]=0							)     ->				Any:




										'''simple docstring'''



										_UpperCamelCase      : Optional[int]         =   floats_tensor((1, 3, 3_2, 3_2),			rng=random.Random(_a							)							).to(_a							)
										_UpperCamelCase      : List[Any]         =   image.cpu().permute(0,			2,			3,			1							)[0]
										_UpperCamelCase      : List[str]         =   Image.fromarray(np.uinta(_a							)							).convert('''RGB'''							)
										if str(_a							).startswith('''mps'''							):
																_UpperCamelCase      : int         =   torch.manual_seed(_a							)
										else:
																_UpperCamelCase      : Union[str, Any]         =   torch.Generator(device=_a							).manual_seed(_a							)
										_UpperCamelCase      : Any         =   {
										    '''image''': image,
										    '''source_prompt''': '''a cat and a frog''',
										    '''target_prompt''': '''a dog and a newt''',
										    '''generator''': generator,
										    '''num_inference_steps''': 2,
										    '''num_maps_per_mask''': 2,
										    '''mask_encode_strength''': 1.0,
										    '''guidance_scale''': 6.0,
										    '''output_type''': '''numpy''',
										}

										return inputs






				def     snake_case     (			self		:   Optional[Any],			lowerCAmelCase__		:   int,			lowerCAmelCase__		:   List[Any]=0							)     ->				Any:




										'''simple docstring'''



										_UpperCamelCase      : Tuple         =   floats_tensor((1, 3, 3_2, 3_2),			rng=random.Random(_a							)							).to(_a							)
										_UpperCamelCase      : int         =   image.cpu().permute(0,			2,			3,			1							)[0]
										_UpperCamelCase      : Tuple         =   Image.fromarray(np.uinta(_a							)							).convert('''RGB'''							)
										if str(_a							).startswith('''mps'''							):
																_UpperCamelCase      : Union[str, Any]         =   torch.manual_seed(_a							)
										else:
																_UpperCamelCase      : Tuple         =   torch.Generator(device=_a							).manual_seed(_a							)
										_UpperCamelCase      : Dict         =   {
										    '''image''': image,
										    '''prompt''': '''a cat and a frog''',
										    '''generator''': generator,
										    '''num_inference_steps''': 2,
										    '''inpaint_strength''': 1.0,
										    '''guidance_scale''': 6.0,
										    '''decode_latents''': True,
										    '''output_type''': '''numpy''',
										}
										return inputs






				def     snake_case     (			self		:   Dict							)     ->				str:




										'''simple docstring'''



										if not hasattr(self.pipeline_class,			'''_optional_components'''							):
																return

										_UpperCamelCase      : Optional[Any]         =   self.get_dummy_components()
										_UpperCamelCase      : Union[str, Any]         =   self.pipeline_class(**_a							)
										pipe.to(_a							)
										pipe.set_progress_bar_config(disable=_a							)

										# set all optional components to None and update pipeline config accordingly
										for optional_component in pipe._optional_components:
																setattr(_a,			_a,			_a							)
										pipe.register_modules(**{optional_component: None for optional_component in pipe._optional_components}							)

										_UpperCamelCase      : List[str]         =   self.get_dummy_inputs(_a							)
										_UpperCamelCase      : List[str]         =   pipe(**_a							)[0]

										with tempfile.TemporaryDirectory() as tmpdir:
																pipe.save_pretrained(_a							)
																_UpperCamelCase      : Tuple         =   self.pipeline_class.from_pretrained(_a							)
																pipe_loaded.to(_a							)
																pipe_loaded.set_progress_bar_config(disable=_a							)

										for optional_component in pipe._optional_components:
																self.assertTrue(
																    getattr(_a,			_a							) is None,			f"""`{optional_component}` did not stay set to None after loading.""",			)

										_UpperCamelCase      : Dict         =   self.get_dummy_inputs(_a							)
										_UpperCamelCase      : str         =   pipe_loaded(**_a							)[0]

										_UpperCamelCase      : Dict         =   np.abs(output - output_loaded							).max()
										self.assertLess(_a,			1e-4							)






				def     snake_case     (			self		:   Any							)     ->				Any:




										'''simple docstring'''



										_UpperCamelCase      : List[str]         =   '''cpu'''

										_UpperCamelCase      : Optional[int]         =   self.get_dummy_components()
										_UpperCamelCase      : str         =   self.pipeline_class(**_a							)
										pipe.to(_a							)
										pipe.set_progress_bar_config(disable=_a							)

										_UpperCamelCase      : Union[str, Any]         =   self.get_dummy_mask_inputs(_a							)
										_UpperCamelCase      : Optional[int]         =   pipe.generate_mask(**_a							)
										_UpperCamelCase      : str         =   mask[0, -3:, -3:]

										self.assertEqual(mask.shape,			(1, 1_6, 1_6)							)
										_UpperCamelCase      : str         =   np.array([0] * 9							)
										_UpperCamelCase      : Union[str, Any]         =   np.abs(mask_slice.flatten() - expected_slice							).max()
										self.assertLessEqual(_a,			1e-3							)
										self.assertEqual(mask[0, -3, -4],			0							)






				def     snake_case     (			self		:   int							)     ->				Union[str, Any]:




										'''simple docstring'''



										_UpperCamelCase      : Optional[Any]         =   '''cpu'''

										_UpperCamelCase      : Tuple         =   self.get_dummy_components()
										_UpperCamelCase      : List[Any]         =   self.pipeline_class(**_a							)
										pipe.to(_a							)
										pipe.set_progress_bar_config(disable=_a							)

										_UpperCamelCase      : str         =   self.get_dummy_inversion_inputs(_a							)
										_UpperCamelCase      : List[Any]         =   pipe.invert(**_a							).images
										_UpperCamelCase      : Optional[int]         =   image[0, -1, -3:, -3:]

										self.assertEqual(image.shape,			(2, 3_2, 3_2, 3)							)
										_UpperCamelCase      : int         =   np.array(
										    [0.5_150, 0.5_134, 0.5_043, 0.5_376, 0.4_694, 0.51_050, 0.5_015, 0.4_407, 0.4_799],			)
										_UpperCamelCase      : int         =   np.abs(image_slice.flatten() - expected_slice							).max()
										self.assertLessEqual(_a,			1e-3							)






				def     snake_case     (			self		:   str							)     ->				List[str]:




										'''simple docstring'''



										super().test_inference_batch_single_identical(expected_max_diff=5e-3							)






				def     snake_case     (			self		:   Optional[Any]							)     ->				Optional[int]:




										'''simple docstring'''



										_UpperCamelCase      : Union[str, Any]         =   '''cpu'''

										_UpperCamelCase      : str         =   self.get_dummy_components()

										_UpperCamelCase      : List[str]         =   {'''beta_start''': 0.00_085, '''beta_end''': 0.012, '''beta_schedule''': '''scaled_linear'''}
										_UpperCamelCase      : Optional[Any]         =   DPMSolverMultistepScheduler(**_a							)
										_UpperCamelCase      : Dict         =   DPMSolverMultistepInverseScheduler(**_a							)

										_UpperCamelCase      : Any         =   self.pipeline_class(**_a							)
										pipe.to(_a							)
										pipe.set_progress_bar_config(disable=_a							)

										_UpperCamelCase      : List[str]         =   self.get_dummy_inversion_inputs(_a							)
										_UpperCamelCase      : Tuple         =   pipe.invert(**_a							).images
										_UpperCamelCase      : List[Any]         =   image[0, -1, -3:, -3:]

										self.assertEqual(image.shape,			(2, 3_2, 3_2, 3)							)
										_UpperCamelCase      : List[str]         =   np.array(
										    [0.5_150, 0.5_134, 0.5_043, 0.5_376, 0.4_694, 0.51_050, 0.5_015, 0.4_407, 0.4_799],			)
										_UpperCamelCase      : int         =   np.abs(image_slice.flatten() - expected_slice							).max()
										self.assertLessEqual(_a,			1e-3							)




@require_torch_gpu
@slow
class 			_a						(				unittest.TestCase    ):






				def     snake_case     (			self		:   Optional[Any]							)     ->				Dict:




										'''simple docstring'''



										super().tearDown()
										gc.collect()
										torch.cuda.empty_cache()






				@classmethod
				def     snake_case     (			cls		:   List[str]							)     ->				Optional[int]:




										'''simple docstring'''



										_UpperCamelCase      : Optional[int]         =   load_image(
										    '''https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main/diffedit/fruit.png'''							)

										_UpperCamelCase      : Optional[Any]         =   raw_image.convert('''RGB'''							).resize((7_6_8, 7_6_8)							)

										_UpperCamelCase      : Tuple         =   raw_image






				def     snake_case     (			self		:   Tuple							)     ->				int:




										'''simple docstring'''



										_UpperCamelCase      : str         =   torch.manual_seed(0							)

										_UpperCamelCase      : Dict         =   StableDiffusionDiffEditPipeline.from_pretrained(
										    '''stabilityai/stable-diffusion-2-1''',			safety_checker=_a,			torch_dtype=torch.floataa							)
										_UpperCamelCase      : Optional[Any]         =   DDIMScheduler.from_config(pipe.scheduler.config							)
										_UpperCamelCase      : List[Any]         =   DDIMInverseScheduler.from_config(pipe.scheduler.config							)
										pipe.enable_model_cpu_offload()
										pipe.set_progress_bar_config(disable=_a							)

										_UpperCamelCase      : List[Any]         =   '''a bowl of fruit'''
										_UpperCamelCase      : Dict         =   '''a bowl of pears'''

										_UpperCamelCase      : Any         =   pipe.generate_mask(
										    image=self.raw_image,			source_prompt=_a,			target_prompt=_a,			generator=_a,			)

										_UpperCamelCase      : List[Any]         =   pipe.invert(
										    prompt=_a,			image=self.raw_image,			inpaint_strength=0.7,			generator=_a							).latents

										_UpperCamelCase      : int         =   pipe(
										    prompt=_a,			mask_image=_a,			image_latents=_a,			generator=_a,			negative_prompt=_a,			inpaint_strength=0.7,			output_type='''numpy''',			).images[0]

										_UpperCamelCase      : Union[str, Any]         =   (
										    np.array(
										        load_image(
										            '''https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main'''
										            '''/diffedit/pears.png'''							).resize((7_6_8, 7_6_8)							)							)
										    / 2_5_5
										)
										assert np.abs((expected_image - image).max()							) < 5e-1






				def     snake_case     (			self		:   List[str]							)     ->				Optional[int]:




										'''simple docstring'''



										_UpperCamelCase      : Any         =   torch.manual_seed(0							)

										_UpperCamelCase      : List[Any]         =   StableDiffusionDiffEditPipeline.from_pretrained(
										    '''stabilityai/stable-diffusion-2-1''',			safety_checker=_a,			torch_dtype=torch.floataa							)
										_UpperCamelCase      : Any         =   DPMSolverMultistepScheduler.from_config(pipe.scheduler.config							)
										_UpperCamelCase      : str         =   DPMSolverMultistepInverseScheduler.from_config(pipe.scheduler.config							)
										pipe.enable_model_cpu_offload()
										pipe.set_progress_bar_config(disable=_a							)

										_UpperCamelCase      : str         =   '''a bowl of fruit'''
										_UpperCamelCase      : Dict         =   '''a bowl of pears'''

										_UpperCamelCase      : Any         =   pipe.generate_mask(
										    image=self.raw_image,			source_prompt=_a,			target_prompt=_a,			generator=_a,			)

										_UpperCamelCase      : Tuple         =   pipe.invert(
										    prompt=_a,			image=self.raw_image,			inpaint_strength=0.7,			generator=_a,			num_inference_steps=2_5,			).latents

										_UpperCamelCase      : Any         =   pipe(
										    prompt=_a,			mask_image=_a,			image_latents=_a,			generator=_a,			negative_prompt=_a,			inpaint_strength=0.7,			num_inference_steps=2_5,			output_type='''numpy''',			).images[0]

										_UpperCamelCase      : Dict         =   (
										    np.array(
										        load_image(
										            '''https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main'''
										            '''/diffedit/pears.png'''							).resize((7_6_8, 7_6_8)							)							)
										    / 2_5_5
										)
										assert np.abs((expected_image - image).max()							) < 5e-1










"""simple docstring"""




import argparse
import json
from typing import List

from ltp import LTP

from transformers.models.bert.tokenization_bert import BertTokenizer





def 	a_    (							_lowercase       ):
						# This defines a "chinese character" as anything in the CJK Unicode block:
						#   https://en.wikipedia.org/wiki/CJK_Unified_Ideographs_(Unicode_block)
						#
						# Note that the CJK Unicode block is NOT all Japanese and Korean characters,
						# despite its name. The modern Korean Hangul alphabet is a different block,
						# as is Japanese Hiragana and Katakana. Those alphabets are used to write
						# space-separated words, so they are not treated specially and handled
						# like the all of the other languages.
						if (
						    (cp >= 0X4E00 and cp <= 0X9FFF)
						    or (cp >= 0X3400 and cp <= 0X4DBF)  #
						    or (cp >= 0X20000 and cp <= 0X2A6DF)  #
						    or (cp >= 0X2A700 and cp <= 0X2B73F)  #
						    or (cp >= 0X2B740 and cp <= 0X2B81F)  #
						    or (cp >= 0X2B820 and cp <= 0X2CEAF)  #
						    or (cp >= 0XF900 and cp <= 0XFAFF)
						    or (cp >= 0X2F800 and cp <= 0X2FA1F)  #
						):  #
												return True

						return False





def 	a_    (							_lowercase       ):
						# word like '180' or '身高' or '神'
						for char in word:
												_UpperCamelCase      : Dict         =   ord(_lowercase       )
												if not _is_chinese_char(_lowercase       ):
																		return 0
						return 1





def 	a_    (							_lowercase       ):
						_UpperCamelCase      : List[str]         =   set()

						for token in tokens:
												_UpperCamelCase      : int         =   len(_lowercase       ) > 1 and is_chinese(_lowercase       )
												if chinese_word:
																		word_set.add(_lowercase       )
						_UpperCamelCase      : Optional[int]         =   list(_lowercase       )
						return word_list





def 	a_    (							_lowercase	,						_lowercase       ):
						if not chinese_word_set:
												return bert_tokens
						_UpperCamelCase      : Tuple         =   max([len(_lowercase       ) for w in chinese_word_set]       )

						_UpperCamelCase      : int         =   bert_tokens
						_UpperCamelCase       ,							_UpperCamelCase      : Union[str, Any]         =   0, len(_lowercase       )
						while start < end:
												_UpperCamelCase      : Union[str, Any]         =   True
												if is_chinese(bert_word[start]       ):
																		_UpperCamelCase      : List[Any]         =   min(end - start	,						_lowercase       )
																		for i in range(_lowercase	,						1	,						-1       ):
																								_UpperCamelCase      : str         =   ''''''.join(bert_word[start : start + i]       )
																								if whole_word in chinese_word_set:
																														for j in range(start + 1	,						start + i       ):
																																				_UpperCamelCase      : int         =   '''##''' + bert_word[j]
																														_UpperCamelCase      : int         =   start + i
																														_UpperCamelCase      : Union[str, Any]         =   False
																														break
												if single_word:
																		start += 1
						return bert_word





def 	a_    (							_lowercase	,						_lowercase	,						_lowercase       ):
						_UpperCamelCase      : List[Any]         =   []

						for i in range(0	,						len(_lowercase       )	,						100       ):
												_UpperCamelCase      : Optional[int]         =   ltp_tokenizer.pipeline(lines[i : i + 100]	,						tasks=['''cws''']       ).cws
												_UpperCamelCase      : Optional[int]         =   [get_chinese_word(_lowercase       ) for r in res]
												ltp_res.extend(_lowercase       )
						assert len(_lowercase       ) == len(_lowercase       )

						_UpperCamelCase      : Dict         =   []
						for i in range(0	,						len(_lowercase       )	,						100       ):
												_UpperCamelCase      : Optional[int]         =   bert_tokenizer(lines[i : i + 100]	,						add_special_tokens=_lowercase	,						truncation=_lowercase	,						max_length=512       )
												bert_res.extend(res['''input_ids''']       )
						assert len(_lowercase       ) == len(_lowercase       )

						_UpperCamelCase      : Optional[Any]         =   []
						for input_ids, chinese_word in zip(_lowercase	,						_lowercase       ):
												_UpperCamelCase      : str         =   []
												for id in input_ids:
																		_UpperCamelCase      : Dict         =   bert_tokenizer._convert_id_to_token(_lowercase       )
																		input_tokens.append(_lowercase       )
												_UpperCamelCase      : str         =   add_sub_symbol(_lowercase	,						_lowercase       )
												_UpperCamelCase      : List[str]         =   []
												# We only save pos of chinese subwords start with ##, which mean is part of a whole word.
												for i, token in enumerate(_lowercase       ):
																		if token[:2] == "##":
																								_UpperCamelCase      : int         =   token[2:]
																								# save chinese tokens' pos
																								if len(_lowercase       ) == 1 and _is_chinese_char(ord(_lowercase       )       ):
																														ref_id.append(_lowercase       )
												ref_ids.append(_lowercase       )

						assert len(_lowercase       ) == len(_lowercase       )

						return ref_ids





def 	a_    (							_lowercase       ):
						# For Chinese (Ro)Bert, the best result is from : RoBERTa-wwm-ext (https://github.com/ymcui/Chinese-BERT-wwm)
						# If we want to fine-tune these model, we have to use same tokenizer : LTP (https://github.com/HIT-SCIR/ltp)
						with open(args.file_name	,						'''r'''	,						encoding='''utf-8'''       ) as f:
												_UpperCamelCase      : Union[str, Any]         =   f.readlines()
						_UpperCamelCase      : Tuple         =   [line.strip() for line in data if len(_lowercase       ) > 0 and not line.isspace()]  # avoid delimiter like '\u2029'
						_UpperCamelCase      : List[Any]         =   LTP(args.ltp       )  # faster in GPU device
						_UpperCamelCase      : int         =   BertTokenizer.from_pretrained(args.bert       )

						_UpperCamelCase      : List[str]         =   prepare_ref(_lowercase	,						_lowercase	,						_lowercase       )

						with open(args.save_path	,						'''w'''	,						encoding='''utf-8'''       ) as f:
												_UpperCamelCase      : List[Any]         =   [json.dumps(_lowercase       ) + '''\n''' for ref in ref_ids]
												f.writelines(_lowercase       )


if __name__ == "__main__":
						UpperCamelCase_									=argparse.ArgumentParser(description="""prepare_chinese_ref""")
						parser.add_argument(
						    """--file_name""",
						    required=False,
						    type=str,
						    default="""./resources/chinese-demo.txt""",
						    help="""file need process, same as training data in lm""",
						)
						parser.add_argument(
						    """--ltp""",
						    required=False,
						    type=str,
						    default="""./resources/ltp""",
						    help="""resources for LTP tokenizer, usually a path""",
						)
						parser.add_argument(
						    """--bert""",
						    required=False,
						    type=str,
						    default="""./resources/robert""",
						    help="""resources for Bert tokenizer""",
						)
						parser.add_argument(
						    """--save_path""",
						    required=False,
						    type=str,
						    default="""./resources/ref.txt""",
						    help="""path to save res""",
						)

						UpperCamelCase_									=parser.parse_args()
						main(args)



