




import logging
import os
from dataclasses import dataclass
from enum import Enum
from typing import List, Optional, Union

from filelock import FileLock

from transformers import PreTrainedTokenizer, is_tf_available, is_torch_available


__A						:							Any							=  logging.getLogger(__name__)




@dataclass
class 			UpperCAmelCase_      :




							'''simple docstring'''



							a__						  =     4_2
							a__						  =     4_2
							a__						  =     4_2





@dataclass
class 			UpperCAmelCase_      :




							'''simple docstring'''



							a__						  =     4_2
							a__						  =     4_2
							a__						  =     None
							a__						  =     None





class 			UpperCAmelCase_      (   A       ):




							'''simple docstring'''



							a__						  =     '''train'''
							a__						  =     '''dev'''
							a__						  =     '''test'''





class 			UpperCAmelCase_      :




							'''simple docstring'''



							@staticmethod
							def    _UpperCAmelCase     (					a       :	Dict       ,     a       :	int			)			->					List[InputExample]:
										raise NotImplementedError





							@staticmethod
							def    _UpperCAmelCase     (					a       :	str			)			->					List[str]:
										raise NotImplementedError







							@staticmethod
							def    _UpperCAmelCase     (					a       :	List[Any]       ,     a       :	Optional[Any]       ,     a       :	Any       ,     a       :	Dict       ,     a       :	int=False       ,     a       :	int="[CLS]"       ,     a       :	Any=1       ,     a       :	Optional[int]="[SEP]"       ,     a       :	str=False       ,     a       :	int=False       ,     a       :	Optional[int]=0       ,     a       :	int=0       ,     a       :	List[Any]=-100       ,     a       :	Optional[Any]=0       ,     a       :	Optional[Any]=True       ,     )			->					List[InputFeatures]:
										SCREAMING_SNAKE_CASE           =					{label: i for i, label in enumerate(_SCREAMING_SNAKE_CASE			)}

										SCREAMING_SNAKE_CASE           =					[]
										for ex_index, example in enumerate(_SCREAMING_SNAKE_CASE			):
													if ex_index % 10_000 == 0:
																logger.info("""Writing example %d of %d"""       ,     _SCREAMING_SNAKE_CASE       ,     len(_SCREAMING_SNAKE_CASE			)			)

													SCREAMING_SNAKE_CASE           =					[]
													SCREAMING_SNAKE_CASE           =					[]
													for word, label in zip(example.words       ,     example.labels			):
																SCREAMING_SNAKE_CASE           =					tokenizer.tokenize(_SCREAMING_SNAKE_CASE			)

																# bert-base-multilingual-cased sometimes output "nothing ([]) when calling tokenize with just a space.
																if len(_SCREAMING_SNAKE_CASE			) > 0:
																			tokens.extend(_SCREAMING_SNAKE_CASE			)
																			# Use the real label id for the first token of the word, and padding ids for the remaining tokens
																			label_ids.extend([label_map[label]] + [pad_token_label_id] * (len(_SCREAMING_SNAKE_CASE			) - 1)			)

            # Account for [CLS] and [SEP] with "- 2" and with "- 3" for RoBERTa.
													SCREAMING_SNAKE_CASE           =					tokenizer.num_special_tokens_to_add()
													if len(_SCREAMING_SNAKE_CASE			) > max_seq_length - special_tokens_count:
																SCREAMING_SNAKE_CASE           =					tokens[: (max_seq_length - special_tokens_count)]
																SCREAMING_SNAKE_CASE           =					label_ids[: (max_seq_length - special_tokens_count)]

													# The convention in BERT is:
													# (a) For sequence pairs:
													#  tokens:   [CLS] is this jack ##son ##ville ? [SEP] no it is not . [SEP]
													#  type_ids:   0   0  0    0    0     0       0   0   1  1  1  1   1   1
													# (b) For single sequences:
													#  tokens:   [CLS] the dog is hairy . [SEP]
													#  type_ids:   0   0   0   0  0     0   0
													#
													# Where "type_ids" are used to indicate whether this is the first
													# sequence or the second sequence. The embedding vectors for `type=0` and
													# `type=1` were learned during pre-training and are added to the wordpiece
													# embedding vector (and position vector). This is not *strictly* necessary
													# since the [SEP] token unambiguously separates the sequences, but it makes
													# it easier for the model to learn the concept of sequences.
													#
													# For classification tasks, the first vector (corresponding to [CLS]) is
													# used as the "sentence vector". Note that this only makes sense because
													# the entire model is fine-tuned.
													tokens += [sep_token]
													label_ids += [pad_token_label_id]
													if sep_token_extra:
																# roberta uses an extra separator b/w pairs of sentences
																tokens += [sep_token]
																label_ids += [pad_token_label_id]
													SCREAMING_SNAKE_CASE           =					[sequence_a_segment_id] * len(_SCREAMING_SNAKE_CASE			)

													if cls_token_at_end:
																tokens += [cls_token]
																label_ids += [pad_token_label_id]
																segment_ids += [cls_token_segment_id]
													else:
																SCREAMING_SNAKE_CASE           =					[cls_token] + tokens
																SCREAMING_SNAKE_CASE           =					[pad_token_label_id] + label_ids
																SCREAMING_SNAKE_CASE           =					[cls_token_segment_id] + segment_ids

													SCREAMING_SNAKE_CASE           =					tokenizer.convert_tokens_to_ids(_SCREAMING_SNAKE_CASE			)

													# The mask has 1 for real tokens and 0 for padding tokens. Only real
													# tokens are attended to.
													SCREAMING_SNAKE_CASE           =					[1 if mask_padding_with_zero else 0] * len(_SCREAMING_SNAKE_CASE			)

													# Zero-pad up to the sequence length.
													SCREAMING_SNAKE_CASE           =					max_seq_length - len(_SCREAMING_SNAKE_CASE			)
													if pad_on_left:
																SCREAMING_SNAKE_CASE           =					([pad_token] * padding_length) + input_ids
																SCREAMING_SNAKE_CASE           =					([0 if mask_padding_with_zero else 1] * padding_length) + input_mask
																SCREAMING_SNAKE_CASE           =					([pad_token_segment_id] * padding_length) + segment_ids
																SCREAMING_SNAKE_CASE           =					([pad_token_label_id] * padding_length) + label_ids
													else:
																input_ids += [pad_token] * padding_length
																input_mask += [0 if mask_padding_with_zero else 1] * padding_length
																segment_ids += [pad_token_segment_id] * padding_length
																label_ids += [pad_token_label_id] * padding_length

													assert len(_SCREAMING_SNAKE_CASE			) == max_seq_length
													assert len(_SCREAMING_SNAKE_CASE			) == max_seq_length
													assert len(_SCREAMING_SNAKE_CASE			) == max_seq_length
													assert len(_SCREAMING_SNAKE_CASE			) == max_seq_length

													if ex_index < 5:
																logger.info("""*** Example ***"""			)
																logger.info("""guid: %s"""       ,     example.guid			)
																logger.info("""tokens: %s"""       ,     """ """.join([str(_SCREAMING_SNAKE_CASE			) for x in tokens]			)			)
																logger.info("""input_ids: %s"""       ,     """ """.join([str(_SCREAMING_SNAKE_CASE			) for x in input_ids]			)			)
																logger.info("""input_mask: %s"""       ,     """ """.join([str(_SCREAMING_SNAKE_CASE			) for x in input_mask]			)			)
																logger.info("""segment_ids: %s"""       ,     """ """.join([str(_SCREAMING_SNAKE_CASE			) for x in segment_ids]			)			)
																logger.info("""label_ids: %s"""       ,     """ """.join([str(_SCREAMING_SNAKE_CASE			) for x in label_ids]			)			)

													if "token_type_ids" not in tokenizer.model_input_names:
																SCREAMING_SNAKE_CASE           =					None

													features.append(
													    InputFeatures(
													        input_ids=_SCREAMING_SNAKE_CASE       ,     attention_mask=_SCREAMING_SNAKE_CASE       ,     token_type_ids=_SCREAMING_SNAKE_CASE       ,     label_ids=_SCREAMING_SNAKE_CASE			)			)
										return features


if is_torch_available():
		import torch
		from torch import nn
		from torch.utils.data import Dataset




		class 			UpperCAmelCase_      (   A       ):




									'''simple docstring'''



									a__						  =     4_2
									a__						  =     nn.CrossEntropyLoss().ignore_index





									def __init__(					self       :	Union[str, Any]       ,     a       :	int       ,     a       :	Any       ,     a       :	Union[str, Any]       ,     a       :	Optional[Any]       ,     a       :	Dict       ,     a       :	int = None       ,     a       :	Dict=False       ,     a       :	Optional[Any] = Split.train       ,     )			->					Optional[int]:
												SCREAMING_SNAKE_CASE           =					os.path.join(
												    _SCREAMING_SNAKE_CASE       ,     """cached_{}_{}_{}""".format(mode.value       ,     tokenizer.__class__.__name__       ,     str(_SCREAMING_SNAKE_CASE			)			)       ,     )

												# Make sure only the first process in distributed training processes the dataset,
												# and the others will use the cache.
												SCREAMING_SNAKE_CASE           =					cached_features_file + """.lock"""
												with FileLock(_SCREAMING_SNAKE_CASE			):
															if os.path.exists(_SCREAMING_SNAKE_CASE			) and not overwrite_cache:
																		logger.info(f"""Loading features from cached file {cached_features_file}"""			)
																		SCREAMING_SNAKE_CASE           =					torch.load(_SCREAMING_SNAKE_CASE			)
															else:
																		logger.info(f"""Creating features from dataset file at {data_dir}"""			)
																		SCREAMING_SNAKE_CASE           =					token_classification_task.read_examples_from_file(_SCREAMING_SNAKE_CASE       ,     _SCREAMING_SNAKE_CASE			)
																		# TODO clean up all this to leverage built-in features of tokenizers
																		SCREAMING_SNAKE_CASE           =					token_classification_task.convert_examples_to_features(
																		    _SCREAMING_SNAKE_CASE       ,     _SCREAMING_SNAKE_CASE       ,     _SCREAMING_SNAKE_CASE       ,     _SCREAMING_SNAKE_CASE       ,     cls_token_at_end=bool(model_type in ["""xlnet"""]			)       ,     cls_token=tokenizer.cls_token       ,     cls_token_segment_id=2 if model_type in ["""xlnet"""] else 0       ,     sep_token=tokenizer.sep_token       ,     sep_token_extra=_SCREAMING_SNAKE_CASE       ,     pad_on_left=bool(tokenizer.padding_side == """left"""			)       ,     pad_token=tokenizer.pad_token_id       ,     pad_token_segment_id=tokenizer.pad_token_type_id       ,     pad_token_label_id=self.pad_token_label_id       ,     )
																		logger.info(f"""Saving features into cached file {cached_features_file}"""			)
																		torch.save(self.features       ,     _SCREAMING_SNAKE_CASE			)





									def __len__(					self       :	int			)			->					List[Any]:
												return len(self.features			)







									def __getitem__(					self       :	str       ,     a       :	Optional[int]			)			->					InputFeatures:
												return self.features[i]


if is_tf_available():
		import tensorflow as tf




		class 			UpperCAmelCase_      :




									'''simple docstring'''



									a__						  =     4_2
									a__						  =     -1_0_0





									def __init__(					self       :	Optional[Any]       ,     a       :	Tuple       ,     a       :	str       ,     a       :	int       ,     a       :	Tuple       ,     a       :	List[Any]       ,     a       :	Dict = None       ,     a       :	Union[str, Any]=False       ,     a       :	Union[str, Any] = Split.train       ,     )			->					str:
												SCREAMING_SNAKE_CASE           =					token_classification_task.read_examples_from_file(_SCREAMING_SNAKE_CASE       ,     _SCREAMING_SNAKE_CASE			)
												# TODO clean up all this to leverage built-in features of tokenizers
												SCREAMING_SNAKE_CASE           =					token_classification_task.convert_examples_to_features(
												    _SCREAMING_SNAKE_CASE       ,     _SCREAMING_SNAKE_CASE       ,     _SCREAMING_SNAKE_CASE       ,     _SCREAMING_SNAKE_CASE       ,     cls_token_at_end=bool(model_type in ["""xlnet"""]			)       ,     cls_token=tokenizer.cls_token       ,     cls_token_segment_id=2 if model_type in ["""xlnet"""] else 0       ,     sep_token=tokenizer.sep_token       ,     sep_token_extra=_SCREAMING_SNAKE_CASE       ,     pad_on_left=bool(tokenizer.padding_side == """left"""			)       ,     pad_token=tokenizer.pad_token_id       ,     pad_token_segment_id=tokenizer.pad_token_type_id       ,     pad_token_label_id=self.pad_token_label_id       ,     )

												def gen():
															for ex in self.features:
																		if ex.token_type_ids is None:
																					yield (
																					    {"input_ids": ex.input_ids, "attention_mask": ex.attention_mask},
																					    ex.label_ids,
																					)
																		else:
																					yield (
																					    {
																					        "input_ids": ex.input_ids,
																					        "attention_mask": ex.attention_mask,
																					        "token_type_ids": ex.token_type_ids,
																					    },
																					    ex.label_ids,
																					)

												if "token_type_ids" not in tokenizer.model_input_names:
															SCREAMING_SNAKE_CASE           =					tf.data.Dataset.from_generator(
															    _SCREAMING_SNAKE_CASE       ,     ({"""input_ids""": tf.intaa, """attention_mask""": tf.intaa}, tf.intaa)       ,     (
															        {"""input_ids""": tf.TensorShape([None]			), """attention_mask""": tf.TensorShape([None]			)},
															        tf.TensorShape([None]			),
															    )       ,     )
												else:
															SCREAMING_SNAKE_CASE           =					tf.data.Dataset.from_generator(
															    _SCREAMING_SNAKE_CASE       ,     ({"""input_ids""": tf.intaa, """attention_mask""": tf.intaa, """token_type_ids""": tf.intaa}, tf.intaa)       ,     (
															        {
															            """input_ids""": tf.TensorShape([None]			),
															            """attention_mask""": tf.TensorShape([None]			),
															            """token_type_ids""": tf.TensorShape([None]			),
															        },
															        tf.TensorShape([None]			),
															    )       ,     )





									def    _UpperCAmelCase     (					self       :	Dict			)			->					Optional[Any]:
												SCREAMING_SNAKE_CASE           =					self.dataset.apply(tf.data.experimental.assert_cardinality(len(self.features			)			)			)

												return self.dataset





									def __len__(					self       :	Tuple			)			->					int:
												return len(self.features			)







									def __getitem__(					self       :	Optional[int]       ,     a       :	Optional[Any]			)			->					InputFeatures:
												return self.features[i]









import os
import sys
import unittest


__A						:							Any							=  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						:							List[Any]							=  os.path.join(git_repo_path, """src""", """diffusers""")




class 			UpperCAmelCase_      (   unittest.TestCase       ):




							'''simple docstring'''



							def    _UpperCAmelCase     (					self       :	Any			)			->					Optional[Any]:
										SCREAMING_SNAKE_CASE           =					find_backend("""    if not is_torch_available():"""			)
										self.assertEqual(a       ,     """torch"""			)

										# backend_with_underscore = find_backend("    if not is_tensorflow_text_available():")
										# self.assertEqual(backend_with_underscore, "tensorflow_text")

										SCREAMING_SNAKE_CASE           =					find_backend("""    if not (is_torch_available() and is_transformers_available()):"""			)
										self.assertEqual(a       ,     """torch_and_transformers"""			)

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

										SCREAMING_SNAKE_CASE           =					find_backend(
										    """    if not (is_torch_available() and is_transformers_available() and is_onnx_available()):"""			)
										self.assertEqual(a       ,     """torch_and_transformers_and_onnx"""			)





							def    _UpperCAmelCase     (					self       :	List[str]			)			->					int:
										SCREAMING_SNAKE_CASE           =					read_init()
										# We don't assert on the exact list of keys to allow for smooth grow of backend-specific objects
										self.assertIn("""torch"""       ,     a			)
										self.assertIn("""torch_and_transformers"""       ,     a			)
										self.assertIn("""flax_and_transformers"""       ,     a			)
										self.assertIn("""torch_and_transformers_and_onnx"""       ,     a			)

										# Likewise, we can't assert on the exact content of a key
										self.assertIn("""UNet2DModel"""       ,     objects["""torch"""]			)
										self.assertIn("""FlaxUNet2DConditionModel"""       ,     objects["""flax"""]			)
										self.assertIn("""StableDiffusionPipeline"""       ,     objects["""torch_and_transformers"""]			)
										self.assertIn("""FlaxStableDiffusionPipeline"""       ,     objects["""flax_and_transformers"""]			)
										self.assertIn("""LMSDiscreteScheduler"""       ,     objects["""torch_and_scipy"""]			)
										self.assertIn("""OnnxStableDiffusionPipeline"""       ,     objects["""torch_and_transformers_and_onnx"""]			)





							def    _UpperCAmelCase     (					self       :	Any			)			->					int:
										SCREAMING_SNAKE_CASE           =					create_dummy_object("""CONSTANT"""       ,     """'torch'"""			)
										self.assertEqual(a       ,     """\nCONSTANT = None\n"""			)

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

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

    def __init__(self, *args, **kwargs):
        requires_backends(self, 'torch')

    @classmethod
    def from_config(cls, *args, **kwargs):
        requires_backends(cls, 'torch')

    @classmethod
    def from_pretrained(cls, *args, **kwargs):
        requires_backends(cls, 'torch')
"""
										SCREAMING_SNAKE_CASE           =					create_dummy_object("""FakeClass"""       ,     """'torch'"""			)
										self.assertEqual(a       ,     a			)







							def    _UpperCAmelCase     (					self       :	Union[str, Any]			)			->					Union[str, Any]:
										SCREAMING_SNAKE_CASE           =					"""# 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\"])

    @classmethod
    def from_config(cls, *args, **kwargs):
        requires_backends(cls, [\"torch\"])

    @classmethod
    def from_pretrained(cls, *args, **kwargs):
        requires_backends(cls, [\"torch\"])
"""
										SCREAMING_SNAKE_CASE           =					create_dummy_files({"""torch""": ["""CONSTANT""", """function""", """FakeClass"""]}			)
										self.assertEqual(dummy_files["""torch"""]       ,     a			)






