"""simple docstring"""



import unittest

from parameterized import parameterized

from transformers import LlamaConfig, is_torch_available, set_seed
from transformers.testing_utils import require_torch, slow, torch_device

from ...generation.test_utils import GenerationTesterMixin
from ...test_configuration_common import ConfigTester
from ...test_modeling_common import ModelTesterMixin, ids_tensor, random_attention_mask
from ...test_pipeline_mixin import PipelineTesterMixin


if is_torch_available():
   import torch

   from transformers import LlamaForCausalLM, LlamaForSequenceClassification, LlamaModel, LlamaTokenizer






class  snake_case__      :


 def __init__( self    ,		lowerCamelCase    ,		lowerCamelCase=13    ,		lowerCamelCase=7    ,		lowerCamelCase=True    ,		lowerCamelCase=True    ,		lowerCamelCase=False    ,		lowerCamelCase=True    ,		lowerCamelCase=99    ,		lowerCamelCase=32    ,		lowerCamelCase=5    ,		lowerCamelCase=4    ,		lowerCamelCase=37    ,		lowerCamelCase="gelu"    ,		lowerCamelCase=0.1    ,		lowerCamelCase=0.1    ,		lowerCamelCase=512    ,		lowerCamelCase=16    ,		lowerCamelCase=2    ,		lowerCamelCase=0.02    ,		lowerCamelCase=3    ,		lowerCamelCase=4    ,		lowerCamelCase=None    ,		):
        __a       =    parent
        __a       =    batch_size
        __a       =    seq_length
        __a       =    is_training
        __a       =    use_input_mask
        __a       =    use_token_type_ids
        __a       =    use_labels
        __a       =    vocab_size
        __a       =    hidden_size
        __a       =    num_hidden_layers
        __a       =    num_attention_heads
        __a       =    intermediate_size
        __a       =    hidden_act
        __a       =    hidden_dropout_prob
        __a       =    attention_probs_dropout_prob
        __a       =    max_position_embeddings
        __a       =    type_vocab_size
        __a       =    type_sequence_label_size
        __a       =    initializer_range
        __a       =    num_labels
        __a       =    num_choices
        __a       =    scope


 def 						a__   ( self						):
        __a       =    ids_tensor([self.batch_size, self.seq_length]    ,		self.vocab_size						)

        __a       =    None
        if self.use_input_mask:
               __a       =    random_attention_mask([self.batch_size, self.seq_length]						)

        __a       =    None
        if self.use_token_type_ids:
               __a       =    ids_tensor([self.batch_size, self.seq_length]    ,		self.type_vocab_size						)

        __a       =    None
        __a       =    None
        __a       =    None
        if self.use_labels:
               __a       =    ids_tensor([self.batch_size]    ,		self.type_sequence_label_size						)
               __a       =    ids_tensor([self.batch_size, self.seq_length]    ,		self.num_labels						)
               __a       =    ids_tensor([self.batch_size]    ,		self.num_choices						)

        __a       =    self.get_config()

        return config, input_ids, token_type_ids, input_mask, sequence_labels, token_labels, choice_labels


 def 						a__   ( self						):
        return LlamaConfig(
            vocab_size=self.vocab_size    ,		hidden_size=self.hidden_size    ,		num_hidden_layers=self.num_hidden_layers    ,		num_attention_heads=self.num_attention_heads    ,		intermediate_size=self.intermediate_size    ,		hidden_act=self.hidden_act    ,		hidden_dropout_prob=self.hidden_dropout_prob    ,		attention_probs_dropout_prob=self.attention_probs_dropout_prob    ,		max_position_embeddings=self.max_position_embeddings    ,		type_vocab_size=self.type_vocab_size    ,		is_decoder=lowerCamelCase    ,		initializer_range=self.initializer_range    ,		)


 def 						a__   ( self    ,		lowerCamelCase    ,		lowerCamelCase    ,		lowerCamelCase    ,		lowerCamelCase    ,		lowerCamelCase    ,		lowerCamelCase    ,		lowerCamelCase						):
        __a       =    LlamaModel(config=lowerCamelCase						)
        model.to(lowerCamelCase						)
        model.eval()
        __a       =    model(lowerCamelCase    ,		attention_mask=lowerCamelCase						)
        __a       =    model(lowerCamelCase						)
        self.parent.assertEqual(result.last_hidden_state.shape    ,		(self.batch_size, self.seq_length, self.hidden_size)						)


 def 						a__   ( self    ,		lowerCamelCase    ,		lowerCamelCase    ,		lowerCamelCase    ,		lowerCamelCase    ,		lowerCamelCase    ,		lowerCamelCase    ,		lowerCamelCase    ,		lowerCamelCase    ,		lowerCamelCase    ,		):
        __a       =    True
        __a       =    LlamaModel(lowerCamelCase						)
        model.to(lowerCamelCase						)
        model.eval()
        __a       =    model(
            lowerCamelCase    ,		attention_mask=lowerCamelCase    ,		encoder_hidden_states=lowerCamelCase    ,		encoder_attention_mask=lowerCamelCase    ,		)
        __a       =    model(
            lowerCamelCase    ,		attention_mask=lowerCamelCase    ,		encoder_hidden_states=lowerCamelCase    ,		)
        __a       =    model(lowerCamelCase    ,		attention_mask=lowerCamelCase						)
        self.parent.assertEqual(result.last_hidden_state.shape    ,		(self.batch_size, self.seq_length, self.hidden_size)						)


 def 						a__   ( self    ,		lowerCamelCase    ,		lowerCamelCase    ,		lowerCamelCase    ,		lowerCamelCase    ,		lowerCamelCase    ,		lowerCamelCase    ,		lowerCamelCase    ,		lowerCamelCase    ,		lowerCamelCase    ,		):
        __a       =    LlamaForCausalLM(config=lowerCamelCase						)
        model.to(lowerCamelCase						)
        model.eval()
        __a       =    model(lowerCamelCase    ,		attention_mask=lowerCamelCase    ,		labels=lowerCamelCase						)
        self.parent.assertEqual(result.logits.shape    ,		(self.batch_size, self.seq_length, self.vocab_size)						)


 def 						a__   ( self    ,		lowerCamelCase    ,		lowerCamelCase    ,		lowerCamelCase    ,		lowerCamelCase    ,		lowerCamelCase    ,		lowerCamelCase    ,		lowerCamelCase    ,		lowerCamelCase    ,		lowerCamelCase    ,		):
        __a       =    True
        __a       =    True
        __a       =    LlamaForCausalLM(config=lowerCamelCase						)
        model.to(lowerCamelCase						)
        model.eval()

        # first forward pass
        __a       =    model(
            lowerCamelCase    ,		attention_mask=lowerCamelCase    ,		encoder_hidden_states=lowerCamelCase    ,		encoder_attention_mask=lowerCamelCase    ,		use_cache=lowerCamelCase    ,		)
        __a       =    outputs.past_key_values

        # create hypothetical multiple next token and extent to next_input_ids
        __a       =    ids_tensor((self.batch_size, 3)    ,		config.vocab_size						)
        __a       =    ids_tensor((self.batch_size, 3)    ,		vocab_size=2						)

        # append to next input_ids and
        __a       =    torch.cat([input_ids, next_tokens]    ,		dim=-1						)
        __a       =    torch.cat([input_mask, next_mask]    ,		dim=-1						)

        __a       =    model(
            lowerCamelCase    ,		attention_mask=lowerCamelCase    ,		encoder_hidden_states=lowerCamelCase    ,		encoder_attention_mask=lowerCamelCase    ,		output_hidden_states=lowerCamelCase    ,		)["hidden_states"][0]
        __a       =    model(
            lowerCamelCase    ,		attention_mask=lowerCamelCase    ,		encoder_hidden_states=lowerCamelCase    ,		encoder_attention_mask=lowerCamelCase    ,		past_key_values=lowerCamelCase    ,		output_hidden_states=lowerCamelCase    ,		)["hidden_states"][0]

        # select random slice
        __a       =    ids_tensor((1,)    ,		output_from_past.shape[-1]						).item()
        __a       =    output_from_no_past[:, -3:, random_slice_idx].detach()
        __a       =    output_from_past[:, :, random_slice_idx].detach()

        self.parent.assertTrue(output_from_past_slice.shape[1] == next_tokens.shape[1]						)

        # test that outputs are equal for slice
        self.parent.assertTrue(torch.allclose(lowerCamelCase    ,		lowerCamelCase    ,		atol=1E-3						)						)






 def 						a__   ( self						):
        __a       =    self.prepare_config_and_inputs()
        (
            (
            __a
        ) ,   (
            __a
        ) ,   (
            __a
        ) ,   (
            __a
        ) ,   (
            __a
        ) ,   (
            __a
        ) ,   (
            __a
        ) ,   
        )       =    config_and_inputs
        __a       =    {"input_ids": input_ids, "attention_mask": input_mask}
        return config, inputs_dict






@require_torch
class  snake_case__      (       snake_case_,						snake_case_,						snake_case_,						unittest.TestCase       ):
 _snake_case       :					Union[str, Any]							  =						(LlamaModel, LlamaForCausalLM, LlamaForSequenceClassification) if is_torch_available() else ()
 _snake_case       :					Tuple							  =						(LlamaForCausalLM,) if is_torch_available() else ()
 _snake_case       :					Tuple							  =						(
     {
         """feature-extraction""": LlamaModel,
         """text-classification""": LlamaForSequenceClassification,
         """text-generation""": LlamaForCausalLM,
         """zero-shot""": LlamaForSequenceClassification,
     }
     if is_torch_available()
     else {}
 )
 _snake_case       :					Union[str, Any]							  =						False
 _snake_case       :					Tuple							  =						False


 def 						a__   ( self						):
        __a       =    LlamaModelTester(self						)
        __a       =    ConfigTester(self    ,		config_class=lowerCamelCase    ,		hidden_size=37						)


 def 						a__   ( self						):
        self.config_tester.run_common_tests()


 def 						a__   ( self						):
        __a       =    self.model_tester.prepare_config_and_inputs()
        self.model_tester.create_and_check_model(*lowerCamelCase						)


 def 						a__   ( self						):
        __a       =    self.model_tester.prepare_config_and_inputs()
        for type in ["absolute", "relative_key", "relative_key_query"]:
               __a       =    type
               self.model_tester.create_and_check_model(*lowerCamelCase						)


 def 						a__   ( self						):
        __a ,   __a       =    self.model_tester.prepare_config_and_inputs_for_common()
        __a       =    3
        __a       =    input_dict["input_ids"]
        __a       =    input_ids.ne(1						).to(lowerCamelCase						)
        __a       =    ids_tensor([self.model_tester.batch_size]    ,		self.model_tester.type_sequence_label_size						)
        __a       =    LlamaForSequenceClassification(lowerCamelCase						)
        model.to(lowerCamelCase						)
        model.eval()
        __a       =    model(lowerCamelCase    ,		attention_mask=lowerCamelCase    ,		labels=lowerCamelCase						)
        self.assertEqual(result.logits.shape    ,		(self.model_tester.batch_size, self.model_tester.num_labels)						)


 def 						a__   ( self						):
        __a ,   __a       =    self.model_tester.prepare_config_and_inputs_for_common()
        __a       =    3
        __a       =    "single_label_classification"
        __a       =    input_dict["input_ids"]
        __a       =    input_ids.ne(1						).to(lowerCamelCase						)
        __a       =    ids_tensor([self.model_tester.batch_size]    ,		self.model_tester.type_sequence_label_size						)
        __a       =    LlamaForSequenceClassification(lowerCamelCase						)
        model.to(lowerCamelCase						)
        model.eval()
        __a       =    model(lowerCamelCase    ,		attention_mask=lowerCamelCase    ,		labels=lowerCamelCase						)
        self.assertEqual(result.logits.shape    ,		(self.model_tester.batch_size, self.model_tester.num_labels)						)


 def 						a__   ( self						):
        __a ,   __a       =    self.model_tester.prepare_config_and_inputs_for_common()
        __a       =    3
        __a       =    "multi_label_classification"
        __a       =    input_dict["input_ids"]
        __a       =    input_ids.ne(1						).to(lowerCamelCase						)
        __a       =    ids_tensor(
            [self.model_tester.batch_size, config.num_labels]    ,		self.model_tester.type_sequence_label_size						).to(torch.float						)
        __a       =    LlamaForSequenceClassification(lowerCamelCase						)
        model.to(lowerCamelCase						)
        model.eval()
        __a       =    model(lowerCamelCase    ,		attention_mask=lowerCamelCase    ,		labels=lowerCamelCase						)
        self.assertEqual(result.logits.shape    ,		(self.model_tester.batch_size, self.model_tester.num_labels)						)


 @unittest.skip("LLaMA buffers include complex numbers, which breaks this test"						)
 def 						a__   ( self						):
        pass






 @parameterized.expand([("linear",), ("dynamic",)]						)
 def 						a__   ( self    ,		lowerCamelCase						):
        __a ,   __a       =    self.model_tester.prepare_config_and_inputs_for_common()
        __a       =    ids_tensor([1, 10]    ,		config.vocab_size						)
        __a       =    ids_tensor([1, int(config.max_position_embeddings * 1.5						)]    ,		config.vocab_size						)

        set_seed(42						)  # Fixed seed at init time so the two models get the same random weights
        __a       =    LlamaModel(lowerCamelCase						)
        original_model.to(lowerCamelCase						)
        original_model.eval()
        __a       =    original_model(lowerCamelCase						).last_hidden_state
        __a       =    original_model(lowerCamelCase						).last_hidden_state

        set_seed(42						)  # Fixed seed at init time so the two models get the same random weights
        __a       =    {"type": scaling_type, "factor": 10.0}
        __a       =    LlamaModel(lowerCamelCase						)
        scaled_model.to(lowerCamelCase						)
        scaled_model.eval()
        __a       =    scaled_model(lowerCamelCase						).last_hidden_state
        __a       =    scaled_model(lowerCamelCase						).last_hidden_state

        # Dynamic scaling does not change the RoPE embeddings until it receives an input longer than the original
        # maximum sequence length, so the outputs for the short input should match.
        if scaling_type == "dynamic":
               self.assertTrue(torch.allclose(lowerCamelCase    ,		lowerCamelCase    ,		atol=1E-5						)						)
        else:
               self.assertFalse(torch.allclose(lowerCamelCase    ,		lowerCamelCase    ,		atol=1E-5						)						)

        # The output should be different for long inputs
        self.assertFalse(torch.allclose(lowerCamelCase    ,		lowerCamelCase    ,		atol=1E-5						)						)






@require_torch
class  snake_case__      (       unittest.TestCase       ):


 @unittest.skip("Logits are not exactly the same, once we fix the instabalities somehow, will update!"						)
 @slow
 def 						a__   ( self						):
        __a       =    [1, 306, 4658, 278, 6593, 310, 2834, 338]
        __a       =    LlamaForCausalLM.from_pretrained("meta-llama/Llama-2-7b-hf"    ,		device_map="auto"						)
        __a       =    model(torch.tensor([input_ids]						)						)
        # Expected mean on dim = -1
        __a       =    torch.tensor([[-6.6550, -4.1227, -4.9859, -3.2406, 0.8262, -3.0033, 1.2964, -3.3699]]						)
        torch.testing.assert_close(out.mean(-1						)    ,		lowerCamelCase    ,		atol=1E-2    ,		rtol=1E-2						)
        # slicing logits[0, 0, 0:30]
        # fmt: off
        __a       =    torch.tensor([-12.8281, -7.4453, -0.4639, -8.0625, -7.2500, -8.0000, -6.4883, -7.7695, -7.8438, -7.0312, -6.2188, -7.1328, -1.8496, 1.9961, -8.6250, -6.7227, -12.8281, -6.9492, -7.0742, -7.7852, -7.5820, -7.9062, -6.9375, -7.9805, -8.3438, -8.1562, -8.0469, -7.6250, -7.7422, -7.3398,]						)
        # fmt: on
        torch.testing.assert_close(out[0, 0, :30]    ,		lowerCamelCase    ,		atol=1E-5    ,		rtol=1E-5						)


 @unittest.skip("Logits are not exactly the same, once we fix the instabalities somehow, will update!"						)
 @slow
 def 						a__   ( self						):
        __a       =    [1, 306, 4658, 278, 6593, 310, 2834, 338]
        __a       =    LlamaForCausalLM.from_pretrained("meta-llama/Llama-2-13b-hf"    ,		device_map="auto"						)
        __a       =    model(torch.tensor(lowerCamelCase						)						)
        # Expected mean on dim = -1
        __a       =    torch.tensor([[-2.0622, -1.2794, -1.1638, -0.9788, -1.4603, -1.0238, -1.7893, -1.4411]]						)
        torch.testing.assert_close(out.mean(-1						)    ,		lowerCamelCase    ,		atol=1E-2    ,		rtol=1E-2						)
        # slicing logits[0, 0, 0:30]
        # fmt: off
        __a       =    torch.tensor([-8.1406, -8.0547, 2.7461, -1.2344, -0.1448, -1.8262, -1.0020, -1.8154, -1.6895, -1.8516, -2.3574, -0.9277, 3.7598, 6.5742, -1.2998, -0.1177, -8.1406, -2.9688, -2.9199, -3.1699, -3.5254, -2.3555, -2.7988, -3.4141, -2.8262, -4.5195, -3.3379, -3.3164, -2.7832, -3.0273]						)
        # fmt: on
        torch.testing.assert_close(out[0, 0, :30]    ,		lowerCamelCase    ,		atol=1E-5    ,		rtol=1E-5						)


 @unittest.skip("Logits are not exactly the same, once we fix the instabalities somehow, will update!"						)
 @slow
 def 						a__   ( self						):
        __a       =    [1, 306, 4658, 278, 6593, 310, 2834, 338]
        __a       =    LlamaForCausalLM.from_pretrained("meta-llama/Llama-2-13b-chat-hf"    ,		device_map="auto"						)
        __a       =    model(torch.tensor(lowerCamelCase						)						)
        # Expected mean on dim = -1
        __a       =    torch.tensor([[-0.8562, -1.8520, -0.7551, -0.4162, -1.5161, -1.2038, -2.4823, -2.3254]]						)
        torch.testing.assert_close(out.mean(-1						)    ,		lowerCamelCase    ,		atol=1E-2    ,		rtol=1E-2						)
        # slicing logits[0, 0, 0:30]
        # fmt: off
        __a       =    torch.tensor([-2.2227, 4.8828, 0.9023, -0.4578, -0.7871, -0.1033, -0.6221, -0.5786, -0.7803, -1.0674, -1.2920, -0.1570, 0.8008, 2.0723, -0.9497, 0.2771, -2.2227, -0.7612, -1.4346, -1.2061, -1.6426, -0.3000, -0.7139, -1.1934, -1.8691, -1.6973, -1.5947, -1.2705, -0.3523, -0.5513]						)
        # fmt: on
        torch.testing.assert_close(out.mean(-1						)    ,		lowerCamelCase    ,		atol=1E-2    ,		rtol=1E-2						)


 @unittest.skip(
     "Logits are not exactly the same, once we fix the instabalities somehow, will update! Also it is gonna be a `too_slow` test"						)
 @slow
 def 						a__   ( self						):
        __a       =    [1, 306, 4658, 278, 6593, 310, 2834, 338]
        __a       =    LlamaForCausalLM.from_pretrained("meta-llama/Llama-2-70b-hf"    ,		device_map="auto"						)
        __a       =    model(torch.tensor(lowerCamelCase						)						)

        __a       =    torch.tensor(
            [[-4.2327, -3.3360, -4.6665, -4.7631, -1.8180, -3.4170, -1.4211, -3.1810]]    ,		dtype=torch.floataa						)
        torch.testing.assert_close(out.mean(-1						)    ,		lowerCamelCase    ,		atol=1E-2    ,		rtol=1E-2						)
        # fmt: off
        __a       =    torch.tensor([-9.4922, -3.9551, 1.7998, -5.6758, -5.1055, -5.8984, -4.8320, -6.8086, -6.5391, -5.6172, -5.5820, -5.5352, 1.7881, 3.6289, -6.5117, -3.4785, -9.5000, -6.0352, -6.8125, -6.0195, -6.6836, -5.4727, -6.2812, -6.0391, -7.3398, -7.4297, -7.4844, -6.5820, -5.8789, -5.5312]						)
        # fmt: on
        torch.testing.assert_close(out[0, 0, :30]    ,		lowerCamelCase    ,		atol=1E-5    ,		rtol=1E-5						)






 @unittest.skip("Model is curently gated"						)
 @slow
 def 						a__   ( self						):
        __a       =    "Simply put, the theory of relativity states that 1) the laws of physics are the same everywhere in the universe and 2) the passage of time and the length of objects can vary depending on the observer\'s frame of reference.\n\nThe first part of the theory, that the laws of physics are the same everywhere, is known as the \"princi"
        __a       =    "Simply put, the theory of relativity states that "
        __a       =    LlamaTokenizer.from_pretrained("meta-llama/Llama-2-13b-chat-hf"						)
        __a       =    tokenizer.encode(lowerCamelCase    ,		return_tensors="pt"						)
        __a       =    LlamaForCausalLM.from_pretrained(
            "meta-llama/Llama-2-13b-chat-hf"    ,		device_map="sequential"    ,		use_safetensors=lowerCamelCase						)

        # greedy generation outputs
        __a       =    model.generate(lowerCamelCase    ,		max_new_tokens=64    ,		top_p=lowerCamelCase    ,		temperature=1    ,		do_sample=lowerCamelCase						)
        __a       =    tokenizer.decode(generated_ids[0]    ,		skip_special_tokens=lowerCamelCase						)
        self.assertEqual(lowerCamelCase    ,		lowerCamelCase						)

"""simple docstring"""



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


SCREAMING_SNAKE_CASE__:Optional[Any]									=			logging.get_logger(__name__)






class  snake_case__      (       snake_case_       ):


 def __init__( self    ,		lowerCamelCase						):
        super().__init__()
        __a       =    nn.ModuleList(lowerCamelCase						)


 def 						a__   ( self    ,		lowerCamelCase    ,		lowerCamelCase    ,		lowerCamelCase    ,		lowerCamelCase    ,		lowerCamelCase    ,		lowerCamelCase = None    ,		lowerCamelCase = None    ,		lowerCamelCase = None    ,		lowerCamelCase = None    ,		lowerCamelCase = False    ,		lowerCamelCase = True    ,		):
        for i, (image, scale, controlnet) in enumerate(zip(lowerCamelCase    ,		lowerCamelCase    ,		self.nets						)						):
               __a ,   __a       =    controlnet(
                   lowerCamelCase    ,		lowerCamelCase    ,		lowerCamelCase    ,		lowerCamelCase    ,		lowerCamelCase    ,		lowerCamelCase    ,		lowerCamelCase    ,		lowerCamelCase    ,		lowerCamelCase    ,		lowerCamelCase    ,		lowerCamelCase    ,		)

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

        return down_block_res_samples, mid_block_res_sample


 def 						a__   ( self    ,		lowerCamelCase    ,		lowerCamelCase = True    ,		lowerCamelCase = None    ,		lowerCamelCase = False    ,		lowerCamelCase = None    ,		):
        __a       =    0
        __a       =    save_directory
        for controlnet in self.nets:
               controlnet.save_pretrained(
                   lowerCamelCase    ,		is_main_process=lowerCamelCase    ,		save_function=lowerCamelCase    ,		safe_serialization=lowerCamelCase    ,		variant=lowerCamelCase    ,		)

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






 @classmethod
 def 						a__   ( cls    ,		lowerCamelCase    ,		**lowerCamelCase						):
        __a       =    0
        __a       =    []

        # 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`, ...
        __a       =    pretrained_model_path
        while os.path.isdir(lowerCamelCase						):
               __a       =    ControlNetModel.from_pretrained(lowerCamelCase    ,		**lowerCamelCase						)
               controlnets.append(lowerCamelCase						)

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

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

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

        return cls(lowerCamelCase						)
