




from typing import Optional, Tuple, Union

import flax
import flax.linen as nn
import jax
import jax.numpy as jnp
from flax.core.frozen_dict import FrozenDict

from ..configuration_utils import ConfigMixin, flax_register_to_config
from ..utils import BaseOutput
from .embeddings_flax import FlaxTimestepEmbedding, FlaxTimesteps
from .modeling_flax_utils import FlaxModelMixin
from .unet_ad_blocks_flax import (
    FlaxCrossAttnDownBlockaD,
    FlaxDownBlockaD,
    FlaxUNetMidBlockaDCrossAttn,
)


@flax.struct.dataclass
class 							UpperCamelCase_       (					UpperCAmelCase__	):

    '''simple docstring'''






    UpperCAmelCase__				    = 42
    UpperCAmelCase__				    = 42


class 							UpperCamelCase_       (					nn.Module	):

    '''simple docstring'''






    UpperCAmelCase__				    = 42
    UpperCAmelCase__				    = (16, 32, 96, 256)
    UpperCAmelCase__				    = jnp.floataa


    def 			SCREAMING_SNAKE_CASE				(     self :      List[str])		->Tuple:





           '''simple docstring'''

           A__ 					=       nn.Conv(
               self.block_out_channels[0]   ,					kernel_size=(3, 3)   ,					padding=((1, 1), (1, 1))   ,					dtype=self.dtype   ,					)

           A__ 					=       []
           for i in range(len(self.block_out_channels) - 1):
                  A__ 					=       self.block_out_channels[i]
                  A__ 					=       self.block_out_channels[i + 1]
                  A__ 					=       nn.Conv(
                      UpperCAmelCase__   ,					kernel_size=(3, 3)   ,					padding=((1, 1), (1, 1))   ,					dtype=self.dtype   ,					)
                  blocks.append(UpperCAmelCase__)
                  A__ 					=       nn.Conv(
                      UpperCAmelCase__   ,					kernel_size=(3, 3)   ,					strides=(2, 2)   ,					padding=((1, 1), (1, 1))   ,					dtype=self.dtype   ,					)
                  blocks.append(UpperCAmelCase__)
           A__ 					=       blocks

           A__ 					=       nn.Conv(
               self.conditioning_embedding_channels   ,					kernel_size=(3, 3)   ,					padding=((1, 1), (1, 1))   ,					kernel_init=nn.initializers.zeros_init()   ,					bias_init=nn.initializers.zeros_init()   ,					dtype=self.dtype   ,					)





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





           '''simple docstring'''

           A__ 					=       self.conv_in(UpperCAmelCase__)
           A__ 					=       nn.silu(UpperCAmelCase__)

           for block in self.blocks:
                  A__ 					=       block(UpperCAmelCase__)
                  A__ 					=       nn.silu(UpperCAmelCase__)

           A__ 					=       self.conv_out(UpperCAmelCase__)

           return embedding


@flax_register_to_config
class 							UpperCamelCase_       (					nn.Module						,   UpperCAmelCase__						,   UpperCAmelCase__	):

    '''simple docstring'''






    UpperCAmelCase__				    = 32
    UpperCAmelCase__				    = 4
    UpperCAmelCase__				    = (
        "CrossAttnDownBlock2D",
        "CrossAttnDownBlock2D",
        "CrossAttnDownBlock2D",
        "DownBlock2D",
    )
    UpperCAmelCase__				    = False
    UpperCAmelCase__				    = (320, 640, 1280, 1280)
    UpperCAmelCase__				    = 2
    UpperCAmelCase__				    = 8
    UpperCAmelCase__				    = None
    UpperCAmelCase__				    = 1280
    UpperCAmelCase__				    = 0.0
    UpperCAmelCase__				    = False
    UpperCAmelCase__				    = jnp.floataa
    UpperCAmelCase__				    = True
    UpperCAmelCase__				    = 0
    UpperCAmelCase__				    = "rgb"
    UpperCAmelCase__				    = (16, 32, 96, 256)


    def 			SCREAMING_SNAKE_CASE				(     self :      Optional[Any]   ,					UpperCAmelCase__ :      jax.random.KeyArray)		->FrozenDict:





           '''simple docstring'''

           A__ 					=       (1, self.in_channels, self.sample_size, self.sample_size)
           A__ 					=       jnp.zeros(UpperCAmelCase__   ,					dtype=jnp.floataa)
           A__ 					=       jnp.ones((1,)   ,					dtype=jnp.intaa)
           A__ 					=       jnp.zeros((1, 1, self.cross_attention_dim)   ,					dtype=jnp.floataa)
           A__ 					=       (1, 3, self.sample_size * 8, self.sample_size * 8)
           A__ 					=       jnp.zeros(UpperCAmelCase__   ,					dtype=jnp.floataa)

           A__					,				A__ 					=       jax.random.split(UpperCAmelCase__)
           A__ 					=       {'''params''': params_rng, '''dropout''': dropout_rng}

           return self.init(UpperCAmelCase__   ,					UpperCAmelCase__   ,					UpperCAmelCase__   ,					UpperCAmelCase__   ,					UpperCAmelCase__)["params"]


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





           '''simple docstring'''

           A__ 					=       self.block_out_channels
           A__ 					=       block_out_channels[0] * 4

           # If `num_attention_heads` is not defined (which is the case for most models)
           # it will default to `attention_head_dim`. This looks weird upon first reading it and it is.
           # The reason for this behavior is to correct for incorrectly named variables that were introduced
           # when this library was created. The incorrect naming was only discovered much later in https://github.com/huggingface/diffusers/issues/2011#issuecomment-1547958131
           # Changing `attention_head_dim` to `num_attention_heads` for 40,000+ configurations is too backwards breaking
           # which is why we correct for the naming here.
           A__ 					=       self.num_attention_heads or self.attention_head_dim

           # input
           A__ 					=       nn.Conv(
               block_out_channels[0]   ,					kernel_size=(3, 3)   ,					strides=(1, 1)   ,					padding=((1, 1), (1, 1))   ,					dtype=self.dtype   ,					)

           # time
           A__ 					=       FlaxTimesteps(
               block_out_channels[0]   ,					flip_sin_to_cos=self.flip_sin_to_cos   ,					freq_shift=self.config.freq_shift)
           A__ 					=       FlaxTimestepEmbedding(UpperCAmelCase__   ,					dtype=self.dtype)

           A__ 					=       FlaxControlNetConditioningEmbedding(
               conditioning_embedding_channels=block_out_channels[0]   ,					block_out_channels=self.conditioning_embedding_out_channels   ,					)

           A__ 					=       self.only_cross_attention
           if isinstance(UpperCAmelCase__   ,					UpperCAmelCase__):
                  A__ 					=       (only_cross_attention,) * len(self.down_block_types)

           if isinstance(UpperCAmelCase__   ,					UpperCAmelCase__):
                  A__ 					=       (num_attention_heads,) * len(self.down_block_types)

           # down
           A__ 					=       []
           A__ 					=       []

           A__ 					=       block_out_channels[0]

           A__ 					=       nn.Conv(
               UpperCAmelCase__   ,					kernel_size=(1, 1)   ,					padding='''VALID'''   ,					kernel_init=nn.initializers.zeros_init()   ,					bias_init=nn.initializers.zeros_init()   ,					dtype=self.dtype   ,					)
           controlnet_down_blocks.append(UpperCAmelCase__)

           for i, down_block_type in enumerate(self.down_block_types):
                  A__ 					=       output_channel
                  A__ 					=       block_out_channels[i]
                  A__ 					=       i == len(UpperCAmelCase__) - 1

                  if down_block_type == "CrossAttnDownBlock2D":
                         A__ 					=       FlaxCrossAttnDownBlockaD(
                             in_channels=UpperCAmelCase__   ,					out_channels=UpperCAmelCase__   ,					dropout=self.dropout   ,					num_layers=self.layers_per_block   ,					num_attention_heads=num_attention_heads[i]   ,					add_downsample=not is_final_block   ,					use_linear_projection=self.use_linear_projection   ,					only_cross_attention=only_cross_attention[i]   ,					dtype=self.dtype   ,					)
                  else:
                         A__ 					=       FlaxDownBlockaD(
                             in_channels=UpperCAmelCase__   ,					out_channels=UpperCAmelCase__   ,					dropout=self.dropout   ,					num_layers=self.layers_per_block   ,					add_downsample=not is_final_block   ,					dtype=self.dtype   ,					)

                  down_blocks.append(UpperCAmelCase__)

                  for _ in range(self.layers_per_block):
                         A__ 					=       nn.Conv(
                             UpperCAmelCase__   ,					kernel_size=(1, 1)   ,					padding='''VALID'''   ,					kernel_init=nn.initializers.zeros_init()   ,					bias_init=nn.initializers.zeros_init()   ,					dtype=self.dtype   ,					)
                         controlnet_down_blocks.append(UpperCAmelCase__)

                  if not is_final_block:
                         A__ 					=       nn.Conv(
                             UpperCAmelCase__   ,					kernel_size=(1, 1)   ,					padding='''VALID'''   ,					kernel_init=nn.initializers.zeros_init()   ,					bias_init=nn.initializers.zeros_init()   ,					dtype=self.dtype   ,					)
                         controlnet_down_blocks.append(UpperCAmelCase__)

           A__ 					=       down_blocks
           A__ 					=       controlnet_down_blocks

           # mid
           A__ 					=       block_out_channels[-1]
           A__ 					=       FlaxUNetMidBlockaDCrossAttn(
               in_channels=UpperCAmelCase__   ,					dropout=self.dropout   ,					num_attention_heads=num_attention_heads[-1]   ,					use_linear_projection=self.use_linear_projection   ,					dtype=self.dtype   ,					)

           A__ 					=       nn.Conv(
               UpperCAmelCase__   ,					kernel_size=(1, 1)   ,					padding='''VALID'''   ,					kernel_init=nn.initializers.zeros_init()   ,					bias_init=nn.initializers.zeros_init()   ,					dtype=self.dtype   ,					)





    def __call__(     self :      List[str]   ,					UpperCAmelCase__ :      Tuple   ,					UpperCAmelCase__ :      Optional[int]   ,					UpperCAmelCase__ :      Any   ,					UpperCAmelCase__ :      int   ,					UpperCAmelCase__ :      float = 1.0   ,					UpperCAmelCase__ :      bool = True   ,					UpperCAmelCase__ :      bool = False   ,					)		->Union[FlaxControlNetOutput, Tuple]:





           '''simple docstring'''

           A__ 					=       self.controlnet_conditioning_channel_order
           if channel_order == "bgr":
                  A__ 					=       jnp.flip(UpperCAmelCase__   ,					axis=1)

           # 1. time
           if not isinstance(UpperCAmelCase__   ,					jnp.ndarray):
                  A__ 					=       jnp.array([timesteps]   ,					dtype=jnp.intaa)
           elif isinstance(UpperCAmelCase__   ,					jnp.ndarray) and len(timesteps.shape) == 0:
                  A__ 					=       timesteps.astype(dtype=jnp.floataa)
                  A__ 					=       jnp.expand_dims(UpperCAmelCase__   ,					0)

           A__ 					=       self.time_proj(UpperCAmelCase__)
           A__ 					=       self.time_embedding(UpperCAmelCase__)

           # 2. pre-process
           A__ 					=       jnp.transpose(UpperCAmelCase__   ,					(0, 2, 3, 1))
           A__ 					=       self.conv_in(UpperCAmelCase__)

           A__ 					=       jnp.transpose(UpperCAmelCase__   ,					(0, 2, 3, 1))
           A__ 					=       self.controlnet_cond_embedding(UpperCAmelCase__)
           sample += controlnet_cond

           # 3. down
           A__ 					=       (sample,)
           for down_block in self.down_blocks:
                  if isinstance(UpperCAmelCase__   ,					UpperCAmelCase__):
                         A__					,				A__ 					=       down_block(UpperCAmelCase__   ,					UpperCAmelCase__   ,					UpperCAmelCase__   ,					deterministic=not train)
                  else:
                         A__					,				A__ 					=       down_block(UpperCAmelCase__   ,					UpperCAmelCase__   ,					deterministic=not train)
                  down_block_res_samples += res_samples

           # 4. mid
           A__ 					=       self.mid_block(UpperCAmelCase__   ,					UpperCAmelCase__   ,					UpperCAmelCase__   ,					deterministic=not train)

           # 5. contronet blocks
           A__ 					=       ()
           for down_block_res_sample, controlnet_block in zip(UpperCAmelCase__   ,					self.controlnet_down_blocks):
                  A__ 					=       controlnet_block(UpperCAmelCase__)
                  controlnet_down_block_res_samples += (down_block_res_sample,)

           A__ 					=       controlnet_down_block_res_samples

           A__ 					=       self.controlnet_mid_block(UpperCAmelCase__)

           # 6. scaling
           A__ 					=       [sample * conditioning_scale for sample in down_block_res_samples]
           mid_block_res_sample *= conditioning_scale

           if not return_dict:
                  return (down_block_res_samples, mid_block_res_sample)

           return FlaxControlNetOutput(
               down_block_res_samples=UpperCAmelCase__   ,					mid_block_res_sample=UpperCAmelCase__)






"""simple docstring"""



import json
import os
import unittest

from transformers.models.gptsan_japanese.tokenization_gptsan_japanese import (
    VOCAB_FILES_NAMES,
    GPTSanJapaneseTokenizer,
)
from transformers.testing_utils import require_tokenizers, slow

from ...test_tokenization_common import TokenizerTesterMixin







@require_tokenizers
class    __a						( __snake_case					,			unittest.TestCase							):
				lowerCamelCase     :       Any			       =GPTSanJapaneseTokenizer
				lowerCamelCase     :       List[str]			       =False
				lowerCamelCase     :       List[str]			       ={'do_clean_text': False, 'add_prefix_space': False}







				def      lowerCamelCase_     ( self   ):

					'''simple docstring'''






					super().setUp()

					# fmt: off
					lowerCAmelCase_      							=			['''こん''', '''こんに''', '''にちは''', '''ばんは''', '''世界,㔺界''', '''、''', '''。''', '''<BR>''', '''<SP>''', '''<TAB>''', '''<URL>''', '''<EMAIL>''', '''<TEL>''', '''<DATE>''', '''<PRICE>''', '''<BLOCK>''', '''<KIGOU>''', '''<U2000U2BFF>''', '''<|emoji1|>''', '''<unk>''', '''<|bagoftoken|>''', '''<|endoftext|>''']
					# fmt: on
					lowerCAmelCase_      							=			{'''emoji''': {'''\ud83d\ude00''': '''<|emoji1|>'''}, '''emoji_inv''': {'''<|emoji1|>''': '''\ud83d\ude00'''}}  # 😀
					lowerCAmelCase_      							=			{'''unk_token''': '''<unk>'''}

					lowerCAmelCase_      							=			os.path.join(self.tmpdirname      ,	VOCAB_FILES_NAMES['''vocab_file''']   )
					lowerCAmelCase_      							=			os.path.join(self.tmpdirname      ,	VOCAB_FILES_NAMES['''emoji_file''']   )
					with open(self.vocab_file      ,	'''w'''      ,	encoding='''utf-8'''   ) as vocab_writer:
						vocab_writer.write(''''''.join([x + '''\n''' for x in vocab_tokens]   )   )
					with open(self.emoji_file      ,	'''w'''   ) as emoji_writer:
						emoji_writer.write(json.dumps(UpperCAmelCase   )   )







				def      lowerCamelCase_     ( self      ,	**UpperCAmelCase   ):

					'''simple docstring'''






					kwargs.update(self.special_tokens_map   )
					return GPTSanJapaneseTokenizer.from_pretrained(self.tmpdirname      ,	**UpperCAmelCase   )







				def      lowerCamelCase_     ( self      ,	UpperCAmelCase   ):

					'''simple docstring'''






					lowerCAmelCase_      							=			'''こんにちは、世界。 \nこんばんは、㔺界。😀'''
					lowerCAmelCase_      							=			'''こんにちは、世界。 \nこんばんは、世界。😀'''
					return input_text, output_text







				def      lowerCamelCase_     ( self      ,	UpperCAmelCase   ):

					'''simple docstring'''






					lowerCAmelCase_							,	lowerCAmelCase_      							=			self.get_input_output_texts(UpperCAmelCase   )
					lowerCAmelCase_      							=			tokenizer.encode(UpperCAmelCase      ,	add_special_tokens=UpperCAmelCase   )
					lowerCAmelCase_      							=			tokenizer.decode(UpperCAmelCase      ,	clean_up_tokenization_spaces=UpperCAmelCase   )
					return text, ids







				def      lowerCamelCase_     ( self   ):

					'''simple docstring'''






					pass  # TODO add if relevant







				def      lowerCamelCase_     ( self   ):

					'''simple docstring'''






					pass  # TODO add if relevant







				def      lowerCamelCase_     ( self   ):

					'''simple docstring'''






					pass  # TODO add if relevant







				def      lowerCamelCase_     ( self   ):

					'''simple docstring'''






					lowerCAmelCase_      							=			self.get_tokenizer()

					# Testing tokenization
					lowerCAmelCase_      							=			'''こんにちは、世界。　こんばんは、㔺界。'''
					lowerCAmelCase_      							=			['''こん''', '''にちは''', '''、''', '''世界''', '''。''', '''<SP>''', '''こん''', '''ばんは''', '''、''', '''㔺界''', '''。''']
					lowerCAmelCase_      							=			tokenizer.tokenize(UpperCAmelCase   )
					self.assertListEqual(UpperCAmelCase      ,	UpperCAmelCase   )

					# Testing conversion to ids without special tokens
					lowerCAmelCase_      							=			[0, 2, 5, 4, 6, 8, 0, 3, 5, 4, 6]
					lowerCAmelCase_      							=			tokenizer.convert_tokens_to_ids(UpperCAmelCase   )
					self.assertListEqual(UpperCAmelCase      ,	UpperCAmelCase   )

					# Testing conversion to ids with special tokens
					lowerCAmelCase_      							=			tokens + [tokenizer.unk_token]
					lowerCAmelCase_      							=			[0, 2, 5, 4, 6, 8, 0, 3, 5, 4, 6, 19]
					lowerCAmelCase_      							=			tokenizer.convert_tokens_to_ids(UpperCAmelCase   )
					self.assertListEqual(UpperCAmelCase      ,	UpperCAmelCase   )







				def      lowerCamelCase_     ( self   ):

					'''simple docstring'''






					lowerCAmelCase_      							=			self.get_tokenizer()

					# Testing tokenization
					lowerCAmelCase_      							=			'''こんにちは、<|bagoftoken|>世界。こんばんは、<|bagoftoken|>㔺界。'''
					lowerCAmelCase_      							=			'''こんにちは、、、、世界。こんばんは、、、、世界。'''
					lowerCAmelCase_      							=			tokenizer.encode(UpperCAmelCase   )
					lowerCAmelCase_      							=			tokenizer.decode(UpperCAmelCase   )
					self.assertEqual(UpperCAmelCase      ,	UpperCAmelCase   )







				@slow
				def      lowerCamelCase_     ( self   ):

					'''simple docstring'''






					lowerCAmelCase_      							=			self.tokenizer_class.from_pretrained('''Tanrei/GPTSAN-japanese'''   )

					# Testing tokenization
					lowerCAmelCase_      							=			'''こんにちは、世界。'''
					lowerCAmelCase_      							=			'''こんばんは、㔺界。😀'''
					lowerCAmelCase_      							=			'''こんにちは、世界。こんばんは、世界。😀'''
					lowerCAmelCase_      							=			tokenizer.encode(prefix_text + input_text   )
					lowerCAmelCase_      							=			tokenizer.encode(''''''      ,	prefix_text=prefix_text + input_text   )
					lowerCAmelCase_      							=			tokenizer.encode(UpperCAmelCase      ,	prefix_text=UpperCAmelCase   )
					lowerCAmelCase_      							=			tokenizer.decode(UpperCAmelCase   )
					lowerCAmelCase_      							=			tokenizer.decode(UpperCAmelCase   )
					lowerCAmelCase_      							=			tokenizer.decode(UpperCAmelCase   )
					self.assertEqual(UpperCAmelCase      ,	UpperCAmelCase   )
					self.assertEqual(UpperCAmelCase      ,	UpperCAmelCase   )
					self.assertEqual(UpperCAmelCase      ,	UpperCAmelCase   )







				@slow
				def      lowerCamelCase_     ( self   ):

					'''simple docstring'''






					lowerCAmelCase_      							=			self.tokenizer_class.from_pretrained('''Tanrei/GPTSAN-japanese'''   )

					# Testing tokenization
					lowerCAmelCase_      							=			'''こんにちは、世界。'''
					lowerCAmelCase_      							=			'''こんばんは、㔺界。😀'''

					lowerCAmelCase_      							=			len(tokenizer.encode(UpperCAmelCase   )   ) - 2
					lowerCAmelCase_      							=			len(tokenizer.encode(UpperCAmelCase   )   ) - 2

					lowerCAmelCase_      							=			[1] + [0] * (len_prefix + len_text + 1)
					lowerCAmelCase_      							=			[1] * (len_prefix + len_text + 1) + [0]
					lowerCAmelCase_      							=			[1] + [1] * (len_prefix) + [0] * (len_text + 1)

					lowerCAmelCase_      							=			tokenizer(prefix_text + input_text   ).token_type_ids
					lowerCAmelCase_      							=			tokenizer(''''''      ,	prefix_text=prefix_text + input_text   ).token_type_ids
					lowerCAmelCase_      							=			tokenizer(UpperCAmelCase      ,	prefix_text=UpperCAmelCase   ).token_type_ids
					self.assertListEqual(UpperCAmelCase      ,	UpperCAmelCase   )
					self.assertListEqual(UpperCAmelCase      ,	UpperCAmelCase   )
					self.assertListEqual(UpperCAmelCase      ,	UpperCAmelCase   )







				@slow
				def      lowerCamelCase_     ( self   ):

					'''simple docstring'''






					lowerCAmelCase_      							=			self.tokenizer_class.from_pretrained('''Tanrei/GPTSAN-japanese'''   )

					lowerCAmelCase_      							=			tokenizer.encode('''あンいワ'''   )
					lowerCAmelCase_      							=			tokenizer.encode(''''''      ,	prefix_text='''あンいワ'''   )
					lowerCAmelCase_      							=			tokenizer.encode('''いワ'''      ,	prefix_text='''あン'''   )

					self.assertEqual(tokenizer.decode(UpperCAmelCase   )      ,	tokenizer.decode(UpperCAmelCase   )   )
					self.assertEqual(tokenizer.decode(UpperCAmelCase   )      ,	tokenizer.decode(UpperCAmelCase   )   )
					self.assertNotEqual(UpperCAmelCase      ,	UpperCAmelCase   )
					self.assertNotEqual(UpperCAmelCase      ,	UpperCAmelCase   )
					self.assertEqual(x_token_a[1]      ,	x_token_a[-1]   )  # SEG token
					self.assertEqual(x_token_a[1]      ,	x_token_a[3]   )  # SEG token







				@slow
				def      lowerCamelCase_     ( self   ):

					'''simple docstring'''






					lowerCAmelCase_      							=			self.tokenizer_class.from_pretrained('''Tanrei/GPTSAN-japanese'''   )

					lowerCAmelCase_      							=			[['''武田信玄''', '''は、'''], ['''織田信長''', '''の配下の、''']]
					lowerCAmelCase_      							=			tokenizer(UpperCAmelCase      ,	padding=UpperCAmelCase   )
					lowerCAmelCase_      							=			tokenizer.batch_encode_plus(UpperCAmelCase      ,	padding=UpperCAmelCase   )

					# fmt: off
					lowerCAmelCase_      							=			[[3_5993, 8640, 2_5948, 3_5998, 3_0647, 3_5675, 3_5999, 3_5999], [3_5993, 1_0382, 9868, 3_5998, 3_0646, 9459, 3_0646, 3_5675]]
					lowerCAmelCase_      							=			[[1, 1, 1, 0, 0, 0, 0, 0], [1, 1, 1, 0, 0, 0, 0, 0]]
					lowerCAmelCase_      							=			[[1, 1, 1, 1, 1, 1, 0, 0], [1, 1, 1, 1, 1, 1, 1, 1]]
					# fmt: on
					self.assertListEqual(x_token.input_ids      ,	UpperCAmelCase   )
					self.assertListEqual(x_token.token_type_ids      ,	UpperCAmelCase   )
					self.assertListEqual(x_token.attention_mask      ,	UpperCAmelCase   )
					self.assertListEqual(x_token_a.input_ids      ,	UpperCAmelCase   )
					self.assertListEqual(x_token_a.token_type_ids      ,	UpperCAmelCase   )
					self.assertListEqual(x_token_a.attention_mask      ,	UpperCAmelCase   )







				def      lowerCamelCase_     ( self   ):

					'''simple docstring'''






					pass







				def      lowerCamelCase_     ( self   ):

					'''simple docstring'''






					pass