





from typing import Optional

from torch import nn

from .transformer_ad import TransformeraDModel, TransformeraDModelOutput



class    _a     (				nn.Module							):






							"""simple docstring"""

							def __init__(      self				:     int							,	a				:     int = 16							,	a				:     int = 88							,	a				:     Optional[int] = None							,	a				:     int = 1							,	a				:     float = 0.0							,	a				:     int = 32							,	a				:     Optional[int] = None							,	a				:     bool = False							,	a				:     Optional[int] = None							,	a				:     Optional[int] = None							,	a				:     str = "geglu"							,	a				:     Optional[int] = None							,	)	->Optional[Any]:
													super().__init__()
													SCREAMING_SNAKE_CASE__     :				Dict   =					nn.ModuleList(
													    [
													        TransformeraDModel(
													            num_attention_heads=a							,	attention_head_dim=a							,	in_channels=a							,	num_layers=a							,	dropout=a							,	norm_num_groups=a							,	cross_attention_dim=a							,	attention_bias=a							,	sample_size=a							,	num_vector_embeds=a							,	activation_fn=a							,	num_embeds_ada_norm=a							,	)
													        for _ in range(2    )
													    ]    )

													# Variables that can be set by a pipeline:

													# The ratio of transformer1 to transformer2's output states to be combined during inference
													SCREAMING_SNAKE_CASE__     :				List[Any]   =					0.5

													# The shape of `encoder_hidden_states` is expected to be
													# `(batch_size, condition_lengths[0]+condition_lengths[1], num_features)`
													SCREAMING_SNAKE_CASE__     :				Optional[Any]   =					[77, 2_57]

													# Which transformer to use to encode which condition.
													# E.g. `(1, 0)` means that we'll use `transformers[1](conditions[0])` and `transformers[0](conditions[1])`
													SCREAMING_SNAKE_CASE__     :				Optional[Any]   =					[1, 0]






							def      A_  (      self				:     Dict							,	a				:     Optional[Any]							,	a				:     Union[str, Any]							,	a				:     int=None							,	a				:     Dict=None							,	a				:     Any=None							,	a				:     bool = True							,	)	->Tuple:
													SCREAMING_SNAKE_CASE__     :				List[str]   =					hidden_states

													SCREAMING_SNAKE_CASE__     :				str   =					[]
													SCREAMING_SNAKE_CASE__     :				List[str]   =					0
													# attention_mask is not used yet
													for i in range(2    ):
																			# for each of the two transformers, pass the corresponding condition tokens
																			SCREAMING_SNAKE_CASE__     :				str   =					encoder_hidden_states[:, tokens_start : tokens_start + self.condition_lengths[i]]
																			SCREAMING_SNAKE_CASE__     :				str   =					self.transformer_index_for_condition[i]
																			SCREAMING_SNAKE_CASE__     :				List[str]   =					self.transformers[transformer_index](
																			    a							,	encoder_hidden_states=a							,	timestep=a							,	cross_attention_kwargs=a							,	return_dict=a							,	)[0]
																			encoded_states.append(encoded_state - input_states    )
																			tokens_start += self.condition_lengths[i]

													SCREAMING_SNAKE_CASE__     :				str   =					encoded_states[0] * self.mix_ratio + encoded_states[1] * (1 - self.mix_ratio)
													SCREAMING_SNAKE_CASE__     :				str   =					output_states + input_states

													if not return_dict:
																			return (output_states,)

													return TransformeraDModelOutput(sample=a    )






# tests directory-specific settings - this file is run automatically
# by pytest before any tests are run

import doctest
import sys
import warnings
from os.path import abspath, dirname, join

import _pytest

from transformers.testing_utils import HfDoctestModule, HfDocTestParser


# allow having multiple repository checkouts and not needing to remember to rerun
# 'pip install -e .[dev]' when switching between checkouts and running tests.
__lowercase       :List[Any]       =  abspath(join(dirname(__file__), "src"))
sys.path.insert(1, git_repo_path)

# silence FutureWarning warnings in tests since often we can't act on them until
# they become normal warnings - i.e. the tests still need to test the current functionality
warnings.simplefilter(action="ignore", category=FutureWarning)







def       UpperCAmelCase							(     _lowerCamelCase      :  int     ):





						'''simple docstring'''


						config.addinivalue_line(
						    "markers"			,   "is_pt_tf_cross_test: mark test to run only when PT and TF interactions are tested"     )
						config.addinivalue_line(
						    "markers"			,   "is_pt_flax_cross_test: mark test to run only when PT and FLAX interactions are tested"     )
						config.addinivalue_line("markers"			,   "is_pipeline_test: mark test to run only when pipelines are tested"     )
						config.addinivalue_line("markers"			,   "is_staging_test: mark test to run only in the staging environment"     )
						config.addinivalue_line("markers"			,   "accelerate_tests: mark test that require accelerate"     )
						config.addinivalue_line("markers"			,   "tool_tests: mark the tool tests that are run on their specific schedule"     )







def       UpperCAmelCase							(     _lowerCamelCase      :  str     ):





						'''simple docstring'''


						from transformers.testing_utils import pytest_addoption_shared

						pytest_addoption_shared(_lowerCamelCase     )







def       UpperCAmelCase							(     _lowerCamelCase      :  Tuple     ):





						'''simple docstring'''


						from transformers.testing_utils import pytest_terminal_summary_main

						SCREAMING_SNAKE_CASE__     :				List[str]   =					terminalreporter.config.getoption("--make-reports"     )
						if make_reports:
												pytest_terminal_summary_main(_lowerCamelCase			,   id=_lowerCamelCase     )







def       UpperCAmelCase							(     _lowerCamelCase      :  List[Any]			,   _lowerCamelCase      :  Dict     ):





						'''simple docstring'''


						if exitstatus == 5:
												SCREAMING_SNAKE_CASE__     :				List[str]   =					0


# Doctest custom flag to ignore output.
__lowercase       :Optional[Any]       =  doctest.register_optionflag("IGNORE_RESULT")

__lowercase       :Dict       =  doctest.OutputChecker



class    _a     (				lowercase__							):






							"""simple docstring"""

							def      A_  (      self				:     Dict							,	a				:     List[str]							,	a				:     Dict							,	a				:     int    )	->Optional[Any]:
													if IGNORE_RESULT & optionflags:
																			return True
													return OutputChecker.check_output(self							,	a							,	a							,	a    )







__lowercase       :Any       =  CustomOutputChecker
__lowercase       :Any       =  HfDoctestModule



__lowercase       :int       =  HfDocTestParser