




from collections import deque
from math import floor
from random import random
from time import time




class 			UpperCAmelCase_      :




							'''simple docstring'''



							def __init__(					self       :	Dict			)			->					Dict:
										SCREAMING_SNAKE_CASE           =					{}





							def    _UpperCAmelCase     (					self       :	Any       ,     a       :	str       ,     a       :	Dict       ,     a       :	Optional[Any]=1			)			->					str:
										if self.graph.get(a			):
													if self.graph[u].count([w, v]			) == 0:
																self.graph[u].append([w, v]			)
										else:
													SCREAMING_SNAKE_CASE           =					[[w, v]]
										if not self.graph.get(a			):
													SCREAMING_SNAKE_CASE           =					[]





							def    _UpperCAmelCase     (					self       :	Tuple			)			->					Any:
										return list(self.graph			)





							def    _UpperCAmelCase     (					self       :	Any       ,     a       :	Optional[Any]       ,     a       :	Tuple			)			->					Any:
										if self.graph.get(a			):
													for _ in self.graph[u]:
																if _[1] == v:
																			self.graph[u].remove(a			)





							def    _UpperCAmelCase     (					self       :	List[Any]       ,     a       :	Any=-2       ,     a       :	str=-1			)			->					Any:
										if s == d:
													return []
										SCREAMING_SNAKE_CASE           =					[]
										SCREAMING_SNAKE_CASE           =					[]
										if s == -2:
													SCREAMING_SNAKE_CASE           =					list(self.graph			)[0]
										stack.append(a			)
										visited.append(a			)
										SCREAMING_SNAKE_CASE           =					s

										while True:
													# check if there is any non isolated nodes
													if len(self.graph[s]			) != 0:
																SCREAMING_SNAKE_CASE           =					s
																for node in self.graph[s]:
																			if visited.count(node[1]			) < 1:
																						if node[1] == d:
																									visited.append(a			)
																									return visited
																						else:
																									stack.append(node[1]			)
																									visited.append(node[1]			)
																									SCREAMING_SNAKE_CASE           =					node[1]
																									break

            # check if all the children are visited
													if s == ss:
																stack.pop()
																if len(a			) != 0:
																			SCREAMING_SNAKE_CASE           =					stack[len(a			) - 1]
													else:
																SCREAMING_SNAKE_CASE           =					ss

													# check if se have reached the starting point
													if len(a			) == 0:
																return visited





							def    _UpperCAmelCase     (					self       :	Optional[Any]       ,     a       :	Union[str, Any]=-1			)			->					Tuple:
										if c == -1:
													SCREAMING_SNAKE_CASE           =					floor(random() * 10_000			) + 10
										for i in range(a			):
													# every vertex has max 100 edges
													for _ in range(floor(random() * 102			) + 1			):
																SCREAMING_SNAKE_CASE           =					floor(random() * c			) + 1
																if n != i:
																			self.add_pair(a       ,     a       ,     1			)





							def    _UpperCAmelCase     (					self       :	Union[str, Any]       ,     a       :	int=-2			)			->					Optional[Any]:
										SCREAMING_SNAKE_CASE           =					deque()
										SCREAMING_SNAKE_CASE           =					[]
										if s == -2:
													SCREAMING_SNAKE_CASE           =					list(self.graph			)[0]
										d.append(a			)
										visited.append(a			)
										while d:
													SCREAMING_SNAKE_CASE           =					d.popleft()
													if len(self.graph[s]			) != 0:
																for node in self.graph[s]:
																			if visited.count(node[1]			) < 1:
																						d.append(node[1]			)
																						visited.append(node[1]			)
										return visited





							def    _UpperCAmelCase     (					self       :	Optional[int]       ,     a       :	List[str]			)			->					Optional[Any]:
										SCREAMING_SNAKE_CASE           =					0
										for x in self.graph:
													for y in self.graph[x]:
																if y[1] == u:
																			count += 1
										return count





							def    _UpperCAmelCase     (					self       :	Any       ,     a       :	Any			)			->					Dict:
										return len(self.graph[u]			)





							def    _UpperCAmelCase     (					self       :	Any       ,     a       :	Tuple=-2			)			->					Optional[int]:
										SCREAMING_SNAKE_CASE           =					[]
										SCREAMING_SNAKE_CASE           =					[]
										if s == -2:
													SCREAMING_SNAKE_CASE           =					list(self.graph			)[0]
										stack.append(a			)
										visited.append(a			)
										SCREAMING_SNAKE_CASE           =					s
										SCREAMING_SNAKE_CASE           =					[]

										while True:
													# check if there is any non isolated nodes
													if len(self.graph[s]			) != 0:
																SCREAMING_SNAKE_CASE           =					s
																for node in self.graph[s]:
																			if visited.count(node[1]			) < 1:
																						stack.append(node[1]			)
																						visited.append(node[1]			)
																						SCREAMING_SNAKE_CASE           =					node[1]
																						break

            # check if all the children are visited
													if s == ss:
																sorted_nodes.append(stack.pop()			)
																if len(a			) != 0:
																			SCREAMING_SNAKE_CASE           =					stack[len(a			) - 1]
													else:
																SCREAMING_SNAKE_CASE           =					ss

													# check if se have reached the starting point
													if len(a			) == 0:
																return sorted_nodes





							def    _UpperCAmelCase     (					self       :	Optional[Any]			)			->					Any:
										SCREAMING_SNAKE_CASE           =					[]
										SCREAMING_SNAKE_CASE           =					[]
										SCREAMING_SNAKE_CASE           =					list(self.graph			)[0]
										stack.append(a			)
										visited.append(a			)
										SCREAMING_SNAKE_CASE           =					-2
										SCREAMING_SNAKE_CASE           =					[]
										SCREAMING_SNAKE_CASE           =					s
										SCREAMING_SNAKE_CASE           =					False
										SCREAMING_SNAKE_CASE           =					set()

										while True:
													# check if there is any non isolated nodes
													if len(self.graph[s]			) != 0:
																SCREAMING_SNAKE_CASE           =					s
																for node in self.graph[s]:
																			if (
																			    visited.count(node[1]			) > 0
																			    and node[1] != parent
																			    and indirect_parents.count(node[1]			) > 0
																			    and not on_the_way_back
																			):
																						SCREAMING_SNAKE_CASE           =					len(a			) - 1
																						while len_stack >= 0:
																									if stack[len_stack] == node[1]:
																												anticipating_nodes.add(node[1]			)
																												break
																									else:
																												anticipating_nodes.add(stack[len_stack]			)
																												len_stack -= 1
																			if visited.count(node[1]			) < 1:
																						stack.append(node[1]			)
																						visited.append(node[1]			)
																						SCREAMING_SNAKE_CASE           =					node[1]
																						break

            # check if all the children are visited
													if s == ss:
																stack.pop()
																SCREAMING_SNAKE_CASE           =					True
																if len(a			) != 0:
																			SCREAMING_SNAKE_CASE           =					stack[len(a			) - 1]
													else:
																SCREAMING_SNAKE_CASE           =					False
																indirect_parents.append(a			)
																SCREAMING_SNAKE_CASE           =					s
																SCREAMING_SNAKE_CASE           =					ss

													# check if se have reached the starting point
													if len(a			) == 0:
																return list(a			)





							def    _UpperCAmelCase     (					self       :	Dict			)			->					Optional[int]:
										SCREAMING_SNAKE_CASE           =					[]
										SCREAMING_SNAKE_CASE           =					[]
										SCREAMING_SNAKE_CASE           =					list(self.graph			)[0]
										stack.append(a			)
										visited.append(a			)
										SCREAMING_SNAKE_CASE           =					-2
										SCREAMING_SNAKE_CASE           =					[]
										SCREAMING_SNAKE_CASE           =					s
										SCREAMING_SNAKE_CASE           =					False
										SCREAMING_SNAKE_CASE           =					set()

										while True:
													# check if there is any non isolated nodes
													if len(self.graph[s]			) != 0:
																SCREAMING_SNAKE_CASE           =					s
																for node in self.graph[s]:
																			if (
																			    visited.count(node[1]			) > 0
																			    and node[1] != parent
																			    and indirect_parents.count(node[1]			) > 0
																			    and not on_the_way_back
																			):
																						SCREAMING_SNAKE_CASE           =					len(a			) - 1
																						while len_stack_minus_one >= 0:
																									if stack[len_stack_minus_one] == node[1]:
																												anticipating_nodes.add(node[1]			)
																												break
																									else:
																												return True
																			if visited.count(node[1]			) < 1:
																						stack.append(node[1]			)
																						visited.append(node[1]			)
																						SCREAMING_SNAKE_CASE           =					node[1]
																						break

            # check if all the children are visited
													if s == ss:
																stack.pop()
																SCREAMING_SNAKE_CASE           =					True
																if len(a			) != 0:
																			SCREAMING_SNAKE_CASE           =					stack[len(a			) - 1]
													else:
																SCREAMING_SNAKE_CASE           =					False
																indirect_parents.append(a			)
																SCREAMING_SNAKE_CASE           =					s
																SCREAMING_SNAKE_CASE           =					ss

													# check if se have reached the starting point
													if len(a			) == 0:
																return False





							def    _UpperCAmelCase     (					self       :	Optional[Any]       ,     a       :	Union[str, Any]=-2       ,     a       :	Tuple=-1			)			->					Tuple:
										SCREAMING_SNAKE_CASE           =					time()
										self.dfs(a       ,     a			)
										SCREAMING_SNAKE_CASE           =					time()
										return end - begin







							def    _UpperCAmelCase     (					self       :	List[str]       ,     a       :	List[str]=-2			)			->					Tuple:
										SCREAMING_SNAKE_CASE           =					time()
										self.bfs(a			)
										SCREAMING_SNAKE_CASE           =					time()
										return end - begin





class 			UpperCAmelCase_      :




							'''simple docstring'''



							def __init__(					self       :	Optional[Any]			)			->					Tuple:
										SCREAMING_SNAKE_CASE           =					{}





							def    _UpperCAmelCase     (					self       :	str       ,     a       :	Union[str, Any]       ,     a       :	Optional[int]       ,     a       :	Dict=1			)			->					Tuple:
										# check if the u exists
										if self.graph.get(a			):
													# if there already is a edge
													if self.graph[u].count([w, v]			) == 0:
																self.graph[u].append([w, v]			)
										else:
													# if u does not exist
													SCREAMING_SNAKE_CASE           =					[[w, v]]
										# add the other way
										if self.graph.get(a			):
													# if there already is a edge
													if self.graph[v].count([w, u]			) == 0:
																self.graph[v].append([w, u]			)
										else:
													# if u does not exist
													SCREAMING_SNAKE_CASE           =					[[w, u]]





							def    _UpperCAmelCase     (					self       :	Any       ,     a       :	Any       ,     a       :	Any			)			->					List[str]:
										if self.graph.get(a			):
													for _ in self.graph[u]:
																if _[1] == v:
																			self.graph[u].remove(a			)
        # the other way round
										if self.graph.get(a			):
													for _ in self.graph[v]:
																if _[1] == u:
																			self.graph[v].remove(a			)





							def    _UpperCAmelCase     (					self       :	List[Any]       ,     a       :	Any=-2       ,     a       :	str=-1			)			->					str:
										if s == d:
													return []
										SCREAMING_SNAKE_CASE           =					[]
										SCREAMING_SNAKE_CASE           =					[]
										if s == -2:
													SCREAMING_SNAKE_CASE           =					list(self.graph			)[0]
										stack.append(a			)
										visited.append(a			)
										SCREAMING_SNAKE_CASE           =					s

										while True:
													# check if there is any non isolated nodes
													if len(self.graph[s]			) != 0:
																SCREAMING_SNAKE_CASE           =					s
																for node in self.graph[s]:
																			if visited.count(node[1]			) < 1:
																						if node[1] == d:
																									visited.append(a			)
																									return visited
																						else:
																									stack.append(node[1]			)
																									visited.append(node[1]			)
																									SCREAMING_SNAKE_CASE           =					node[1]
																									break

            # check if all the children are visited
													if s == ss:
																stack.pop()
																if len(a			) != 0:
																			SCREAMING_SNAKE_CASE           =					stack[len(a			) - 1]
													else:
																SCREAMING_SNAKE_CASE           =					ss

													# check if se have reached the starting point
													if len(a			) == 0:
																return visited





							def    _UpperCAmelCase     (					self       :	Dict       ,     a       :	Dict=-1			)			->					str:
										if c == -1:
													SCREAMING_SNAKE_CASE           =					floor(random() * 10_000			) + 10
										for i in range(a			):
													# every vertex has max 100 edges
													for _ in range(floor(random() * 102			) + 1			):
																SCREAMING_SNAKE_CASE           =					floor(random() * c			) + 1
																if n != i:
																			self.add_pair(a       ,     a       ,     1			)





							def    _UpperCAmelCase     (					self       :	Union[str, Any]       ,     a       :	Tuple=-2			)			->					Union[str, Any]:
										SCREAMING_SNAKE_CASE           =					deque()
										SCREAMING_SNAKE_CASE           =					[]
										if s == -2:
													SCREAMING_SNAKE_CASE           =					list(self.graph			)[0]
										d.append(a			)
										visited.append(a			)
										while d:
													SCREAMING_SNAKE_CASE           =					d.popleft()
													if len(self.graph[s]			) != 0:
																for node in self.graph[s]:
																			if visited.count(node[1]			) < 1:
																						d.append(node[1]			)
																						visited.append(node[1]			)
										return visited





							def    _UpperCAmelCase     (					self       :	Dict       ,     a       :	Dict			)			->					List[str]:
										return len(self.graph[u]			)





							def    _UpperCAmelCase     (					self       :	Union[str, Any]			)			->					List[str]:
										SCREAMING_SNAKE_CASE           =					[]
										SCREAMING_SNAKE_CASE           =					[]
										SCREAMING_SNAKE_CASE           =					list(self.graph			)[0]
										stack.append(a			)
										visited.append(a			)
										SCREAMING_SNAKE_CASE           =					-2
										SCREAMING_SNAKE_CASE           =					[]
										SCREAMING_SNAKE_CASE           =					s
										SCREAMING_SNAKE_CASE           =					False
										SCREAMING_SNAKE_CASE           =					set()

										while True:
													# check if there is any non isolated nodes
													if len(self.graph[s]			) != 0:
																SCREAMING_SNAKE_CASE           =					s
																for node in self.graph[s]:
																			if (
																			    visited.count(node[1]			) > 0
																			    and node[1] != parent
																			    and indirect_parents.count(node[1]			) > 0
																			    and not on_the_way_back
																			):
																						SCREAMING_SNAKE_CASE           =					len(a			) - 1
																						while len_stack >= 0:
																									if stack[len_stack] == node[1]:
																												anticipating_nodes.add(node[1]			)
																												break
																									else:
																												anticipating_nodes.add(stack[len_stack]			)
																												len_stack -= 1
																			if visited.count(node[1]			) < 1:
																						stack.append(node[1]			)
																						visited.append(node[1]			)
																						SCREAMING_SNAKE_CASE           =					node[1]
																						break

            # check if all the children are visited
													if s == ss:
																stack.pop()
																SCREAMING_SNAKE_CASE           =					True
																if len(a			) != 0:
																			SCREAMING_SNAKE_CASE           =					stack[len(a			) - 1]
													else:
																SCREAMING_SNAKE_CASE           =					False
																indirect_parents.append(a			)
																SCREAMING_SNAKE_CASE           =					s
																SCREAMING_SNAKE_CASE           =					ss

													# check if se have reached the starting point
													if len(a			) == 0:
																return list(a			)





							def    _UpperCAmelCase     (					self       :	Optional[Any]			)			->					Optional[int]:
										SCREAMING_SNAKE_CASE           =					[]
										SCREAMING_SNAKE_CASE           =					[]
										SCREAMING_SNAKE_CASE           =					list(self.graph			)[0]
										stack.append(a			)
										visited.append(a			)
										SCREAMING_SNAKE_CASE           =					-2
										SCREAMING_SNAKE_CASE           =					[]
										SCREAMING_SNAKE_CASE           =					s
										SCREAMING_SNAKE_CASE           =					False
										SCREAMING_SNAKE_CASE           =					set()

										while True:
													# check if there is any non isolated nodes
													if len(self.graph[s]			) != 0:
																SCREAMING_SNAKE_CASE           =					s
																for node in self.graph[s]:
																			if (
																			    visited.count(node[1]			) > 0
																			    and node[1] != parent
																			    and indirect_parents.count(node[1]			) > 0
																			    and not on_the_way_back
																			):
																						SCREAMING_SNAKE_CASE           =					len(a			) - 1
																						while len_stack_minus_one >= 0:
																									if stack[len_stack_minus_one] == node[1]:
																												anticipating_nodes.add(node[1]			)
																												break
																									else:
																												return True
																			if visited.count(node[1]			) < 1:
																						stack.append(node[1]			)
																						visited.append(node[1]			)
																						SCREAMING_SNAKE_CASE           =					node[1]
																						break

            # check if all the children are visited
													if s == ss:
																stack.pop()
																SCREAMING_SNAKE_CASE           =					True
																if len(a			) != 0:
																			SCREAMING_SNAKE_CASE           =					stack[len(a			) - 1]
													else:
																SCREAMING_SNAKE_CASE           =					False
																indirect_parents.append(a			)
																SCREAMING_SNAKE_CASE           =					s
																SCREAMING_SNAKE_CASE           =					ss

													# check if se have reached the starting point
													if len(a			) == 0:
																return False





							def    _UpperCAmelCase     (					self       :	Tuple			)			->					List[Any]:
										return list(self.graph			)





							def    _UpperCAmelCase     (					self       :	int       ,     a       :	List[str]=-2       ,     a       :	str=-1			)			->					Any:
										SCREAMING_SNAKE_CASE           =					time()
										self.dfs(a       ,     a			)
										SCREAMING_SNAKE_CASE           =					time()
										return end - begin







							def    _UpperCAmelCase     (					self       :	Union[str, Any]       ,     a       :	Optional[int]=-2			)			->					Tuple:
										SCREAMING_SNAKE_CASE           =					time()
										self.bfs(a			)
										SCREAMING_SNAKE_CASE           =					time()
										return end - begin












import argparse

from diffusers.pipelines.stable_diffusion.convert_from_ckpt import download_controlnet_from_original_ckpt


if __name__ == "__main__":
		__A						:							Tuple							=  argparse.ArgumentParser()

		parser.add_argument(
		    """--checkpoint_path""", default=None, type=str, required=True, help="""Path to the checkpoint to convert."""
		)
		parser.add_argument(
		    """--original_config_file""",
		    type=str,
		    required=True,
		    help="""The YAML config file corresponding to the original architecture.""",
		)
		parser.add_argument(
		    """--num_in_channels""",
		    default=None,
		    type=int,
		    help="""The number of input channels. If `None` number of input channels will be automatically inferred.""",
		)
		parser.add_argument(
		    """--image_size""",
		    default=5_1_2,
		    type=int,
		    help=(
		        """The image size that the model was trained on. Use 512 for Stable Diffusion v1.X and Stable Siffusion v2"""
		        """ Base. Use 768 for Stable Diffusion v2."""
		    ),
		)
		parser.add_argument(
		    """--extract_ema""",
		    action="""store_true""",
		    help=(
		        """Only relevant for checkpoints that have both EMA and non-EMA weights. Whether to extract the EMA weights"""
		        """ or not. Defaults to `False`. Add `--extract_ema` to extract the EMA weights. EMA weights usually yield"""
		        """ higher quality images for inference. Non-EMA weights are usually better to continue fine-tuning."""
		    ),
		)
		parser.add_argument(
		    """--upcast_attention""",
		    action="""store_true""",
		    help=(
		        """Whether the attention computation should always be upcasted. This is necessary when running stable"""
		        """ diffusion 2.1."""
		    ),
		)
		parser.add_argument(
		    """--from_safetensors""",
		    action="""store_true""",
		    help="""If `--checkpoint_path` is in `safetensors` format, load checkpoint with safetensors instead of PyTorch.""",
		)
		parser.add_argument(
		    """--to_safetensors""",
		    action="""store_true""",
		    help="""Whether to store pipeline in safetensors format or not.""",
		)
		parser.add_argument("""--dump_path""", default=None, type=str, required=True, help="""Path to the output model.""")
		parser.add_argument("""--device""", type=str, help="""Device to use (e.g. cpu, cuda:0, cuda:1, etc.)""")
		def 					lowerCamelCase_    (    SCREAMING_SNAKE_CASE   ):
					'''simple docstring'''
					if string == "True":
								return True
					elif string == "False":
								return False
					else:
								raise ValueError(f"""could not parse string as bool {string}"""   )

		parser.add_argument(
		    """--use_linear_projection""", help="""Override for use linear projection""", required=False, type=parse_bool
		)

		parser.add_argument("""--cross_attention_dim""", help="""Override for cross attention_dim""", required=False, type=int)

		__A						:							Union[str, Any]							=  parser.parse_args()

		__A						:							Any							=  download_controlnet_from_original_ckpt(
		    checkpoint_path=args.checkpoint_path,
		    original_config_file=args.original_config_file,
		    image_size=args.image_size,
		    extract_ema=args.extract_ema,
		    num_in_channels=args.num_in_channels,
		    upcast_attention=args.upcast_attention,
		    from_safetensors=args.from_safetensors,
		    device=args.device,
		    use_linear_projection=args.use_linear_projection,
		    cross_attention_dim=args.cross_attention_dim,
		)




		controlnet.save_pretrained(args.dump_path, safe_serialization=args.to_safetensors)






