




"""simple docstring"""


import collections
from typing import List, Optional, Union

from ...tokenization_utils_base import BatchEncoding
from ...utils import TensorType, add_end_docstrings, add_start_docstrings, logging
from ..bert.tokenization_bert import BertTokenizer


A_      =    logging.get_logger(__name__)

A_      =    {'''vocab_file''': '''vocab.txt''', '''tokenizer_file''': '''tokenizer.json'''}

A_      =    {
    '''vocab_file''': {
        '''facebook/dpr-ctx_encoder-single-nq-base''': (
            '''https://huggingface.co/facebook/dpr-ctx_encoder-single-nq-base/resolve/main/vocab.txt'''
        ),
        '''facebook/dpr-ctx_encoder-multiset-base''': (
            '''https://huggingface.co/facebook/dpr-ctx_encoder-multiset-base/resolve/main/vocab.txt'''
        ),
    },
    '''tokenizer_file''': {
        '''facebook/dpr-ctx_encoder-single-nq-base''': (
            '''https://huggingface.co/facebook/dpr-ctx_encoder-single-nq-base/resolve/main/tokenizer.json'''
        ),
        '''facebook/dpr-ctx_encoder-multiset-base''': (
            '''https://huggingface.co/facebook/dpr-ctx_encoder-multiset-base/resolve/main/tokenizer.json'''
        ),
    },
}
A_      =    {
    '''vocab_file''': {
        '''facebook/dpr-question_encoder-single-nq-base''': (
            '''https://huggingface.co/facebook/dpr-question_encoder-single-nq-base/resolve/main/vocab.txt'''
        ),
        '''facebook/dpr-question_encoder-multiset-base''': (
            '''https://huggingface.co/facebook/dpr-question_encoder-multiset-base/resolve/main/vocab.txt'''
        ),
    },
    '''tokenizer_file''': {
        '''facebook/dpr-question_encoder-single-nq-base''': (
            '''https://huggingface.co/facebook/dpr-question_encoder-single-nq-base/resolve/main/tokenizer.json'''
        ),
        '''facebook/dpr-question_encoder-multiset-base''': (
            '''https://huggingface.co/facebook/dpr-question_encoder-multiset-base/resolve/main/tokenizer.json'''
        ),
    },
}
A_      =    {
    '''vocab_file''': {
        '''facebook/dpr-reader-single-nq-base''': (
            '''https://huggingface.co/facebook/dpr-reader-single-nq-base/resolve/main/vocab.txt'''
        ),
        '''facebook/dpr-reader-multiset-base''': (
            '''https://huggingface.co/facebook/dpr-reader-multiset-base/resolve/main/vocab.txt'''
        ),
    },
    '''tokenizer_file''': {
        '''facebook/dpr-reader-single-nq-base''': (
            '''https://huggingface.co/facebook/dpr-reader-single-nq-base/resolve/main/tokenizer.json'''
        ),
        '''facebook/dpr-reader-multiset-base''': (
            '''https://huggingface.co/facebook/dpr-reader-multiset-base/resolve/main/tokenizer.json'''
        ),
    },
}

A_      =    {
    '''facebook/dpr-ctx_encoder-single-nq-base''': 5_12,
    '''facebook/dpr-ctx_encoder-multiset-base''': 5_12,
}
A_      =    {
    '''facebook/dpr-question_encoder-single-nq-base''': 5_12,
    '''facebook/dpr-question_encoder-multiset-base''': 5_12,
}
A_      =    {
    '''facebook/dpr-reader-single-nq-base''': 5_12,
    '''facebook/dpr-reader-multiset-base''': 5_12,
}


A_      =    {
    '''facebook/dpr-ctx_encoder-single-nq-base''': {'''do_lower_case''': True},
    '''facebook/dpr-ctx_encoder-multiset-base''': {'''do_lower_case''': True},
}
A_      =    {
    '''facebook/dpr-question_encoder-single-nq-base''': {'''do_lower_case''': True},
    '''facebook/dpr-question_encoder-multiset-base''': {'''do_lower_case''': True},
}
A_      =    {
    '''facebook/dpr-reader-single-nq-base''': {'''do_lower_case''': True},
    '''facebook/dpr-reader-multiset-base''': {'''do_lower_case''': True},
}






class  lowercase(					_a			):







 '''simple docstring'''





 lowercase__			 = VOCAB_FILES_NAMES
 lowercase__			 = CONTEXT_ENCODER_PRETRAINED_VOCAB_FILES_MAP
 lowercase__			 = CONTEXT_ENCODER_PRETRAINED_POSITIONAL_EMBEDDINGS_SIZES
 lowercase__			 = CONTEXT_ENCODER_PRETRAINED_INIT_CONFIGURATION






class  lowercase(					_a			):







 '''simple docstring'''





 lowercase__			 = VOCAB_FILES_NAMES
 lowercase__			 = QUESTION_ENCODER_PRETRAINED_VOCAB_FILES_MAP
 lowercase__			 = QUESTION_ENCODER_PRETRAINED_POSITIONAL_EMBEDDINGS_SIZES
 lowercase__			 = QUESTION_ENCODER_PRETRAINED_INIT_CONFIGURATION





A_      =    collections.namedtuple(
    '''DPRSpanPrediction''', ['''span_score''', '''relevance_score''', '''doc_id''', '''start_index''', '''end_index''', '''text''']
)

A_      =    collections.namedtuple('''DPRReaderOutput''', ['''start_logits''', '''end_logits''', '''relevance_logits'''])


A_      =    r'''\n    Return a dictionary with the token ids of the input strings and other information to give to `.decode_best_spans`.\n    It converts the strings of a question and different passages (title and text) in a sequence of IDs (integers),\n    using the tokenizer and vocabulary. The resulting `input_ids` is a matrix of size `(n_passages, sequence_length)`\n    with the format:\n\n    ```\n    [CLS] <question token ids> [SEP] <titles ids> [SEP] <texts ids>\n    ```\n\n    Args:\n        questions (`str` or `List[str]`):\n            The questions to be encoded. You can specify one question for many passages. In this case, the question\n            will be duplicated like `[questions] * n_passages`. Otherwise you have to specify as many questions as in\n            `titles` or `texts`.\n        titles (`str` or `List[str]`):\n            The passages titles to be encoded. This can be a string or a list of strings if there are several passages.\n        texts (`str` or `List[str]`):\n            The passages texts to be encoded. This can be a string or a list of strings if there are several passages.\n        padding (`bool`, `str` or [`~utils.PaddingStrategy`], *optional*, defaults to `False`):\n            Activates and controls padding. Accepts the following values:\n\n            - `True` or `\'longest\'`: Pad to the longest sequence in the batch (or no padding if only a single sequence\n              if provided).\n            - `\'max_length\'`: Pad to a maximum length specified with the argument `max_length` or to the maximum\n              acceptable input length for the model if that argument is not provided.\n            - `False` or `\'do_not_pad\'` (default): No padding (i.e., can output a batch with sequences of different\n              lengths).\n        truncation (`bool`, `str` or [`~tokenization_utils_base.TruncationStrategy`], *optional*, defaults to `False`):\n            Activates and controls truncation. Accepts the following values:\n\n            - `True` or `\'longest_first\'`: Truncate to a maximum length specified with the argument `max_length` or to\n              the maximum acceptable input length for the model if that argument is not provided. This will truncate\n              token by token, removing a token from the longest sequence in the pair if a pair of sequences (or a batch\n              of pairs) is provided.\n            - `\'only_first\'`: Truncate to a maximum length specified with the argument `max_length` or to the maximum\n              acceptable input length for the model if that argument is not provided. This will only truncate the first\n              sequence of a pair if a pair of sequences (or a batch of pairs) is provided.\n            - `\'only_second\'`: Truncate to a maximum length specified with the argument `max_length` or to the maximum\n              acceptable input length for the model if that argument is not provided. This will only truncate the\n              second sequence of a pair if a pair of sequences (or a batch of pairs) is provided.\n            - `False` or `\'do_not_truncate\'` (default): No truncation (i.e., can output batch with sequence lengths\n              greater than the model maximum admissible input size).\n        max_length (`int`, *optional*):\n                Controls the maximum length to use by one of the truncation/padding parameters.\n\n                If left unset or set to `None`, this will use the predefined model maximum length if a maximum length\n                is required by one of the truncation/padding parameters. If the model has no specific maximum input\n                length (like XLNet) truncation/padding to a maximum length will be deactivated.\n        return_tensors (`str` or [`~utils.TensorType`], *optional*):\n                If set, will return tensors instead of list of python integers. Acceptable values are:\n\n                - `\'tf\'`: Return TensorFlow `tf.constant` objects.\n                - `\'pt\'`: Return PyTorch `torch.Tensor` objects.\n                - `\'np\'`: Return Numpy `np.ndarray` objects.\n        return_attention_mask (`bool`, *optional*):\n            Whether or not to return the attention mask. If not set, will return the attention mask according to the\n            specific tokenizer\'s default, defined by the `return_outputs` attribute.\n\n            [What are attention masks?](../glossary#attention-mask)\n\n    Returns:\n        `Dict[str, List[List[int]]]`: A dictionary with the following keys:\n\n        - `input_ids`: List of token ids to be fed to a model.\n        - `attention_mask`: List of indices specifying which tokens should be attended to by the model.\n    '''






@add_start_docstrings(_a			)
class  lowercase:







 '''simple docstring'''





 def __call__(    self:		str,				a_:		Optional[Any],				a_:		Optional[str] = None,				a_:		Optional[str] = None,				a_:		Union[bool, str] = False,				a_:		Union[bool, str] = False,				a_:		Optional[int] = None,				a_:		Optional[Union[str, TensorType]] = None,				a_:		Optional[bool] = None,				**a_:		Union[str, Any],				):




   '''simple docstring'''



   if titles is None and texts is None:
     return super().__call__(
         snake_case_,				padding=snake_case_,				truncation=snake_case_,				max_length=snake_case_,				return_tensors=snake_case_,				return_attention_mask=snake_case_,				**snake_case_,				)
   elif titles is None or texts is None:
     _snake_case							:		int								=  titles if texts is None else texts
     return super().__call__(
         snake_case_,				snake_case_,				padding=snake_case_,				truncation=snake_case_,				max_length=snake_case_,				return_tensors=snake_case_,				return_attention_mask=snake_case_,				**snake_case_,				)
   _snake_case							:		List[str]								=  titles if not isinstance(snake_case_,				snake_case_		) else [titles]
   _snake_case							:		Union[str, Any]								=  texts if not isinstance(snake_case_,				snake_case_		) else [texts]
   _snake_case							:		Dict								=  len(snake_case_		)
   _snake_case							:		Union[str, Any]								=  questions if not isinstance(snake_case_,				snake_case_		) else [questions] * n_passages
   if len(snake_case_		) != len(snake_case_		):
     raise ValueError(
         f"There should be as many titles than texts but got {len(snake_case_		)} titles and {len(snake_case_		)} texts."		)
   _snake_case							:		int								=  super().__call__(snake_case_,				snake_case_,				padding=snake_case_,				truncation=snake_case_		)["""input_ids"""]
   _snake_case							:		Any								=  super().__call__(snake_case_,				add_special_tokens=snake_case_,				padding=snake_case_,				truncation=snake_case_		)["""input_ids"""]
   _snake_case							:		Dict								=  {
       """input_ids""": [
           (encoded_question_and_title + encoded_text)[:max_length]
           if max_length is not None and truncation
           else encoded_question_and_title + encoded_text
           for encoded_question_and_title, encoded_text in zip(snake_case_,				snake_case_		)
       ]
   }
   if return_attention_mask is not False:
     _snake_case							:		List[Any]								=  []
     for input_ids in encoded_inputs["input_ids"]:
       attention_mask.append([int(input_id != self.pad_token_id		) for input_id in input_ids]		)
     _snake_case							:		Union[str, Any]								=  attention_mask
   return self.pad(snake_case_,				padding=snake_case_,				max_length=snake_case_,				return_tensors=snake_case_		)


 def 			UpperCamelCase_       (    self:		Optional[int],				a_:		BatchEncoding,				a_:		DPRReaderOutput,				a_:		int = 16,				a_:		int = 64,				a_:		int = 4,				):




   '''simple docstring'''



   _snake_case							:		Optional[int]								=  reader_input["""input_ids"""]
   _snake_case							:		List[str]								=  reader_output[:3]
   _snake_case							:		Union[str, Any]								=  len(snake_case_		)
   _snake_case							:		Tuple								=  sorted(range(snake_case_		),				reverse=snake_case_,				key=relevance_logits.__getitem__		)
   _snake_case							:		List[DPRReaderOutput]								=  []
   for doc_id in sorted_docs:
     _snake_case							:		Union[str, Any]								=  list(input_ids[doc_id]		)
     # assuming question & title information is at the beginning of the sequence
     _snake_case							:		Optional[Any]								=  sequence_ids.index(self.sep_token_id,				2		) + 1  # second sep id
     if sequence_ids[-1] == self.pad_token_id:
       _snake_case							:		int								=  sequence_ids.index(self.pad_token_id		)
     else:
       _snake_case							:		int								=  len(snake_case_		)

     _snake_case							:		Optional[int]								=  self._get_best_spans(
         start_logits=start_logits[doc_id][passage_offset:sequence_len],				end_logits=end_logits[doc_id][passage_offset:sequence_len],				max_answer_length=snake_case_,				top_spans=snake_case_,				)
     for start_index, end_index in best_spans:
       start_index += passage_offset
       end_index += passage_offset
       nbest_spans_predictions.append(
           DPRSpanPrediction(
               span_score=start_logits[doc_id][start_index] + end_logits[doc_id][end_index],				relevance_score=relevance_logits[doc_id],				doc_id=snake_case_,				start_index=snake_case_,				end_index=snake_case_,				text=self.decode(sequence_ids[start_index : end_index + 1]		),				)		)
     if len(snake_case_		) >= num_spans:
       break
   return nbest_spans_predictions[:num_spans]


 def 			UpperCamelCase_       (    self:		str,				a_:		List[int],				a_:		List[int],				a_:		int,				a_:		int,				):




   '''simple docstring'''



   _snake_case							:		List[str]								=  []
   for start_index, start_score in enumerate(snake_case_		):
     for answer_length, end_score in enumerate(end_logits[start_index : start_index + max_answer_length]		):
       scores.append(((start_index, start_index + answer_length), start_score + end_score)		)
   _snake_case							:		Any								=  sorted(snake_case_,				key=lambda a_		: x[1],				reverse=snake_case_		)
   _snake_case							:		Optional[Any]								=  []
   for (start_index, end_index), score in scores:
     if start_index > end_index:
       raise ValueError(f"Wrong span indices: [{start_index}:{end_index}]"		)
     _snake_case							:		Union[str, Any]								=  end_index - start_index + 1
     if length > max_answer_length:
       raise ValueError(f"Span is too long: {length} > {max_answer_length}"		)
     if any(
         start_index <= prev_start_index <= prev_end_index <= end_index
         or prev_start_index <= start_index <= end_index <= prev_end_index
         for (prev_start_index, prev_end_index) in chosen_span_intervals		):
       continue
     chosen_span_intervals.append((start_index, end_index)		)

     if len(snake_case_		) == top_spans:
       break
   return chosen_span_intervals






@add_end_docstrings(_a			)
class  lowercase(					_a	,      _a			):







 '''simple docstring'''





 lowercase__			 = VOCAB_FILES_NAMES
 lowercase__			 = READER_PRETRAINED_VOCAB_FILES_MAP
 lowercase__			 = READER_PRETRAINED_POSITIONAL_EMBEDDINGS_SIZES
 lowercase__			 = READER_PRETRAINED_INIT_CONFIGURATION
 lowercase__			 = ["input_ids", "attention_mask"]








"""simple docstring"""


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  lowercase(					__a			):







 '''simple docstring'''





 lowercase__			 = 42
 lowercase__			 = 42







class  lowercase(					nn.Module			):







 '''simple docstring'''





 lowercase__			 = 42
 lowercase__			 = (16, 32, 96, 2_56)
 lowercase__			 = jnp.floataa


 def 			UpperCamelCase_       (    self:		Optional[int]		):




   '''simple docstring'''



   _snake_case							:		List[str]								=  nn.Conv(
       self.block_out_channels[0],				kernel_size=(3, 3),				padding=((1, 1), (1, 1)),				dtype=self.dtype,				)

   _snake_case							:		int								=  []
   for i in range(len(self.block_out_channels		) - 1		):
     _snake_case							:		int								=  self.block_out_channels[i]
     _snake_case							:		Tuple								=  self.block_out_channels[i + 1]
     _snake_case							:		Dict								=  nn.Conv(
         a_,				kernel_size=(3, 3),				padding=((1, 1), (1, 1)),				dtype=self.dtype,				)
     blocks.append(a_		)
     _snake_case							:		List[Any]								=  nn.Conv(
         a_,				kernel_size=(3, 3),				strides=(2, 2),				padding=((1, 1), (1, 1)),				dtype=self.dtype,				)
     blocks.append(a_		)
   _snake_case							:		Any								=  blocks

   _snake_case							:		Optional[Any]								=  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:		Optional[Any],				a_:		Optional[Any]		):




   '''simple docstring'''



   _snake_case							:		int								=  self.conv_in(a_		)
   _snake_case							:		Optional[int]								=  nn.silu(a_		)

   for block in self.blocks:
     _snake_case							:		Tuple								=  block(a_		)
     _snake_case							:		int								=  nn.silu(a_		)

   _snake_case							:		Optional[int]								=  self.conv_out(a_		)

   return embedding







@flax_register_to_config
class  lowercase(					nn.Module	,      __a	,      __a			):







 '''simple docstring'''





 lowercase__			 = 32
 lowercase__			 = 4
 lowercase__			 = (
     "CrossAttnDownBlock2D",
     "CrossAttnDownBlock2D",
     "CrossAttnDownBlock2D",
     "DownBlock2D",
 )
 lowercase__			 = False
 lowercase__			 = (3_20, 6_40, 12_80, 12_80)
 lowercase__			 = 2
 lowercase__			 = 8
 lowercase__			 = None
 lowercase__			 = 12_80
 lowercase__			 = 0.0
 lowercase__			 = False
 lowercase__			 = jnp.floataa
 lowercase__			 = True
 lowercase__			 = 0
 lowercase__			 = "rgb"
 lowercase__			 = (16, 32, 96, 2_56)


 def 			UpperCamelCase_       (    self:		int,				a_:		jax.random.KeyArray		):




   '''simple docstring'''



   _snake_case							:		str								=  (1, self.in_channels, self.sample_size, self.sample_size)
   _snake_case							:		Optional[Any]								=  jnp.zeros(a_,				dtype=jnp.floataa		)
   _snake_case							:		List[str]								=  jnp.ones((1,),				dtype=jnp.intaa		)
   _snake_case							:		List[Any]								=  jnp.zeros((1, 1, self.cross_attention_dim),				dtype=jnp.floataa		)
   _snake_case							:		Any								=  (1, 3, self.sample_size * 8, self.sample_size * 8)
   _snake_case							:		Optional[int]								=  jnp.zeros(a_,				dtype=jnp.floataa		)

   _snake_case		, _snake_case							:		Tuple								=  jax.random.split(a_		)
   _snake_case							:		str								=  {"""params""": params_rng, """dropout""": dropout_rng}

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


 def 			UpperCamelCase_       (    self:		Any		):




   '''simple docstring'''



   _snake_case							:		Optional[int]								=  self.block_out_channels
   _snake_case							:		Optional[int]								=  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.
   _snake_case							:		int								=  self.num_attention_heads or self.attention_head_dim

   # input
   _snake_case							:		Union[str, Any]								=  nn.Conv(
       block_out_channels[0],				kernel_size=(3, 3),				strides=(1, 1),				padding=((1, 1), (1, 1)),				dtype=self.dtype,				)

   # time
   _snake_case							:		int								=  FlaxTimesteps(
       block_out_channels[0],				flip_sin_to_cos=self.flip_sin_to_cos,				freq_shift=self.config.freq_shift		)
   _snake_case							:		Any								=  FlaxTimestepEmbedding(a_,				dtype=self.dtype		)

   _snake_case							:		Optional[Any]								=  FlaxControlNetConditioningEmbedding(
       conditioning_embedding_channels=block_out_channels[0],				block_out_channels=self.conditioning_embedding_out_channels,				)

   _snake_case							:		List[str]								=  self.only_cross_attention
   if isinstance(a_,				a_		):
     _snake_case							:		List[Any]								=  (only_cross_attention,) * len(self.down_block_types		)

   if isinstance(a_,				a_		):
     _snake_case							:		Optional[Any]								=  (num_attention_heads,) * len(self.down_block_types		)

   # down
   _snake_case							:		List[str]								=  []
   _snake_case							:		Tuple								=  []

   _snake_case							:		int								=  block_out_channels[0]

   _snake_case							:		Optional[Any]								=  nn.Conv(
       a_,				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(a_		)

   for i, down_block_type in enumerate(self.down_block_types		):
     _snake_case							:		List[Any]								=  output_channel
     _snake_case							:		Any								=  block_out_channels[i]
     _snake_case							:		List[str]								=  i == len(a_		) - 1

     if down_block_type == "CrossAttnDownBlock2D":
       _snake_case							:		Optional[int]								=  FlaxCrossAttnDownBlockaD(
           in_channels=a_,				out_channels=a_,				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:
       _snake_case							:		List[Any]								=  FlaxDownBlockaD(
           in_channels=a_,				out_channels=a_,				dropout=self.dropout,				num_layers=self.layers_per_block,				add_downsample=not is_final_block,				dtype=self.dtype,				)

     down_blocks.append(a_		)

     for _ in range(self.layers_per_block		):
       _snake_case							:		List[Any]								=  nn.Conv(
           a_,				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(a_		)

     if not is_final_block:
       _snake_case							:		List[Any]								=  nn.Conv(
           a_,				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(a_		)

   _snake_case							:		str								=  down_blocks
   _snake_case							:		Union[str, Any]								=  controlnet_down_blocks

   # mid
   _snake_case							:		Tuple								=  block_out_channels[-1]
   _snake_case							:		Optional[int]								=  FlaxUNetMidBlockaDCrossAttn(
       in_channels=a_,				dropout=self.dropout,				num_attention_heads=num_attention_heads[-1],				use_linear_projection=self.use_linear_projection,				dtype=self.dtype,				)

   _snake_case							:		Tuple								=  nn.Conv(
       a_,				kernel_size=(1, 1),				padding="""VALID""",				kernel_init=nn.initializers.zeros_init(),				bias_init=nn.initializers.zeros_init(),				dtype=self.dtype,				)


 def __call__(    self:		str,				a_:		Any,				a_:		Tuple,				a_:		Any,				a_:		int,				a_:		float = 1.0,				a_:		bool = True,				a_:		bool = False,				):




   '''simple docstring'''



   _snake_case							:		Dict								=  self.controlnet_conditioning_channel_order
   if channel_order == "bgr":
     _snake_case							:		List[Any]								=  jnp.flip(a_,				axis=1		)

   # 1. time
   if not isinstance(a_,				jnp.ndarray		):
     _snake_case							:		Any								=  jnp.array([timesteps],				dtype=jnp.intaa		)
   elif isinstance(a_,				jnp.ndarray		) and len(timesteps.shape		) == 0:
     _snake_case							:		Union[str, Any]								=  timesteps.astype(dtype=jnp.floataa		)
     _snake_case							:		List[str]								=  jnp.expand_dims(a_,				0		)

   _snake_case							:		List[str]								=  self.time_proj(a_		)
   _snake_case							:		str								=  self.time_embedding(a_		)

   # 2. pre-process
   _snake_case							:		List[str]								=  jnp.transpose(a_,				(0, 2, 3, 1)		)
   _snake_case							:		List[Any]								=  self.conv_in(a_		)

   _snake_case							:		Union[str, Any]								=  jnp.transpose(a_,				(0, 2, 3, 1)		)
   _snake_case							:		Any								=  self.controlnet_cond_embedding(a_		)
   sample += controlnet_cond

   # 3. down
   _snake_case							:		List[str]								=  (sample,)
   for down_block in self.down_blocks:
     if isinstance(a_,				a_		):
       _snake_case		, _snake_case							:		Optional[Any]								=  down_block(a_,				a_,				a_,				deterministic=not train		)
     else:
       _snake_case		, _snake_case							:		Dict								=  down_block(a_,				a_,				deterministic=not train		)
     down_block_res_samples += res_samples

   # 4. mid
   _snake_case							:		Dict								=  self.mid_block(a_,				a_,				a_,				deterministic=not train		)

   # 5. contronet blocks
   _snake_case							:		Tuple								=  ()
   for down_block_res_sample, controlnet_block in zip(a_,				self.controlnet_down_blocks		):
     _snake_case							:		Any								=  controlnet_block(a_		)
     controlnet_down_block_res_samples += (down_block_res_sample,)

   _snake_case							:		List[Any]								=  controlnet_down_block_res_samples

   _snake_case							:		int								=  self.controlnet_mid_block(a_		)

   # 6. scaling
   _snake_case							:		int								=  [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=a_,				mid_block_res_sample=a_		)


