import gc
import random
import unittest

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

from diffusers import (
    AutoencoderKL,
    DDIMScheduler,
    EulerAncestralDiscreteScheduler,
    LMSDiscreteScheduler,
    PNDMScheduler,
    StableDiffusionInstructPixaPixPipeline,
    UNetaDConditionModel,
)
from diffusers.image_processor import VaeImageProcessor
from diffusers.utils import floats_tensor, load_image, slow, torch_device
from diffusers.utils.testing_utils import enable_full_determinism, require_torch_gpu

from ..pipeline_params import (
    IMAGE_TO_IMAGE_IMAGE_PARAMS,
    TEXT_GUIDED_IMAGE_INPAINTING_BATCH_PARAMS,
    TEXT_GUIDED_IMAGE_VARIATION_PARAMS,
)
from ..test_pipelines_common import PipelineKarrasSchedulerTesterMixin, PipelineLatentTesterMixin, PipelineTesterMixin


enable_full_determinism()




class  __magic_name__  (		__a      ,	__a      ,	__a      ,	unittest.TestCase    ):





   """simple docstring"""




   lowerCAmelCase      :    List[Any]  			=   StableDiffusionInstructPixaPixPipeline
   lowerCAmelCase      :    Union[str, Any]  			=   TEXT_GUIDED_IMAGE_VARIATION_PARAMS - {'''height''', '''width''', '''cross_attention_kwargs'''}
   lowerCAmelCase      :    Any  			=   TEXT_GUIDED_IMAGE_INPAINTING_BATCH_PARAMS
   lowerCAmelCase      :    Union[str, Any]  			=   IMAGE_TO_IMAGE_IMAGE_PARAMS
   lowerCAmelCase      :    Tuple  			=   IMAGE_TO_IMAGE_IMAGE_PARAMS



   def   lowerCAmelCase						(	self					:  Optional[Any]							):



    """simple docstring"""



    torch.manual_seed(0							)
    _UpperCamelCase:     List[str]							= UNetaDConditionModel(
        block_out_channels=(32, 64)		,  layers_per_block=2		,  sample_size=32		,  in_channels=8		,  out_channels=4		,  down_block_types=('''DownBlock2D''', '''CrossAttnDownBlock2D''')		,  up_block_types=('''CrossAttnUpBlock2D''', '''UpBlock2D''')		,  cross_attention_dim=32		,  )
    _UpperCamelCase:     str							= PNDMScheduler(skip_prk_steps=_lowercase							)
    torch.manual_seed(0							)
    _UpperCamelCase:     int							= AutoencoderKL(
        block_out_channels=[32, 64]		,  in_channels=3		,  out_channels=3		,  down_block_types=['''DownEncoderBlock2D''', '''DownEncoderBlock2D''']		,  up_block_types=['''UpDecoderBlock2D''', '''UpDecoderBlock2D''']		,  latent_channels=4		,  )
    torch.manual_seed(0							)
    _UpperCamelCase:     str							= CLIPTextConfig(
        bos_token_id=0		,  eos_token_id=2		,  hidden_size=32		,  intermediate_size=37		,  layer_norm_eps=1E-05		,  num_attention_heads=4		,  num_hidden_layers=5		,  pad_token_id=1		,  vocab_size=1_000		,  )
    _UpperCamelCase:     List[Any]							= CLIPTextModel(_lowercase							)
    _UpperCamelCase:     Union[str, Any]							= CLIPTokenizer.from_pretrained('''hf-internal-testing/tiny-random-clip'''							)

    _UpperCamelCase:     List[Any]							= {
        '''unet''': unet,
        '''scheduler''': scheduler,
        '''vae''': vae,
        '''text_encoder''': text_encoder,
        '''tokenizer''': tokenizer,
        '''safety_checker''': None,
        '''feature_extractor''': None,
    }
    return components



   def   lowerCAmelCase						(	self					:  str		,  _lowercase					:  int		,  _lowercase					:  Union[str, Any]=0							):



    """simple docstring"""



    _UpperCamelCase:     Dict							= floats_tensor((1, 3, 32, 32)		,  rng=random.Random(_lowercase							)							).to(_lowercase							)
    _UpperCamelCase:     Union[str, Any]							= image.cpu().permute(0		,  2		,  3		,  1							)[0]
    _UpperCamelCase:     Union[str, Any]							= Image.fromarray(np.uinta(_lowercase							)							).convert('''RGB'''							)
    if str(_lowercase							).startswith('''mps'''							):
     _UpperCamelCase:     List[Any]							= torch.manual_seed(_lowercase							)
    else:
     _UpperCamelCase:     List[Any]							= torch.Generator(device=_lowercase							).manual_seed(_lowercase							)
    _UpperCamelCase:     Optional[Any]							= {
        '''prompt''': '''A painting of a squirrel eating a burger''',
        '''image''': image,
        '''generator''': generator,
        '''num_inference_steps''': 2,
        '''guidance_scale''': 6.0,
        '''image_guidance_scale''': 1,
        '''output_type''': '''numpy''',
    }
    return inputs



   def   lowerCAmelCase						(	self					:  List[Any]							):



    """simple docstring"""



    _UpperCamelCase:     Dict							= '''cpu'''  # ensure determinism for the device-dependent torch.Generator
    _UpperCamelCase:     Dict							= self.get_dummy_components()
    _UpperCamelCase:     Optional[Any]							= StableDiffusionInstructPixaPixPipeline(**_lowercase							)
    _UpperCamelCase:     Optional[Any]							= sd_pipe.to(_lowercase							)
    sd_pipe.set_progress_bar_config(disable=_lowercase							)

    _UpperCamelCase:     int							= self.get_dummy_inputs(_lowercase							)
    _UpperCamelCase:     Optional[int]							= sd_pipe(**_lowercase							).images
    _UpperCamelCase:     Union[str, Any]							= image[0, -3:, -3:, -1]
    assert image.shape == (1, 32, 32, 3)
    _UpperCamelCase:     Optional[Any]							= np.array([0.7526, 0.3750, 0.4547, 0.6117, 0.5866, 0.5016, 0.4327, 0.5642, 0.4815]							)

    assert np.abs(image_slice.flatten() - expected_slice							).max() < 1E-3



   def   lowerCAmelCase						(	self					:  List[Any]							):



    """simple docstring"""



    _UpperCamelCase:     Tuple							= '''cpu'''  # ensure determinism for the device-dependent torch.Generator
    _UpperCamelCase:     int							= self.get_dummy_components()
    _UpperCamelCase:     List[str]							= StableDiffusionInstructPixaPixPipeline(**_lowercase							)
    _UpperCamelCase:     Union[str, Any]							= sd_pipe.to(_lowercase							)
    sd_pipe.set_progress_bar_config(disable=_lowercase							)

    _UpperCamelCase:     Union[str, Any]							= self.get_dummy_inputs(_lowercase							)
    _UpperCamelCase:     Dict							= '''french fries'''
    _UpperCamelCase:     List[str]							= sd_pipe(**_lowercase		,  negative_prompt=_lowercase							)
    _UpperCamelCase:     int							= output.images
    _UpperCamelCase:     Optional[Any]							= image[0, -3:, -3:, -1]

    assert image.shape == (1, 32, 32, 3)
    _UpperCamelCase:     Any							= np.array([0.7511, 0.3642, 0.4553, 0.6236, 0.5797, 0.5013, 0.4343, 0.5611, 0.4831]							)

    assert np.abs(image_slice.flatten() - expected_slice							).max() < 1E-3



   def   lowerCAmelCase						(	self					:  str							):



    """simple docstring"""



    _UpperCamelCase:     Any							= '''cpu'''  # ensure determinism for the device-dependent torch.Generator
    _UpperCamelCase:     Optional[int]							= self.get_dummy_components()
    _UpperCamelCase:     Union[str, Any]							= StableDiffusionInstructPixaPixPipeline(**_lowercase							)
    _UpperCamelCase:     Dict							= sd_pipe.to(_lowercase							)
    sd_pipe.set_progress_bar_config(disable=_lowercase							)

    _UpperCamelCase:     int							= self.get_dummy_inputs(_lowercase							)
    _UpperCamelCase:     Union[str, Any]							= [inputs['''prompt''']] * 2

    _UpperCamelCase:     Any							= np.array(inputs['''image''']							).astype(np.floataa							) / 255.0
    _UpperCamelCase:     Tuple							= torch.from_numpy(_lowercase							).unsqueeze(0							).to(_lowercase							)
    _UpperCamelCase:     List[str]							= image / 2 + 0.5
    _UpperCamelCase:     List[str]							= image.permute(0		,  3		,  1		,  2							)
    _UpperCamelCase:     Optional[int]							= image.repeat(2		,  1		,  1		,  1							)

    _UpperCamelCase:     Dict							= sd_pipe(**_lowercase							).images
    _UpperCamelCase:     int							= image[-1, -3:, -3:, -1]

    assert image.shape == (2, 32, 32, 3)
    _UpperCamelCase:     Tuple							= np.array([0.5812, 0.5748, 0.5222, 0.5908, 0.5695, 0.7174, 0.6804, 0.5523, 0.5579]							)

    assert np.abs(image_slice.flatten() - expected_slice							).max() < 1E-3



   def   lowerCAmelCase						(	self					:  List[str]							):



    """simple docstring"""



    _UpperCamelCase:     str							= '''cpu'''  # ensure determinism for the device-dependent torch.Generator
    _UpperCamelCase:     int							= self.get_dummy_components()
    _UpperCamelCase:     List[Any]							= EulerAncestralDiscreteScheduler(
        beta_start=0.00085		,  beta_end=0.012		,  beta_schedule='''scaled_linear'''							)
    _UpperCamelCase:     Dict							= StableDiffusionInstructPixaPixPipeline(**_lowercase							)
    _UpperCamelCase:     str							= sd_pipe.to(_lowercase							)
    sd_pipe.set_progress_bar_config(disable=_lowercase							)

    _UpperCamelCase:     int							= self.get_dummy_inputs(_lowercase							)
    _UpperCamelCase:     Dict							= sd_pipe(**_lowercase							).images
    _UpperCamelCase:     Dict							= image[0, -3:, -3:, -1]

    _UpperCamelCase:     Tuple							= [round(_lowercase		,  4							) for x in image_slice.flatten().tolist()]
    print(''','''.join([str(_lowercase							) for x in slice]							)							)

    assert image.shape == (1, 32, 32, 3)
    _UpperCamelCase:     Dict							= np.array([0.7417, 0.3842, 0.4732, 0.5776, 0.5891, 0.5139, 0.4052, 0.5673, 0.4986]							)

    assert np.abs(image_slice.flatten() - expected_slice							).max() < 1E-3



   def   lowerCAmelCase						(	self					:  Any							):



    """simple docstring"""



    super().test_inference_batch_single_identical(expected_max_diff=3E-3							)



   def   lowerCAmelCase						(	self					:  Optional[int]							):



    """simple docstring"""



    _UpperCamelCase:     List[Any]							= self.get_dummy_components()
    _UpperCamelCase:     List[str]							= StableDiffusionInstructPixaPixPipeline(**_lowercase							)
    _UpperCamelCase:     Tuple							= VaeImageProcessor(do_resize=_lowercase		,  do_normalize=_lowercase							)
    _UpperCamelCase:     List[str]							= pipe.to(_lowercase							)
    pipe.set_progress_bar_config(disable=_lowercase							)

    _UpperCamelCase:     str							= pipe(**self.get_dummy_inputs_by_type(_lowercase		,  input_image_type='''pt'''							)							)[0]

    _UpperCamelCase:     str							= components['''vae''']
    _UpperCamelCase:     List[str]							= self.get_dummy_inputs_by_type(_lowercase		,  input_image_type='''pt'''							)

    for image_param in self.image_latents_params:
     if image_param in inputs.keys():
      _UpperCamelCase:     Tuple							= vae.encode(inputs[image_param]							).latent_dist.mode()

    _UpperCamelCase:     Optional[Any]							= pipe(**_lowercase							)[0]

    _UpperCamelCase:     Tuple							= np.abs(out - out_latents_inputs							).max()
    self.assertLess(_lowercase		,  1E-4		,  '''passing latents as image input generate different result from passing image'''							)




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





   """simple docstring"""




   def   lowerCAmelCase						(	self					:  Optional[Any]							):



    """simple docstring"""



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



   def   lowerCAmelCase						(	self					:  Tuple		,  _lowercase					:  Dict=0							):



    """simple docstring"""



    _UpperCamelCase:     Dict							= torch.manual_seed(_lowercase							)
    _UpperCamelCase:     Tuple							= load_image(
        '''https://huggingface.co/datasets/diffusers/test-arrays/resolve/main/stable_diffusion_pix2pix/example.jpg'''							)
    _UpperCamelCase:     Tuple							= {
        '''prompt''': '''turn him into a cyborg''',
        '''image''': image,
        '''generator''': generator,
        '''num_inference_steps''': 3,
        '''guidance_scale''': 7.5,
        '''image_guidance_scale''': 1.0,
        '''output_type''': '''numpy''',
    }
    return inputs



   def   lowerCAmelCase						(	self					:  Dict							):



    """simple docstring"""



    _UpperCamelCase:     Optional[Any]							= StableDiffusionInstructPixaPixPipeline.from_pretrained(
        '''timbrooks/instruct-pix2pix'''		,  safety_checker=_lowercase							)
    pipe.to(_lowercase							)
    pipe.set_progress_bar_config(disable=_lowercase							)
    pipe.enable_attention_slicing()

    _UpperCamelCase:     Optional[int]							= self.get_inputs()
    _UpperCamelCase:     Union[str, Any]							= pipe(**_lowercase							).images
    _UpperCamelCase:     Dict							= image[0, -3:, -3:, -1].flatten()

    assert image.shape == (1, 512, 512, 3)
    _UpperCamelCase:     Union[str, Any]							= np.array([0.5902, 0.6015, 0.6027, 0.5983, 0.6092, 0.6061, 0.5765, 0.5785, 0.5555]							)

    assert np.abs(expected_slice - image_slice							).max() < 1E-3



   def   lowerCAmelCase						(	self					:  Optional[int]							):



    """simple docstring"""



    _UpperCamelCase:     List[Any]							= StableDiffusionInstructPixaPixPipeline.from_pretrained(
        '''timbrooks/instruct-pix2pix'''		,  safety_checker=_lowercase							)
    _UpperCamelCase:     int							= LMSDiscreteScheduler.from_config(pipe.scheduler.config							)
    pipe.to(_lowercase							)
    pipe.set_progress_bar_config(disable=_lowercase							)
    pipe.enable_attention_slicing()

    _UpperCamelCase:     List[Any]							= self.get_inputs()
    _UpperCamelCase:     Optional[Any]							= pipe(**_lowercase							).images
    _UpperCamelCase:     int							= image[0, -3:, -3:, -1].flatten()

    assert image.shape == (1, 512, 512, 3)
    _UpperCamelCase:     Union[str, Any]							= np.array([0.6578, 0.6817, 0.6972, 0.6761, 0.6856, 0.6916, 0.6428, 0.6516, 0.6301]							)

    assert np.abs(expected_slice - image_slice							).max() < 1E-3



   def   lowerCAmelCase						(	self					:  Tuple							):



    """simple docstring"""



    _UpperCamelCase:     int							= StableDiffusionInstructPixaPixPipeline.from_pretrained(
        '''timbrooks/instruct-pix2pix'''		,  safety_checker=_lowercase							)
    _UpperCamelCase:     List[str]							= DDIMScheduler.from_config(pipe.scheduler.config							)
    pipe.to(_lowercase							)
    pipe.set_progress_bar_config(disable=_lowercase							)
    pipe.enable_attention_slicing()

    _UpperCamelCase:     Optional[Any]							= self.get_inputs()
    _UpperCamelCase:     Tuple							= pipe(**_lowercase							).images
    _UpperCamelCase:     List[Any]							= image[0, -3:, -3:, -1].flatten()

    assert image.shape == (1, 512, 512, 3)
    _UpperCamelCase:     Optional[Any]							= np.array([0.3828, 0.3834, 0.3818, 0.3792, 0.3865, 0.3752, 0.3792, 0.3847, 0.3753]							)

    assert np.abs(expected_slice - image_slice							).max() < 1E-3



   def   lowerCAmelCase						(	self					:  Dict							):



    """simple docstring"""



    _UpperCamelCase:     Dict							= 0

    def callback_fn(_lowercase					:  int		,  _lowercase					:  int		,  _lowercase					:  torch.FloatTensor							) -> None:
     _UpperCamelCase:     int							= True
     nonlocal number_of_steps
     number_of_steps += 1
     if step == 1:
      _UpperCamelCase:     Any							= latents.detach().cpu().numpy()
      assert latents.shape == (1, 4, 64, 64)
      _UpperCamelCase:     Union[str, Any]							= latents[0, -3:, -3:, -1]
      _UpperCamelCase:     Dict							= np.array([-0.2463, -0.4644, -0.9756, 1.5176, 1.4414, 0.7866, 0.9897, 0.8521, 0.7983]							)

      assert np.abs(latents_slice.flatten() - expected_slice							).max() < 5E-2
     elif step == 2:
      _UpperCamelCase:     Optional[int]							= latents.detach().cpu().numpy()
      assert latents.shape == (1, 4, 64, 64)
      _UpperCamelCase:     Optional[Any]							= latents[0, -3:, -3:, -1]
      _UpperCamelCase:     Union[str, Any]							= np.array([-0.2644, -0.4626, -0.9653, 1.5176, 1.4551, 0.7686, 0.9805, 0.8452, 0.8115]							)

      assert np.abs(latents_slice.flatten() - expected_slice							).max() < 5E-2

    _UpperCamelCase:     Any							= False

    _UpperCamelCase:     List[Any]							= StableDiffusionInstructPixaPixPipeline.from_pretrained(
        '''timbrooks/instruct-pix2pix'''		,  safety_checker=_lowercase		,  torch_dtype=torch.floataa							)
    _UpperCamelCase:     int							= pipe.to(_lowercase							)
    pipe.set_progress_bar_config(disable=_lowercase							)
    pipe.enable_attention_slicing()

    _UpperCamelCase:     Dict							= self.get_inputs()
    pipe(**_lowercase		,  callback=_lowercase		,  callback_steps=1							)
    assert callback_fn.has_been_called
    assert number_of_steps == 3



   def   lowerCAmelCase						(	self					:  Optional[Any]							):



    """simple docstring"""



    torch.cuda.empty_cache()
    torch.cuda.reset_max_memory_allocated()
    torch.cuda.reset_peak_memory_stats()

    _UpperCamelCase:     Any							= StableDiffusionInstructPixaPixPipeline.from_pretrained(
        '''timbrooks/instruct-pix2pix'''		,  safety_checker=_lowercase		,  torch_dtype=torch.floataa							)
    _UpperCamelCase:     List[str]							= pipe.to(_lowercase							)
    pipe.set_progress_bar_config(disable=_lowercase							)
    pipe.enable_attention_slicing(1							)
    pipe.enable_sequential_cpu_offload()

    _UpperCamelCase:     str							= self.get_inputs()
    _UpperCamelCase:     Optional[Any]							= pipe(**_lowercase							)

    _UpperCamelCase:     Tuple							= torch.cuda.max_memory_allocated()
    # make sure that less than 2.2 GB is allocated
    assert mem_bytes < 2.2 * 10**9



   def   lowerCAmelCase						(	self					:  Dict							):



    """simple docstring"""



    _UpperCamelCase:     List[Any]							= self.get_inputs()
    # resize to resolution that is divisible by 8 but not 16 or 32
    _UpperCamelCase:     Optional[int]							= inputs['''image'''].resize((504, 504)							)

    _UpperCamelCase:     Union[str, Any]							= '''timbrooks/instruct-pix2pix'''
    _UpperCamelCase:     List[str]							= StableDiffusionInstructPixaPixPipeline.from_pretrained(
        _lowercase		,  safety_checker=_lowercase		,  )
    pipe.to(_lowercase							)
    pipe.set_progress_bar_config(disable=_lowercase							)
    pipe.enable_attention_slicing()

    _UpperCamelCase:     Optional[Any]							= pipe(**_lowercase							)
    _UpperCamelCase:     Union[str, Any]							= output.images[0]

    _UpperCamelCase:     List[str]							= image[255:258, 383:386, -1]

    assert image.shape == (504, 504, 3)
    _UpperCamelCase:     Optional[int]							= np.array([0.2726, 0.2529, 0.2664, 0.2655, 0.2641, 0.2642, 0.2591, 0.2649, 0.2590]							)

    assert np.abs(image_slice.flatten() - expected_slice							).max() < 5E-3
# Copyright 2021 The HuggingFace Team. All rights reserved.
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
#     http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.

import argparse

from ...utils.dataclasses import (
    ComputeEnvironment,
    DistributedType,
    DynamoBackend,
    PrecisionType,
    SageMakerDistributedType,
)
from ..menu import BulletMenu


UpperCAmelCase_			    =							[
    '''EAGER''',
    '''AOT_EAGER''',
    '''INDUCTOR''',
    '''NVFUSER''',
    '''AOT_NVFUSER''',
    '''AOT_CUDAGRAPHS''',
    '''OFI''',
    '''FX2TRT''',
    '''ONNXRT''',
    '''IPEX''',
]




def       lowerCAmelCase_     (		lowercase:							str  ,					lowercase:							Optional[Any]=None  ,					lowercase:							List[str]=None  ,					lowercase:							List[str]=None		)    ->				Tuple:







 '''simple docstring'''
 _UpperCamelCase:     int							= True
 while ask_again:
  _UpperCamelCase:     Any							= input(lowercase		)
  try:
   if default is not None and len(lowercase		) == 0:
    return default
   return convert_value(lowercase		) if convert_value is not None else result
  except Exception:
   if error_message is not None:
    print(lowercase		)




def       lowerCAmelCase_     (		lowercase:							List[Any]  ,					lowercase:							Union[str, Any]=[]  ,					lowercase:							Union[str, Any]=None  ,					lowercase:							Union[str, Any]=0		)    ->				List[Any]:







 '''simple docstring'''
 _UpperCamelCase:     List[str]							= BulletMenu(lowercase  ,					lowercase		)
 _UpperCamelCase:     List[Any]							= menu.run(default_choice=lowercase		)
 return convert_value(lowercase		) if convert_value is not None else result




def       lowerCAmelCase_     (		lowercase:							Dict		)    ->				Optional[int]:







 '''simple docstring'''
 _UpperCamelCase:     int							= int(lowercase		)
 return ComputeEnvironment(['''LOCAL_MACHINE''', '''AMAZON_SAGEMAKER'''][value]		)




def       lowerCAmelCase_     (		lowercase:							Tuple		)    ->				Any:







 '''simple docstring'''
 _UpperCamelCase:     str							= int(lowercase		)
 return DistributedType(['''NO''', '''MULTI_CPU''', '''MULTI_XPU''', '''MULTI_GPU''', '''MULTI_NPU''', '''TPU'''][value]		)




def       lowerCAmelCase_     (		lowercase:							Union[str, Any]		)    ->				Optional[int]:







 '''simple docstring'''
 _UpperCamelCase:     Tuple							= int(lowercase		)
 return DynamoBackend(DYNAMO_BACKENDS[value]		).value




def       lowerCAmelCase_     (		lowercase:							int		)    ->				Any:







 '''simple docstring'''
 _UpperCamelCase:     int							= int(lowercase		)
 return PrecisionType(['''no''', '''fp16''', '''bf16''', '''fp8'''][value]		)




def       lowerCAmelCase_     (		lowercase:							List[str]		)    ->				List[str]:







 '''simple docstring'''
 _UpperCamelCase:     Dict							= int(lowercase		)
 return SageMakerDistributedType(['''NO''', '''DATA_PARALLEL''', '''MODEL_PARALLEL'''][value]		)




def       lowerCAmelCase_     (		lowercase:							Any		)    ->				List[str]:







 '''simple docstring'''
 return {"yes": True, "no": False}[value.lower()]





class  __magic_name__  (		argparse.RawDescriptionHelpFormatter    ):





   """simple docstring"""




   def   lowerCAmelCase						(	self					:  str		,  _lowercase					:  Optional[int]		,  _lowercase					:  List[Any]		,  _lowercase					:  Dict		,  _lowercase					:  Any							):



    """simple docstring"""



    _UpperCamelCase:     Optional[Any]							= super()._format_usage(_lowercase		,  _lowercase		,  _lowercase		,  _lowercase							)
    _UpperCamelCase:     int							= usage.replace('''<command> [<args>] '''		,  ''''''							)
    return usage