


import collections
import os
import re
from pathlib import Path


_snake_case  :	List[str]			      =       "src/transformers"


# Matches is_xxx_available()
_snake_case  :	int			      =       re.compile(R"is\_([a-z_]*)_available()")
# Catches a one-line _import_struct = {xxx}
_snake_case  :	Optional[Any]			      =       re.compile(R"^_import_structure\s+=\s+\{([^\}]+)\}")
# Catches a line with a key-values pattern: "bla": ["foo", "bar"]
_snake_case  :	Dict			      =       re.compile(R"\s+\"\S*\":\s+\[([^\]]*)\]")
# Catches a line if not is_foo_available
_snake_case  :	Dict			      =       re.compile(R"^\s*if\s+not\s+is\_[a-z_]*\_available\(\)")
# Catches a line _import_struct["bla"].append("foo")
_snake_case  :	Dict			      =       re.compile(R"^\s*_import_structure\[\"\S*\"\]\.append\(\"(\S*)\"\)")
# Catches a line _import_struct["bla"].extend(["foo", "bar"]) or _import_struct["bla"] = ["foo", "bar"]
_snake_case  :	str			      =       re.compile(R"^\s*_import_structure\[\S*\](?:\.extend\(|\s*=\s+)\[([^\]]*)\]")
# Catches a line with an object between quotes and a comma:     "MyModel",
_snake_case  :	Optional[int]			      =       re.compile(R"^\s+\"([^\"]+)\",")
# Catches a line with objects between brackets only:    ["foo", "bar"],
_snake_case  :	Optional[Any]			      =       re.compile(R"^\s+\[([^\]]+)\]")
# Catches a line with from foo import bar, bla, boo
_snake_case  :	Union[str, Any]			      =       re.compile(R"\s+from\s+\S*\s+import\s+([^\(\s].*)\n")
# Catches a line with try:
_snake_case  :	List[str]			      =       re.compile(R"^\s*try:")
# Catches a line with else:
_snake_case  :	Dict			      =       re.compile(R"^\s*else:")







def        lowerCAmelCase_  (      __lowerCamelCase			):
							if _re_test_backend.search(__lowerCamelCase			) is None:
														return None
							__snake_case	:    Any											=     [b[0] for b in _re_backend.findall(__lowerCamelCase			)]
							backends.sort()
							return "_and_".join(__lowerCamelCase			)







def        lowerCAmelCase_  (      __lowerCamelCase			):
							with open(__lowerCamelCase							,			"r"							,			encoding="utf-8"							,			newline="\n"			) as f:
														__snake_case	:    List[Any]											=     f.readlines()

							__snake_case	:    List[Any]											=     0
							while line_index < len(__lowerCamelCase			) and not lines[line_index].startswith("_import_structure = {"			):
														line_index += 1

							# If this is a traditional init, just return.
							if line_index >= len(__lowerCamelCase			):
														return None

							# First grab the objects without a specific backend in _import_structure
							__snake_case	:    str											=     []
							while not lines[line_index].startswith("if TYPE_CHECKING"			) and find_backend(lines[line_index]			) is None:
														__snake_case	:    List[Any]											=     lines[line_index]
														# If we have everything on a single line, let's deal with it.
														if _re_one_line_import_struct.search(__lowerCamelCase			):
																					__snake_case	:    List[str]											=     _re_one_line_import_struct.search(__lowerCamelCase			).groups()[0]
																					__snake_case	:    Dict											=     re.findall(R"\[([^\]]+)\]"							,			__lowerCamelCase			)
																					for imp in imports:
																												objects.extend([obj[1:-1] for obj in imp.split(", "			)]			)
																					line_index += 1
																					continue
														__snake_case	:    Any											=     _re_import_struct_key_value.search(__lowerCamelCase			)
														if single_line_import_search is not None:
																					__snake_case	:    List[Any]											=     [obj[1:-1] for obj in single_line_import_search.groups()[0].split(", "			) if len(__lowerCamelCase			) > 0]
																					objects.extend(__lowerCamelCase			)
														elif line.startswith(" " * 8 + "\""			):
																					objects.append(line[9:-3]			)
														line_index += 1

							__snake_case	:    Union[str, Any]											=     {"none": objects}
							# Let's continue with backend-specific objects in _import_structure
							while not lines[line_index].startswith("if TYPE_CHECKING"			):
														# If the line is an if not is_backend_available, we grab all objects associated.
														__snake_case	:    Any											=     find_backend(lines[line_index]			)
														# Check if the backend declaration is inside a try block:
														if _re_try.search(lines[line_index - 1]			) is None:
																					__snake_case	:    Union[str, Any]											=     None

														if backend is not None:
																					line_index += 1

																					# Scroll until we hit the else block of try-except-else
																					while _re_else.search(lines[line_index]			) is None:
																												line_index += 1

																					line_index += 1

																					__snake_case	:    int											=     []
																					# Until we unindent, add backend objects to the list
																					while len(lines[line_index]			) <= 1 or lines[line_index].startswith(" " * 4			):
																												__snake_case	:    Tuple											=     lines[line_index]
																												if _re_import_struct_add_one.search(__lowerCamelCase			) is not None:
																																			objects.append(_re_import_struct_add_one.search(__lowerCamelCase			).groups()[0]			)
																												elif _re_import_struct_add_many.search(__lowerCamelCase			) is not None:
																																			__snake_case	:    Any											=     _re_import_struct_add_many.search(__lowerCamelCase			).groups()[0].split(", "			)
																																			__snake_case	:    Optional[Any]											=     [obj[1:-1] for obj in imports if len(__lowerCamelCase			) > 0]
																																			objects.extend(__lowerCamelCase			)
																												elif _re_between_brackets.search(__lowerCamelCase			) is not None:
																																			__snake_case	:    List[str]											=     _re_between_brackets.search(__lowerCamelCase			).groups()[0].split(", "			)
																																			__snake_case	:    int											=     [obj[1:-1] for obj in imports if len(__lowerCamelCase			) > 0]
																																			objects.extend(__lowerCamelCase			)
																												elif _re_quote_object.search(__lowerCamelCase			) is not None:
																																			objects.append(_re_quote_object.search(__lowerCamelCase			).groups()[0]			)
																												elif line.startswith(" " * 8 + "\""			):
																																			objects.append(line[9:-3]			)
																												elif line.startswith(" " * 1_2 + "\""			):
																																			objects.append(line[1_3:-3]			)
																												line_index += 1

																					__snake_case	:    Any											=     objects
														else:
																					line_index += 1

    # At this stage we are in the TYPE_CHECKING part, first grab the objects without a specific backend
							__snake_case	:    int											=     []
							while (
							    line_index < len(__lowerCamelCase			)
							    and find_backend(lines[line_index]			) is None
							    and not lines[line_index].startswith("else"			)
							):
														__snake_case	:    str											=     lines[line_index]
														__snake_case	:    Optional[Any]											=     _re_import.search(__lowerCamelCase			)
														if single_line_import_search is not None:
																					objects.extend(single_line_import_search.groups()[0].split(", "			)			)
														elif line.startswith(" " * 8			):
																					objects.append(line[8:-2]			)
														line_index += 1

							__snake_case	:    Tuple											=     {"none": objects}
							# Let's continue with backend-specific objects
							while line_index < len(__lowerCamelCase			):
														# If the line is an if is_backend_available, we grab all objects associated.
														__snake_case	:    Any											=     find_backend(lines[line_index]			)
														# Check if the backend declaration is inside a try block:
														if _re_try.search(lines[line_index - 1]			) is None:
																					__snake_case	:    Optional[int]											=     None

														if backend is not None:
																					line_index += 1

																					# Scroll until we hit the else block of try-except-else
																					while _re_else.search(lines[line_index]			) is None:
																												line_index += 1

																					line_index += 1

																					__snake_case	:    Tuple											=     []
																					# Until we unindent, add backend objects to the list
																					while len(lines[line_index]			) <= 1 or lines[line_index].startswith(" " * 8			):
																												__snake_case	:    List[str]											=     lines[line_index]
																												__snake_case	:    List[Any]											=     _re_import.search(__lowerCamelCase			)
																												if single_line_import_search is not None:
																																			objects.extend(single_line_import_search.groups()[0].split(", "			)			)
																												elif line.startswith(" " * 1_2			):
																																			objects.append(line[1_2:-2]			)
																												line_index += 1

																					__snake_case	:    Dict											=     objects
														else:
																					line_index += 1

							return import_dict_objects, type_hint_objects







def        lowerCAmelCase_  (      __lowerCamelCase							,			__lowerCamelCase			):

							def find_duplicates(__lowerCamelCase			):
														return [k for k, v in collections.Counter(__lowerCamelCase			).items() if v > 1]

							if list(import_dict_objects.keys()			) != list(type_hint_objects.keys()			):
														return ["Both sides of the init do not have the same backends!"]

							__snake_case	:    Dict											=     []
							for key in import_dict_objects.keys():
														__snake_case	:    Optional[Any]											=     find_duplicates(import_dict_objects[key]			)
														if duplicate_imports:
																					errors.append(F'Duplicate _import_structure definitions for: {duplicate_imports}'			)
														__snake_case	:    Union[str, Any]											=     find_duplicates(type_hint_objects[key]			)
														if duplicate_type_hints:
																					errors.append(F'Duplicate TYPE_CHECKING objects for: {duplicate_type_hints}'			)

														if sorted(set(import_dict_objects[key]			)			) != sorted(set(type_hint_objects[key]			)			):
																					__snake_case	:    Any											=     "base imports" if key == "none" else F'{key} backend'
																					errors.append(F'Differences for {name}:'			)
																					for a in type_hint_objects[key]:
																												if a not in import_dict_objects[key]:
																																			errors.append(F'  {a} in TYPE_HINT but not in _import_structure.'			)
																					for a in import_dict_objects[key]:
																												if a not in type_hint_objects[key]:
																																			errors.append(F'  {a} in _import_structure but not in TYPE_HINT.'			)
							return errors







def        lowerCAmelCase_  (      ):
							__snake_case	:    Optional[Any]											=     []
							for root, _, files in os.walk(__lowerCamelCase			):
														if "__init__.py" in files:
																					__snake_case	:    List[Any]											=     os.path.join(__lowerCamelCase							,			"__init__.py"			)
																					__snake_case	:    Tuple											=     parse_init(__lowerCamelCase			)
																					if objects is not None:
																												__snake_case	:    Tuple											=     analyze_results(*__lowerCamelCase			)
																												if len(__lowerCamelCase			) > 0:
																																			__snake_case	:    Any											=     F'Problem in {fname}, both halves do not define the same objects.\n{errors[0]}'
																																			failures.append("\n".join(__lowerCamelCase			)			)
							if len(__lowerCamelCase			) > 0:
														raise ValueError("\n\n".join(__lowerCamelCase			)			)







def        lowerCAmelCase_  (      ):
							__snake_case	:    List[str]											=     []
							for path, directories, files in os.walk(__lowerCamelCase			):
														for folder in directories:
																					# Ignore private modules
																					if folder.startswith("_"			):
																												directories.remove(__lowerCamelCase			)
																												continue
																					# Ignore leftovers from branches (empty folders apart from pycache)
																					if len(list((Path(__lowerCamelCase			) / folder).glob("*.py"			)			)			) == 0:
																												continue
																					__snake_case	:    Optional[Any]											=     str((Path(__lowerCamelCase			) / folder).relative_to(__lowerCamelCase			)			)
																					__snake_case	:    str											=     short_path.replace(os.path.sep							,			"."			)
																					submodules.append(__lowerCamelCase			)
														for fname in files:
																					if fname == "__init__.py":
																												continue
																					__snake_case	:    List[str]											=     str((Path(__lowerCamelCase			) / fname).relative_to(__lowerCamelCase			)			)
																					__snake_case	:    List[str]											=     short_path.replace(".py"							,			""			).replace(os.path.sep							,			"."			)
																					if len(submodule.split("."			)			) == 1:
																												submodules.append(__lowerCamelCase			)
							return submodules


_snake_case  :	Dict			      =       [
    "convert_pytorch_checkpoint_to_tf2",
    "modeling_flax_pytorch_utils",
    "models.esm.openfold_utils",
]







def        lowerCAmelCase_  (      ):
							# This is to make sure the transformers module imported is the one in the repo.
							from transformers.utils import direct_transformers_import

							__snake_case	:    Optional[int]											=     direct_transformers_import(__lowerCamelCase			)

							__snake_case	:    List[Any]											=     set(transformers._import_structure.keys()			)
							# This contains all the base keys of the _import_structure object defined in the init, but if the user is missing
							# some optional dependencies, they may not have all of them. Thus we read the init to read all additions and
							# (potentiall re-) add them.
							with open(os.path.join(__lowerCamelCase							,			"__init__.py"			)							,			"r"			) as f:
														__snake_case	:    Tuple											=     f.read()
							import_structure_keys.update(set(re.findall(R"import_structure\[\"([^\"]*)\"\]"							,			__lowerCamelCase			)			)			)

							__snake_case	:    Any											=     [
							    module
							    for module in get_transformers_submodules()
							    if module not in IGNORE_SUBMODULES and module not in import_structure_keys
							]

							if len(__lowerCamelCase			) > 0:
														__snake_case	:    List[Any]											=     "\n".join(F'- {module}' for module in module_not_registered			)
														raise ValueError(
														    "The following submodules are not properly registed in the main init of Transformers:\n"
														    F'{list_of_modules}\n'
														    "Make sure they appear somewhere in the keys of `_import_structure` with an empty list as value."			)


if __name__ == "__main__":
			check_all_inits()
			check_submodules()





import unittest

from transformers import (
    MODEL_FOR_SEQUENCE_CLASSIFICATION_MAPPING,
    TF_MODEL_FOR_SEQUENCE_CLASSIFICATION_MAPPING,
    TextClassificationPipeline,
    pipeline,
)
from transformers.testing_utils import is_pipeline_test, nested_simplify, require_tf, require_torch, slow

from .test_pipelines_common import ANY


# These 2 model types require different inputs than those of the usual text models.
_snake_case  :	Dict			      =       {"LayoutLMv2Config", "LayoutLMv3Config"}

@is_pipeline_test
class        a	(unittest.TestCase   ):




							"""simple docstring"""


							__UpperCAmelCase					:							Union[str, Any]  						=						MODEL_FOR_SEQUENCE_CLASSIFICATION_MAPPING
							__UpperCAmelCase					:							Optional[int]  						=						TF_MODEL_FOR_SEQUENCE_CLASSIFICATION_MAPPING

							if model_mapping is not None:
														__UpperCAmelCase					:							Optional[int]  						=						{config: model for config, model in model_mapping.items() if config.__name__ not in _TO_SKIP}
							if tf_model_mapping is not None:
														__UpperCAmelCase					:							Any  						=						{
														    config: model for config, model in tf_model_mapping.items() if config.__name__ not in _TO_SKIP
														}

							@require_torch
							def 					__snake_case      (							self :						str       )			->					str:
														__snake_case	:    Dict											=     pipeline(
														    task="text-classification"					,			model="hf-internal-testing/tiny-random-distilbert"					,			framework="pt"       )

														__snake_case	:    Optional[Any]											=     text_classifier("This is great !"       )
														self.assertEqual(nested_simplify(lowerCamelCase       )					,			[{"label": "LABEL_0", "score": 0.5_04}]       )

														__snake_case	:    Any											=     text_classifier("This is great !"					,			top_k=2       )
														self.assertEqual(
														    nested_simplify(lowerCamelCase       )					,			[{"label": "LABEL_0", "score": 0.5_04}, {"label": "LABEL_1", "score": 0.4_96}]       )

														__snake_case	:    int											=     text_classifier(["This is great !", "This is bad"]					,			top_k=2       )
														self.assertEqual(
														    nested_simplify(lowerCamelCase       )					,			[
														        [{"label": "LABEL_0", "score": 0.5_04}, {"label": "LABEL_1", "score": 0.4_96}],
														        [{"label": "LABEL_0", "score": 0.5_04}, {"label": "LABEL_1", "score": 0.4_96}],
														    ]					,			)

														__snake_case	:    List[str]											=     text_classifier("This is great !"					,			top_k=1       )
														self.assertEqual(nested_simplify(lowerCamelCase       )					,			[{"label": "LABEL_0", "score": 0.5_04}]       )

														# Legacy behavior
														__snake_case	:    Dict											=     text_classifier("This is great !"					,			return_all_scores=lowerCamelCase       )
														self.assertEqual(nested_simplify(lowerCamelCase       )					,			[{"label": "LABEL_0", "score": 0.5_04}]       )

														__snake_case	:    Any											=     text_classifier("This is great !"					,			return_all_scores=lowerCamelCase       )
														self.assertEqual(
														    nested_simplify(lowerCamelCase       )					,			[[{"label": "LABEL_0", "score": 0.5_04}, {"label": "LABEL_1", "score": 0.4_96}]]       )

														__snake_case	:    Tuple											=     text_classifier(["This is great !", "Something else"]					,			return_all_scores=lowerCamelCase       )
														self.assertEqual(
														    nested_simplify(lowerCamelCase       )					,			[
														        [{"label": "LABEL_0", "score": 0.5_04}, {"label": "LABEL_1", "score": 0.4_96}],
														        [{"label": "LABEL_0", "score": 0.5_04}, {"label": "LABEL_1", "score": 0.4_96}],
														    ]					,			)

														__snake_case	:    Tuple											=     text_classifier(["This is great !", "Something else"]					,			return_all_scores=lowerCamelCase       )
														self.assertEqual(
														    nested_simplify(lowerCamelCase       )					,			[
														        {"label": "LABEL_0", "score": 0.5_04},
														        {"label": "LABEL_0", "score": 0.5_04},
														    ]					,			)

							@require_torch
							def 					__snake_case      (							self :						Optional[int]       )			->					List[Any]:
														import torch

														__snake_case	:    Dict											=     pipeline(
														    task="text-classification"					,			model="hf-internal-testing/tiny-random-distilbert"					,			framework="pt"					,			device=torch.device("cpu"       )					,			)

														__snake_case	:    Optional[int]											=     text_classifier("This is great !"       )
														self.assertEqual(nested_simplify(lowerCamelCase       )					,			[{"label": "LABEL_0", "score": 0.5_04}]       )

							@require_tf
							def 					__snake_case      (							self :						Any       )			->					Tuple:
														__snake_case	:    List[Any]											=     pipeline(
														    task="text-classification"					,			model="hf-internal-testing/tiny-random-distilbert"					,			framework="tf"       )

														__snake_case	:    str											=     text_classifier("This is great !"       )
														self.assertEqual(nested_simplify(lowerCamelCase       )					,			[{"label": "LABEL_0", "score": 0.5_04}]       )

							@slow
							@require_torch
							def 					__snake_case      (							self :						int       )			->					int:
														__snake_case	:    Dict											=     pipeline("text-classification"       )

														__snake_case	:    Dict											=     text_classifier("This is great !"       )
														self.assertEqual(nested_simplify(lowerCamelCase       )					,			[{"label": "POSITIVE", "score": 1.0}]       )
														__snake_case	:    int											=     text_classifier("This is bad !"       )
														self.assertEqual(nested_simplify(lowerCamelCase       )					,			[{"label": "NEGATIVE", "score": 1.0}]       )
														__snake_case	:    str											=     text_classifier("Birds are a type of animal"       )
														self.assertEqual(nested_simplify(lowerCamelCase       )					,			[{"label": "POSITIVE", "score": 0.9_88}]       )

							@slow
							@require_tf
							def 					__snake_case      (							self :						List[Any]       )			->					str:
														__snake_case	:    Optional[Any]											=     pipeline("text-classification"					,			framework="tf"       )

														__snake_case	:    Any											=     text_classifier("This is great !"       )
														self.assertEqual(nested_simplify(lowerCamelCase       )					,			[{"label": "POSITIVE", "score": 1.0}]       )
														__snake_case	:    Optional[int]											=     text_classifier("This is bad !"       )
														self.assertEqual(nested_simplify(lowerCamelCase       )					,			[{"label": "NEGATIVE", "score": 1.0}]       )
														__snake_case	:    Any											=     text_classifier("Birds are a type of animal"       )
														self.assertEqual(nested_simplify(lowerCamelCase       )					,			[{"label": "POSITIVE", "score": 0.9_88}]       )

							def 					__snake_case      (							self :						str					,			lowerCamelCase :						Tuple					,			lowerCamelCase :						Any					,			lowerCamelCase :						Union[str, Any]       )			->					List[Any]:
														__snake_case	:    Union[str, Any]											=     TextClassificationPipeline(model=lowerCamelCase					,			tokenizer=lowerCamelCase       )
														return text_classifier, ["HuggingFace is in", "This is another test"]






							def 					__snake_case      (							self :						List[str]					,			lowerCamelCase :						Optional[Any]					,			lowerCamelCase :						Tuple       )			->					str:
														__snake_case	:    Tuple											=     text_classifier.model
														# Small inputs because BartTokenizer tiny has maximum position embeddings = 22
														__snake_case	:    Any											=     "HuggingFace is in"
														__snake_case	:    Tuple											=     text_classifier(lowerCamelCase       )

														self.assertEqual(nested_simplify(lowerCamelCase       )					,			[{"label": ANY(lowerCamelCase       ), "score": ANY(lowerCamelCase       )}]       )
														self.assertTrue(outputs[0]["label"] in model.config.idalabel.values()       )

														__snake_case	:    Union[str, Any]											=     ["HuggingFace is in ", "Paris is in France"]
														__snake_case	:    Union[str, Any]											=     text_classifier(lowerCamelCase       )
														self.assertEqual(
														    nested_simplify(lowerCamelCase       )					,			[{"label": ANY(lowerCamelCase       ), "score": ANY(lowerCamelCase       )}, {"label": ANY(lowerCamelCase       ), "score": ANY(lowerCamelCase       )}]					,			)
														self.assertTrue(outputs[0]["label"] in model.config.idalabel.values()       )
														self.assertTrue(outputs[1]["label"] in model.config.idalabel.values()       )

														# Forcing to get all results with `top_k=None`
														# This is NOT the legacy format
														__snake_case	:    str											=     text_classifier(lowerCamelCase					,			top_k=lowerCamelCase       )
														__snake_case	:    int											=     len(model.config.idalabel.values()       )
														self.assertEqual(
														    nested_simplify(lowerCamelCase       )					,			[[{"label": ANY(lowerCamelCase       ), "score": ANY(lowerCamelCase       )}] * N, [{"label": ANY(lowerCamelCase       ), "score": ANY(lowerCamelCase       )}] * N]					,			)

														__snake_case	:    Optional[int]											=     {"text": "HuggingFace is in ", "text_pair": "Paris is in France"}
														__snake_case	:    Optional[Any]											=     text_classifier(lowerCamelCase       )
														self.assertEqual(
														    nested_simplify(lowerCamelCase       )					,			{"label": ANY(lowerCamelCase       ), "score": ANY(lowerCamelCase       )}					,			)
														self.assertTrue(outputs["label"] in model.config.idalabel.values()       )

														# This might be used a text pair, but tokenizer + pipe interaction
														# makes it hard to understand that it's not using the pair properly
														# https://github.com/huggingface/transformers/issues/17305
														# We disabled this usage instead as it was outputting wrong outputs.
														__snake_case	:    Any											=     [["HuggingFace is in ", "Paris is in France"]]
														with self.assertRaises(lowerCamelCase       ):
																					text_classifier(lowerCamelCase       )

														# This used to be valid for doing text pairs
														# We're keeping it working because of backward compatibility
														__snake_case	:    List[Any]											=     text_classifier([[["HuggingFace is in ", "Paris is in France"]]]       )
														self.assertEqual(
														    nested_simplify(lowerCamelCase       )					,			[{"label": ANY(lowerCamelCase       ), "score": ANY(lowerCamelCase       )}]					,			)
														self.assertTrue(outputs[0]["label"] in model.config.idalabel.values()       )

