




import os
from typing import Any, Callable, Dict, List, Optional, Tuple, Union

import torch
from torch import nn

from ...models.controlnet import ControlNetModel, ControlNetOutput
from ...models.modeling_utils import ModelMixin
from ...utils import logging


a													=			logging.get_logger(__name__)




class       _A				(		__lowercase     ):






		def __init__(    self						,		_SCREAMING_SNAKE_CASE			):
								super().__init__()
								_UpperCAmelCase      =			nn.ModuleList(_SCREAMING_SNAKE_CASE			)






		def 				UpperCAmelCase (    self						,		_SCREAMING_SNAKE_CASE						,		_SCREAMING_SNAKE_CASE						,		_SCREAMING_SNAKE_CASE						,		_SCREAMING_SNAKE_CASE						,		_SCREAMING_SNAKE_CASE						,		_SCREAMING_SNAKE_CASE = None						,		_SCREAMING_SNAKE_CASE = None						,		_SCREAMING_SNAKE_CASE = None						,		_SCREAMING_SNAKE_CASE = None						,		_SCREAMING_SNAKE_CASE = False						,		_SCREAMING_SNAKE_CASE = True						,		):
								for i, (image, scale, controlnet) in enumerate(zip(_SCREAMING_SNAKE_CASE						,		_SCREAMING_SNAKE_CASE						,		self.nets			)			):
														_UpperCAmelCase    ,					_UpperCAmelCase      =			controlnet(
														    _SCREAMING_SNAKE_CASE						,		_SCREAMING_SNAKE_CASE						,		_SCREAMING_SNAKE_CASE						,		_SCREAMING_SNAKE_CASE						,		_SCREAMING_SNAKE_CASE						,		_SCREAMING_SNAKE_CASE						,		_SCREAMING_SNAKE_CASE						,		_SCREAMING_SNAKE_CASE						,		_SCREAMING_SNAKE_CASE						,		_SCREAMING_SNAKE_CASE						,		_SCREAMING_SNAKE_CASE						,		)

														# merge samples
														if i == 0:
																				_UpperCAmelCase    ,					_UpperCAmelCase      =			down_samples, mid_sample
														else:
																				_UpperCAmelCase      =			[
																				    samples_prev + samples_curr
																				    for samples_prev, samples_curr in zip(_SCREAMING_SNAKE_CASE						,		_SCREAMING_SNAKE_CASE			)
																				]
																				mid_block_res_sample += mid_sample

								return down_block_res_samples, mid_block_res_sample






		def 				UpperCAmelCase (    self						,		_SCREAMING_SNAKE_CASE						,		_SCREAMING_SNAKE_CASE = True						,		_SCREAMING_SNAKE_CASE = None						,		_SCREAMING_SNAKE_CASE = False						,		_SCREAMING_SNAKE_CASE = None						,		):
								_UpperCAmelCase      =			0
								_UpperCAmelCase      =			save_directory
								for controlnet in self.nets:
														controlnet.save_pretrained(
														    _SCREAMING_SNAKE_CASE						,		is_main_process=_SCREAMING_SNAKE_CASE						,		save_function=_SCREAMING_SNAKE_CASE						,		safe_serialization=_SCREAMING_SNAKE_CASE						,		variant=_SCREAMING_SNAKE_CASE						,		)

														idx += 1
														_UpperCAmelCase      =			model_path_to_save + F"_{idx}"






		@classmethod
		def 				UpperCAmelCase (    cls						,		_SCREAMING_SNAKE_CASE						,		**_SCREAMING_SNAKE_CASE			):
								_UpperCAmelCase      =			0
								_UpperCAmelCase      =			[]

								# load controlnet and append to list until no controlnet directory exists anymore
								# first controlnet has to be saved under `./mydirectory/controlnet` to be compliant with `DiffusionPipeline.from_prertained`
								# second, third, ... controlnets have to be saved under `./mydirectory/controlnet_1`, `./mydirectory/controlnet_2`, ...
								_UpperCAmelCase      =			pretrained_model_path
								while os.path.isdir(_SCREAMING_SNAKE_CASE			):
														_UpperCAmelCase      =			ControlNetModel.from_pretrained(_SCREAMING_SNAKE_CASE						,		**_SCREAMING_SNAKE_CASE			)
														controlnets.append(_SCREAMING_SNAKE_CASE			)

														idx += 1
														_UpperCAmelCase      =			pretrained_model_path + F"_{idx}"

								logger.info(F"{len(_SCREAMING_SNAKE_CASE			)} controlnets loaded from {pretrained_model_path}."			)

								if len(_SCREAMING_SNAKE_CASE			) == 0:
														raise ValueError(
														    F"No ControlNets found under {os.path.dirname(_SCREAMING_SNAKE_CASE			)}. Expected at least {pretrained_model_path + '_0'}."			)

								return cls(_SCREAMING_SNAKE_CASE			)





import os
import sys
import unittest


a													=			os.path.abspath(os.path.dirname(os.path.dirname(os.path.dirname(__file__))))
sys.path.append(os.path.join(git_repo_path, "utils"))

import check_dummies  # noqa: E402
from check_dummies import create_dummy_files, create_dummy_object, find_backend, read_init  # noqa: E402


# Align TRANSFORMERS_PATH in check_dummies with the current path
a													=			os.path.join(git_repo_path, "src", "transformers")

a													=			"\n{0} = None\n"

a													=			"\nclass {0}(metaclass=DummyObject):\n    _backends = {1}\n\n    def __init__(self, *args, **kwargs):\n        requires_backends(self, {1})\n"


a													=			"\ndef {0}(*args, **kwargs):\n    requires_backends({0}, {1})\n"




class       _A				(		unittest.TestCase     ):






		def 				UpperCAmelCase (    self			):
								_UpperCAmelCase      =			find_backend("""    _import_structure[\"models.albert\"].append(\"AlbertTokenizerFast\")"""			)
								self.assertIsNone(_SCREAMING_SNAKE_CASE			)

								_UpperCAmelCase      =			find_backend("""    if not is_tokenizers_available():"""			)
								self.assertEqual(_SCREAMING_SNAKE_CASE						,		"""tokenizers"""			)

								_UpperCAmelCase      =			find_backend("""    if not is_tensorflow_text_available():"""			)
								self.assertEqual(_SCREAMING_SNAKE_CASE						,		"""tensorflow_text"""			)

								_UpperCAmelCase      =			find_backend("""    if not (is_sentencepiece_available() and is_tokenizers_available()):"""			)
								self.assertEqual(_SCREAMING_SNAKE_CASE						,		"""sentencepiece_and_tokenizers"""			)

								_UpperCAmelCase      =			find_backend(
								    """    if not (is_sentencepiece_available() and is_tensorflow_text_available()):"""			)
								self.assertEqual(_SCREAMING_SNAKE_CASE						,		"""sentencepiece_and_tensorflow_text"""			)

								_UpperCAmelCase      =			find_backend(
								    """    if not (is_sentencepiece_available() and is_tokenizers_available() and is_vision_available()):"""			)
								self.assertEqual(_SCREAMING_SNAKE_CASE						,		"""sentencepiece_and_tokenizers_and_vision"""			)






		def 				UpperCAmelCase (    self			):
								_UpperCAmelCase      =			read_init()
								# We don't assert on the exact list of keys to allow for smooth grow of backend-specific objects
								self.assertIn("""torch"""						,		_SCREAMING_SNAKE_CASE			)
								self.assertIn("""tensorflow_text"""						,		_SCREAMING_SNAKE_CASE			)
								self.assertIn("""sentencepiece_and_tokenizers"""						,		_SCREAMING_SNAKE_CASE			)

								# Likewise, we can't assert on the exact content of a key
								self.assertIn("""BertModel"""						,		objects["""torch"""]			)
								self.assertIn("""TFBertModel"""						,		objects["""tf"""]			)
								self.assertIn("""FlaxBertModel"""						,		objects["""flax"""]			)
								self.assertIn("""BertModel"""						,		objects["""torch"""]			)
								self.assertIn("""TFBertTokenizer"""						,		objects["""tensorflow_text"""]			)
								self.assertIn("""convert_slow_tokenizer"""						,		objects["""sentencepiece_and_tokenizers"""]			)






		def 				UpperCAmelCase (    self			):
								_UpperCAmelCase      =			create_dummy_object("""CONSTANT"""						,		"""'torch'"""			)
								self.assertEqual(_SCREAMING_SNAKE_CASE						,		"""\nCONSTANT = None\n"""			)

								_UpperCAmelCase      =			create_dummy_object("""function"""						,		"""'torch'"""			)
								self.assertEqual(
								    _SCREAMING_SNAKE_CASE						,		"""\ndef function(*args, **kwargs):\n    requires_backends(function, 'torch')\n"""			)

								_UpperCAmelCase      =			"""
class FakeClass(metaclass=DummyObject):
    _backends = 'torch'

    def __init__(self, *args, **kwargs):
        requires_backends(self, 'torch')
"""
								_UpperCAmelCase      =			create_dummy_object("""FakeClass"""						,		"""'torch'"""			)
								self.assertEqual(_SCREAMING_SNAKE_CASE						,		_SCREAMING_SNAKE_CASE			)






		def 				UpperCAmelCase (    self			):
								_UpperCAmelCase      =			"""# This file is autogenerated by the command `make fix-copies`, do not edit.
from ..utils import DummyObject, requires_backends


CONSTANT = None


def function(*args, **kwargs):
    requires_backends(function, [\"torch\"])


class FakeClass(metaclass=DummyObject):
    _backends = [\"torch\"]

    def __init__(self, *args, **kwargs):
        requires_backends(self, [\"torch\"])
"""
								_UpperCAmelCase      =			create_dummy_files({"""torch""": ["""CONSTANT""", """function""", """FakeClass"""]}			)
								self.assertEqual(dummy_files["""torch"""]						,		_SCREAMING_SNAKE_CASE			)