


import argparse
import json
from pathlib import Path

import requests
import torch
from huggingface_hub import hf_hub_download
from PIL import Image

from transformers import YolosConfig, YolosForObjectDetection, YolosImageProcessor
from transformers.utils import logging


logging.set_verbosity_info()
lowerCAmelCase	=							logging.get_logger(__name__)
def       _a			(				SCREAMING_SNAKE_CASE					):


		"""simple docstring"""




		lowercase__						=				YolosConfig()

		# size of the architecture
		if "yolos_ti" in yolos_name:
				lowercase__						=				1_92
				lowercase__						=				7_68
				lowercase__						=				12
				lowercase__						=				3
				lowercase__						=				[8_00, 13_33]
				lowercase__						=				False
		elif yolos_name == "yolos_s_dWr":
				lowercase__						=				3_30
				lowercase__						=				14
				lowercase__						=				6
				lowercase__						=				13_20
		elif "yolos_s" in yolos_name:
				lowercase__						=				3_84
				lowercase__						=				15_36
				lowercase__						=				12
				lowercase__						=				6
		elif "yolos_b" in yolos_name:
				lowercase__						=				[8_00, 13_44]

		lowercase__						=				91
		lowercase__						=				'''huggingface/label-files'''
		lowercase__						=				'''coco-detection-id2label.json'''
		lowercase__						=				json.load(open(hf_hub_download(_lowercase						,    _lowercase						,    repo_type='''dataset'''					)						,    '''r'''					)					)
		lowercase__						=				{int(_lowercase					): v for k, v in idalabel.items()}
		lowercase__						=				idalabel
		lowercase__						=				{v: k for k, v in idalabel.items()}

		return config
def       _a			(				SCREAMING_SNAKE_CASE						,    SCREAMING_SNAKE_CASE						,    SCREAMING_SNAKE_CASE = False					):


		"""simple docstring"""




		for i in range(config.num_hidden_layers					):
				# read in weights + bias of input projection layer (in timm, this is a single matrix + bias)
				lowercase__						=				state_dict.pop(f'blocks.{i}.attn.qkv.weight'					)
				lowercase__						=				state_dict.pop(f'blocks.{i}.attn.qkv.bias'					)
				# next, add query, keys and values (in that order) to the state dict
				lowercase__						=				in_proj_weight[: config.hidden_size, :]
				lowercase__						=				in_proj_bias[: config.hidden_size]
				lowercase__						=				in_proj_weight[
				    config.hidden_size : config.hidden_size * 2, :
				]
				lowercase__						=				in_proj_bias[
				    config.hidden_size : config.hidden_size * 2
				]
				lowercase__						=				in_proj_weight[-config.hidden_size :, :]
				lowercase__						=				in_proj_bias[-config.hidden_size :]
def       _a			(				SCREAMING_SNAKE_CASE					):


		"""simple docstring"""




		if "backbone" in name:
				lowercase__						=				name.replace('''backbone'''						,    '''vit'''					)
		if "cls_token" in name:
				lowercase__						=				name.replace('''cls_token'''						,    '''embeddings.cls_token'''					)
		if "det_token" in name:
				lowercase__						=				name.replace('''det_token'''						,    '''embeddings.detection_tokens'''					)
		if "mid_pos_embed" in name:
				lowercase__						=				name.replace('''mid_pos_embed'''						,    '''encoder.mid_position_embeddings'''					)
		if "pos_embed" in name:
				lowercase__						=				name.replace('''pos_embed'''						,    '''embeddings.position_embeddings'''					)
		if "patch_embed.proj" in name:
				lowercase__						=				name.replace('''patch_embed.proj'''						,    '''embeddings.patch_embeddings.projection'''					)
		if "blocks" in name:
				lowercase__						=				name.replace('''blocks'''						,    '''encoder.layer'''					)
		if "attn.proj" in name:
				lowercase__						=				name.replace('''attn.proj'''						,    '''attention.output.dense'''					)
		if "attn" in name:
				lowercase__						=				name.replace('''attn'''						,    '''attention.self'''					)
		if "norm1" in name:
				lowercase__						=				name.replace('''norm1'''						,    '''layernorm_before'''					)
		if "norm2" in name:
				lowercase__						=				name.replace('''norm2'''						,    '''layernorm_after'''					)
		if "mlp.fc1" in name:
				lowercase__						=				name.replace('''mlp.fc1'''						,    '''intermediate.dense'''					)
		if "mlp.fc2" in name:
				lowercase__						=				name.replace('''mlp.fc2'''						,    '''output.dense'''					)
		if "class_embed" in name:
				lowercase__						=				name.replace('''class_embed'''						,    '''class_labels_classifier'''					)
		if "bbox_embed" in name:
				lowercase__						=				name.replace('''bbox_embed'''						,    '''bbox_predictor'''					)
		if "vit.norm" in name:
				lowercase__						=				name.replace('''vit.norm'''						,    '''vit.layernorm'''					)

		return name
def       _a			(				SCREAMING_SNAKE_CASE						,    SCREAMING_SNAKE_CASE					):


		"""simple docstring"""




		for key in orig_state_dict.copy().keys():
				lowercase__						=				orig_state_dict.pop(_lowercase					)

				if "qkv" in key:
						lowercase__						=				key.split('''.'''					)
						lowercase__						=				int(key_split[2]					)
						lowercase__						=				model.vit.encoder.layer[layer_num].attention.attention.all_head_size
						if "weight" in key:
								lowercase__						=				val[:dim, :]
								lowercase__						=				val[
								    dim : dim * 2, :
								]
								lowercase__						=				val[-dim:, :]
						else:
								lowercase__						=				val[:dim]
								lowercase__						=				val[dim : dim * 2]
								lowercase__						=				val[-dim:]
				else:
						lowercase__						=				val

		return orig_state_dict
def       _a			(				):


		"""simple docstring"""




		lowercase__						=				'''http://images.cocodataset.org/val2017/000000039769.jpg'''
		lowercase__						=				Image.open(requests.get(_lowercase						,    stream=_lowercase					).raw					)
		return im
@torch.no_grad()
def       _a			(				SCREAMING_SNAKE_CASE						,    SCREAMING_SNAKE_CASE						,    SCREAMING_SNAKE_CASE						,    SCREAMING_SNAKE_CASE = False					):


		"""simple docstring"""




		lowercase__						=				get_yolos_config(_lowercase					)

		# load original state_dict
		lowercase__						=				torch.load(_lowercase						,    map_location='''cpu'''					)['''model''']

		# load 🤗 model
		lowercase__						=				YolosForObjectDetection(_lowercase					)
		model.eval()
		lowercase__						=				convert_state_dict(_lowercase						,    _lowercase					)
		model.load_state_dict(_lowercase					)

		# Check outputs on an image, prepared by YolosImageProcessor
		lowercase__						=				8_00 if yolos_name != '''yolos_ti''' else 5_12
		lowercase__						=				YolosImageProcessor(format='''coco_detection'''						,    size=_lowercase					)
		lowercase__						=				image_processor(images=prepare_img()						,    return_tensors='''pt'''					)
		lowercase__						=				model(**_lowercase					)
		lowercase__					,		lowercase__						=				outputs.logits, outputs.pred_boxes

		lowercase__					,		lowercase__						=				None, None
		if yolos_name == "yolos_ti":
				lowercase__						=				torch.tensor(
				    [[-39.5_022, -11.9_820, -17.6_888], [-29.9_574, -9.9_769, -17.7_691], [-42.3_281, -20.7_200, -30.6_294]]					)
				lowercase__						=				torch.tensor(
				    [[0.4_021, 0.0_836, 0.7_979], [0.0_184, 0.2_609, 0.0_364], [0.1_781, 0.2_004, 0.2_095]]					)
		elif yolos_name == "yolos_s_200_pre":
				lowercase__						=				torch.tensor(
				    [[-24.0_248, -10.3_024, -14.8_290], [-42.0_392, -16.8_200, -27.4_334], [-27.2_743, -11.8_154, -18.7_148]]					)
				lowercase__						=				torch.tensor(
				    [[0.2_559, 0.5_455, 0.4_706], [0.2_989, 0.7_279, 0.1_875], [0.7_732, 0.4_017, 0.4_462]]					)
		elif yolos_name == "yolos_s_300_pre":
				lowercase__						=				torch.tensor(
				    [[-36.2_220, -14.4_385, -23.5_457], [-35.6_970, -14.7_583, -21.3_935], [-31.5_939, -13.6_042, -16.8_049]]					)
				lowercase__						=				torch.tensor(
				    [[0.7_614, 0.2_316, 0.4_728], [0.7_168, 0.4_495, 0.3_855], [0.4_996, 0.1_466, 0.9_996]]					)
		elif yolos_name == "yolos_s_dWr":
				lowercase__						=				torch.tensor(
				    [[-42.8_668, -24.1_049, -41.1_690], [-34.7_456, -14.1_274, -24.9_194], [-33.7_898, -12.1_946, -25.6_495]]					)
				lowercase__						=				torch.tensor(
				    [[0.5_587, 0.2_773, 0.0_605], [0.5_004, 0.3_014, 0.9_994], [0.4_999, 0.1_548, 0.9_994]]					)
		elif yolos_name == "yolos_base":
				lowercase__						=				torch.tensor(
				    [[-40.6_064, -24.3_084, -32.6_447], [-55.1_990, -30.7_719, -35.5_877], [-51.4_311, -33.3_507, -35.6_462]]					)
				lowercase__						=				torch.tensor(
				    [[0.5_555, 0.2_794, 0.0_655], [0.9_049, 0.2_664, 0.1_894], [0.9_183, 0.1_984, 0.1_635]]					)
		else:
				raise ValueError(f'Unknown yolos_name: {yolos_name}'					)

		assert torch.allclose(logits[0, :3, :3]						,    _lowercase						,    atol=1E-4					)
		assert torch.allclose(pred_boxes[0, :3, :3]						,    _lowercase						,    atol=1E-4					)

		Path(_lowercase					).mkdir(exist_ok=_lowercase					)
		print(f'Saving model {yolos_name} to {pytorch_dump_folder_path}'					)
		model.save_pretrained(_lowercase					)
		print(f'Saving image processor to {pytorch_dump_folder_path}'					)
		image_processor.save_pretrained(_lowercase					)

		if push_to_hub:
				lowercase__						=				{
				    '''yolos_ti''': '''yolos-tiny''',
				    '''yolos_s_200_pre''': '''yolos-small''',
				    '''yolos_s_300_pre''': '''yolos-small-300''',
				    '''yolos_s_dWr''': '''yolos-small-dwr''',
				    '''yolos_base''': '''yolos-base''',
				}

				print('''Pushing to the hub...'''					)
				lowercase__						=				model_mapping[yolos_name]
				image_processor.push_to_hub(_lowercase						,    organization='''hustvl'''					)
				model.push_to_hub(_lowercase						,    organization='''hustvl'''					)


if __name__ == "__main__":
			lowerCAmelCase	=							argparse.ArgumentParser()
			# Required parameters
			parser.add_argument(
			    '--yolos_name',
			    default='yolos_s_200_pre',
			    type=str,
			    help=(
			        'Name of the YOLOS model you\'d like to convert. Should be one of \'yolos_ti\', \'yolos_s_200_pre\','
			        ' \'yolos_s_300_pre\', \'yolos_s_dWr\', \'yolos_base\'.'
			    ),
			)
			parser.add_argument(
			    '--checkpoint_path', default=None, type=str, help='Path to the original state dict (.pth file).'
			)
			parser.add_argument(
			    '--pytorch_dump_folder_path', default=None, type=str, help='Path to the output PyTorch model directory.'
			)
			parser.add_argument(
			    '--push_to_hub', action='store_true', help='Whether or not to push the converted model to the 🤗 hub.'
			)

			lowerCAmelCase	=							parser.parse_args()
			convert_yolos_checkpoint(args.yolos_name, args.checkpoint_path, args.pytorch_dump_folder_path, args.push_to_hub)






from abc import ABC, abstractmethod
from typing import List, Optional


class 	_a							(      UpperCamelCase__      ):

							def __init__(							self:     Optional[int]							)      ->       Union[str, Any]:





									"""simple docstring"""







									self.test()

							def 				lowerCamelCase_			(							self:     List[Any]							)      ->       List[Any]:





									"""simple docstring"""







									lowercase__						=				0
									lowercase__						=				False
									while not completed:
											if counter == 1:
													self.reset()
											lowercase__						=				self.advance()
											if not self.does_advance(UpperCamelCase_							):
													raise Exception(
													    '''Custom Constraint is not defined correctly. self.does_advance(self.advance()) must be true.'''							)

											lowercase__					,		lowercase__					,		lowercase__						=				self.update(UpperCamelCase_							)
											counter += 1

											if counter > 10_000:
													raise Exception('''update() does not fulfill the constraint.'''							)

									if self.remaining() != 0:
											raise Exception('''Custom Constraint is not defined correctly.'''							)

							@abstractmethod
							def 				lowerCamelCase_			(							self:     int							)      ->       Any:





									"""simple docstring"""







									raise NotImplementedError(
									    f'{self.__class__} is an abstract class. Only classes inheriting this class can be called.'							)

							@abstractmethod
							def 				lowerCamelCase_			(							self:     Tuple   ,						UpperCamelCase_:     int							)      ->       Optional[int]:





									"""simple docstring"""







									raise NotImplementedError(
									    f'{self.__class__} is an abstract class. Only classes inheriting this class can be called.'							)

							@abstractmethod
							def 				lowerCamelCase_			(							self:     Optional[int]   ,						UpperCamelCase_:     int							)      ->       str:





									"""simple docstring"""







									raise NotImplementedError(
									    f'{self.__class__} is an abstract class. Only classes inheriting this class can be called.'							)

							@abstractmethod
							def 				lowerCamelCase_			(							self:     Tuple							)      ->       List[Any]:





									"""simple docstring"""







									raise NotImplementedError(
									    f'{self.__class__} is an abstract class. Only classes inheriting this class can be called.'							)

							@abstractmethod
							def 				lowerCamelCase_			(							self:     Any							)      ->       Tuple:





									"""simple docstring"""







									raise NotImplementedError(
									    f'{self.__class__} is an abstract class. Only classes inheriting this class can be called.'							)


							@abstractmethod
							def 				lowerCamelCase_			(							self:     Tuple   ,						UpperCamelCase_:     int=False							)      ->       Any:





									"""simple docstring"""







									raise NotImplementedError(
									    f'{self.__class__} is an abstract class. Only classes inheriting this class can be called.'							)


class 	_a							(      UpperCamelCase__      ):

							def __init__(							self:     str   ,						UpperCamelCase_:     List[int]							)      ->       Tuple:





									"""simple docstring"""







									super(UpperCamelCase_   ,						self							).__init__()

									if not isinstance(UpperCamelCase_   ,						UpperCamelCase_							) or len(UpperCamelCase_							) == 0:
											raise ValueError(f'`token_ids` has to be a non-empty list, but is {token_ids}.'							)
									if any((not isinstance(UpperCamelCase_   ,						UpperCamelCase_							) or token_id < 0) for token_id in token_ids							):
											raise ValueError(f'Each list in `token_ids` has to be a list of positive integers, but is {token_ids}.'							)

									lowercase__						=				token_ids

									lowercase__						=				len(self.token_ids							)
									lowercase__						=				-1  # the index of the currently fulfilled step
									lowercase__						=				False

							def 				lowerCamelCase_			(							self:     Tuple							)      ->       Tuple:





									"""simple docstring"""







									if self.completed:
											return None
									return self.token_ids[self.fulfilled_idx + 1]

							def 				lowerCamelCase_			(							self:     Union[str, Any]   ,						UpperCamelCase_:     int							)      ->       Optional[Any]:





									"""simple docstring"""







									if not isinstance(UpperCamelCase_   ,						UpperCamelCase_							):
											raise ValueError(f'`token_id` has to be an `int`, but is {token_id} of type {type(UpperCamelCase_							)}'							)

									if self.completed:
											return False

									return token_id == self.token_ids[self.fulfilled_idx + 1]

							def 				lowerCamelCase_			(							self:     Optional[int]   ,						UpperCamelCase_:     int							)      ->       Dict:





									"""simple docstring"""







									if not isinstance(UpperCamelCase_   ,						UpperCamelCase_							):
											raise ValueError(f'`token_id` has to be an `int`, but is {token_id} of type {type(UpperCamelCase_							)}'							)

									lowercase__						=				False
									lowercase__						=				False
									lowercase__						=				False

									if self.does_advance(UpperCamelCase_							):
											self.fulfilled_idx += 1
											lowercase__						=				True
											if self.fulfilled_idx == (self.seqlen - 1):
													lowercase__						=				True
											lowercase__						=				completed
									else:
											# failed to make progress.
											lowercase__						=				True
											self.reset()
									return stepped, completed, reset

							def 				lowerCamelCase_			(							self:     Tuple							)      ->       int:





									"""simple docstring"""







									lowercase__						=				False
									lowercase__						=				0

							def 				lowerCamelCase_			(							self:     Any							)      ->       Dict:





									"""simple docstring"""







									return self.seqlen - (self.fulfilled_idx + 1)


							def 				lowerCamelCase_			(							self:     Any   ,						UpperCamelCase_:     Union[str, Any]=False							)      ->       Tuple:





									"""simple docstring"""







									lowercase__						=				PhrasalConstraint(self.token_ids							)

									if stateful:
											lowercase__						=				self.seqlen
											lowercase__						=				self.fulfilled_idx
											lowercase__						=				self.completed

									return new_constraint


class 	_a							:

							def __init__(							self:     Union[str, Any]   ,						UpperCamelCase_:     List[List[int]]   ,						UpperCamelCase_:     int=True							)      ->       int:





									"""simple docstring"""







									lowercase__						=				max([len(UpperCamelCase_							) for one in nested_token_ids]							)

									lowercase__						=				{}
									for token_ids in nested_token_ids:
											lowercase__						=				root
											for tidx, token_id in enumerate(UpperCamelCase_							):
													if token_id not in level:
															lowercase__						=				{}

													lowercase__						=				level[token_id]

									if no_subsets and self.has_subsets(UpperCamelCase_   ,						UpperCamelCase_							):
											raise ValueError(
											    '''Each list in `nested_token_ids` can\'t be a complete subset of another list, but is'''
											    f' {nested_token_ids}.'							)

									lowercase__						=				root

							def 				lowerCamelCase_			(							self:     int   ,						UpperCamelCase_:     str							)      ->       Any:





									"""simple docstring"""







									lowercase__						=				self.trie

									for current_token in current_seq:
											lowercase__						=				start[current_token]

									lowercase__						=				list(start.keys()							)

									return next_tokens

							def 				lowerCamelCase_			(							self:     Any   ,						UpperCamelCase_:     Tuple							)      ->       Optional[Any]:





									"""simple docstring"""







									lowercase__						=				self.next_tokens(UpperCamelCase_							)

									return len(UpperCamelCase_							) == 0

							def 				lowerCamelCase_			(							self:     List[str]   ,						UpperCamelCase_:     Optional[Any]							)      ->       Any:





									"""simple docstring"""







									lowercase__						=				list(root.values()							)
									if len(UpperCamelCase_							) == 0:
											return 1
									else:
											return sum([self.count_leaves(UpperCamelCase_							) for nn in next_nodes]							)


							def 				lowerCamelCase_			(							self:     Any   ,						UpperCamelCase_:     Union[str, Any]   ,						UpperCamelCase_:     int							)      ->       Tuple:





									"""simple docstring"""







									lowercase__						=				self.count_leaves(UpperCamelCase_							)
									return len(UpperCamelCase_							) != leaf_count


class 	_a							(      UpperCamelCase__      ):

							def __init__(							self:     Optional[int]   ,						UpperCamelCase_:     List[List[int]]							)      ->       List[Any]:





									"""simple docstring"""







									super(UpperCamelCase_   ,						self							).__init__()

									if not isinstance(UpperCamelCase_   ,						UpperCamelCase_							) or len(UpperCamelCase_							) == 0:
											raise ValueError(f'`nested_token_ids` has to be a non-empty list, but is {nested_token_ids}.'							)
									if any(not isinstance(UpperCamelCase_   ,						UpperCamelCase_							) for token_ids in nested_token_ids							):
											raise ValueError(f'`nested_token_ids` has to be a list of lists, but is {nested_token_ids}.'							)
									if any(
									    any((not isinstance(UpperCamelCase_   ,						UpperCamelCase_							) or token_id < 0) for token_id in token_ids							)
									    for token_ids in nested_token_ids							):
											raise ValueError(
											    f'Each list in `nested_token_ids` has to be a list of positive integers, but is {nested_token_ids}.'							)

									lowercase__						=				DisjunctiveTrie(UpperCamelCase_							)
									lowercase__						=				nested_token_ids

									lowercase__						=				self.trie.max_height
									lowercase__						=				[]
									lowercase__						=				False

							def 				lowerCamelCase_			(							self:     Union[str, Any]							)      ->       str:





									"""simple docstring"""







									lowercase__						=				self.trie.next_tokens(self.current_seq							)

									if len(UpperCamelCase_							) == 0:
											return None
									else:
											return token_list

							def 				lowerCamelCase_			(							self:     str   ,						UpperCamelCase_:     int							)      ->       Tuple:





									"""simple docstring"""







									if not isinstance(UpperCamelCase_   ,						UpperCamelCase_							):
											raise ValueError(f'`token_id` is supposed to be type `int`, but is {token_id} of type {type(UpperCamelCase_							)}'							)

									lowercase__						=				self.trie.next_tokens(self.current_seq							)

									return token_id in next_tokens

							def 				lowerCamelCase_			(							self:     int   ,						UpperCamelCase_:     int							)      ->       Dict:





									"""simple docstring"""







									if not isinstance(UpperCamelCase_   ,						UpperCamelCase_							):
											raise ValueError(f'`token_id` is supposed to be type `int`, but is {token_id} of type {type(UpperCamelCase_							)}'							)

									lowercase__						=				False
									lowercase__						=				False
									lowercase__						=				False

									if self.does_advance(UpperCamelCase_							):
											self.current_seq.append(UpperCamelCase_							)
											lowercase__						=				True
									else:
											lowercase__						=				True
											self.reset()

									lowercase__						=				self.trie.reached_leaf(self.current_seq							)
									lowercase__						=				completed

									return stepped, completed, reset

							def 				lowerCamelCase_			(							self:     List[str]							)      ->       List[Any]:





									"""simple docstring"""







									lowercase__						=				False
									lowercase__						=				[]

							def 				lowerCamelCase_			(							self:     List[str]							)      ->       Optional[Any]:





									"""simple docstring"""







									if self.completed:
											# since this can be completed without reaching max height
											return 0
									else:
											return self.seqlen - len(self.current_seq							)


							def 				lowerCamelCase_			(							self:     Any   ,						UpperCamelCase_:     Optional[Any]=False							)      ->       str:





									"""simple docstring"""







									lowercase__						=				DisjunctiveConstraint(self.token_ids							)

									if stateful:
											lowercase__						=				self.seqlen
											lowercase__						=				self.current_seq
											lowercase__						=				self.completed

									return new_constraint


class 	_a							:

							def __init__(							self:     int   ,						UpperCamelCase_:     List[Constraint]							)      ->       Dict:





									"""simple docstring"""







									lowercase__						=				constraints

									# max # of steps required to fulfill a given constraint
									lowercase__						=				max([c.seqlen for c in constraints]							)
									lowercase__						=				len(UpperCamelCase_							)
									lowercase__						=				False

									self.init_state()

							def 				lowerCamelCase_			(							self:     List[str]							)      ->       str:





									"""simple docstring"""







									lowercase__						=				[]
									lowercase__						=				None
									lowercase__						=				[constraint.copy(stateful=UpperCamelCase_							) for constraint in self.constraints]

							def 				lowerCamelCase_			(							self:     str							)      ->       Any:





									"""simple docstring"""







									lowercase__						=				0
									if self.inprogress_constraint:
											# extra points for having a constraint mid-fulfilled
											add += self.max_seqlen - self.inprogress_constraint.remaining()

									return (len(self.complete_constraints							) * self.max_seqlen) + add

							def 				lowerCamelCase_			(							self:     Union[str, Any]							)      ->       List[Any]:





									"""simple docstring"""







									lowercase__						=				[]
									if self.inprogress_constraint is None:
											for constraint in self.pending_constraints:  # "pending" == "unfulfilled yet"
													lowercase__						=				constraint.advance()
													if isinstance(UpperCamelCase_   ,						UpperCamelCase_							):
															token_list.append(UpperCamelCase_							)
													elif isinstance(UpperCamelCase_   ,						UpperCamelCase_							):
															token_list.extend(UpperCamelCase_							)
									else:
											lowercase__						=				self.inprogress_constraint.advance()
											if isinstance(UpperCamelCase_   ,						UpperCamelCase_							):
													token_list.append(UpperCamelCase_							)
											elif isinstance(UpperCamelCase_   ,						UpperCamelCase_							):
													token_list.extend(UpperCamelCase_							)

									if len(UpperCamelCase_							) == 0:
											return None
									else:
											return token_list

							def 				lowerCamelCase_			(							self:     Optional[Any]   ,						UpperCamelCase_:     Optional[List[int]]							)      ->       Optional[int]:





									"""simple docstring"""







									self.init_state()

									if token_ids is not None:
											for token in token_ids:
													# completes or steps **one** constraint
													lowercase__					,		lowercase__						=				self.add(UpperCamelCase_							)

													# the entire list of constraints are fulfilled
													if self.completed:
															break

							def 				lowerCamelCase_			(							self:     Optional[Any]   ,						UpperCamelCase_:     int							)      ->       int:





									"""simple docstring"""







									if not isinstance(UpperCamelCase_   ,						UpperCamelCase_							):
											raise ValueError(f'`token_id` should be an `int`, but is `{token_id}`.'							)

									lowercase__					,		lowercase__						=				False, False

									if self.completed:
											lowercase__						=				True
											lowercase__						=				False
											return complete, stepped

									if self.inprogress_constraint is not None:
											# In the middle of fulfilling a constraint. If the `token_id` *does* makes an incremental progress to current
											# job, simply update the state

											lowercase__					,		lowercase__					,		lowercase__						=				self.inprogress_constraint.update(UpperCamelCase_							)
											if reset:
													# 1. If the next token breaks the progress, then we must restart.
													#     e.g. constraint = "I love pies" and sequence so far is "I love" but `token_id` == "books".

													#     But that doesn't mean we self.init_state(), since we only reset the state for this particular
													#     constraint, not the full list of constraints.

													self.pending_constraints.append(self.inprogress_constraint.copy(stateful=UpperCamelCase_							)							)
													lowercase__						=				None

											if complete:
													# 2. If the next token completes the constraint, move it to completed list, set
													#     inprogress to None. If there are no pending constraints either, then this full list of constraints
													#     is complete.

													self.complete_constraints.append(self.inprogress_constraint							)
													lowercase__						=				None

													if len(self.pending_constraints							) == 0:
															# we're done!
															lowercase__						=				True

									else:
											# Not in the middle of fulfilling a constraint. So does this `token_id` helps us step towards any of our list
											# of constraints?

											for cidx, pending_constraint in enumerate(self.pending_constraints							):
													if pending_constraint.does_advance(UpperCamelCase_							):
															lowercase__					,		lowercase__					,		lowercase__						=				pending_constraint.update(UpperCamelCase_							)

															if not stepped:
																	raise Exception(
																	    '''`constraint.update(token_id)` is not yielding incremental progress, '''
																	    '''even though `constraint.does_advance(token_id)` is true.'''							)

															if complete:
																	self.complete_constraints.append(UpperCamelCase_							)
																	lowercase__						=				None

															if not complete and stepped:
																	lowercase__						=				pending_constraint

															if complete or stepped:
																	# If we made any progress at all, then it's at least not a "pending constraint".

																	lowercase__						=				(
																	    self.pending_constraints[:cidx] + self.pending_constraints[cidx + 1 :]
																	)

																	if len(self.pending_constraints							) == 0 and self.inprogress_constraint is None:
																			# If there's no longer any pending after this and no inprogress either, then we must be
																			# complete.

																			lowercase__						=				True

																	break  # prevent accidentally stepping through multiple constraints with just one token.

									return complete, stepped


							def 				lowerCamelCase_			(							self:     Any   ,						UpperCamelCase_:     Optional[Any]=True							)      ->       Dict:





									"""simple docstring"""







									lowercase__						=				ConstraintListState(self.constraints							)  # we actually never though self.constraints objects
									# throughout this process. So it's at initialization state.

									if stateful:
											lowercase__						=				[
											    constraint.copy(stateful=UpperCamelCase_							) for constraint in self.complete_constraints
											]
											if self.inprogress_constraint is not None:
													lowercase__						=				self.inprogress_constraint.copy(stateful=UpperCamelCase_							)
											lowercase__						=				[constraint.copy() for constraint in self.pending_constraints]

									return new_state


