




import collections
import importlib.util
import os
import re
from pathlib import Path


lowerCamelCase    :		str			   =       "src/transformers"


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

def       _SCREAMING_SNAKE_CASE      (							lowercase     :	Optional[Any]					):


						'''simple docstring'''



						if _re_test_backend.search(lowercase					) is None:
												return None
						lowerCamelCase_							=   [b[0] for b in _re_backend.findall(lowercase					)]
						backends.sort()
						return "_and_".join(lowercase					)

def       _SCREAMING_SNAKE_CASE      (							lowercase     :	Optional[int]					):


						'''simple docstring'''



						with open(lowercase     ,							'r'     ,							encoding='utf-8'     ,							newline='\n'					) as f:
												lowerCamelCase_							=   f.readlines()

						lowerCamelCase_							=   0
						while line_index < len(lowercase					) and not lines[line_index].startswith('_import_structure = {'					):
												line_index += 1

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

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

						lowerCamelCase_							=   {'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.
												lowerCamelCase_							=   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:
																		lowerCamelCase_							=   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

																		lowerCamelCase_							=   []
																		# Until we unindent, add backend objects to the list
																		while len(lines[line_index]					) <= 1 or lines[line_index].startswith(' ' * 4					):
																								lowerCamelCase_							=   lines[line_index]
																								if _re_import_struct_add_one.search(lowercase					) is not None:
																														objects.append(_re_import_struct_add_one.search(lowercase					).groups()[0]					)
																								elif _re_import_struct_add_many.search(lowercase					) is not None:
																														lowerCamelCase_							=   _re_import_struct_add_many.search(lowercase					).groups()[0].split(', '					)
																														lowerCamelCase_							=   [obj[1:-1] for obj in imports if len(lowercase					) > 0]
																														objects.extend(lowercase					)
																								elif _re_between_brackets.search(lowercase					) is not None:
																														lowerCamelCase_							=   _re_between_brackets.search(lowercase					).groups()[0].split(', '					)
																														lowerCamelCase_							=   [obj[1:-1] for obj in imports if len(lowercase					) > 0]
																														objects.extend(lowercase					)
																								elif _re_quote_object.search(lowercase					) is not None:
																														objects.append(_re_quote_object.search(lowercase					).groups()[0]					)
																								elif line.startswith(' ' * 8 + '"'					):
																														objects.append(line[9:-3]					)
																								elif line.startswith(' ' * 12 + '"'					):
																														objects.append(line[13:-3]					)
																								line_index += 1

																		lowerCamelCase_							=   objects
												else:
																		line_index += 1

    # At this stage we are in the TYPE_CHECKING part, first grab the objects without a specific backend
						lowerCamelCase_							=   []
						while (
						    line_index < len(lowercase					)
						    and find_backend(lines[line_index]					) is None
						    and not lines[line_index].startswith('else'					)
						):
												lowerCamelCase_							=   lines[line_index]
												lowerCamelCase_							=   _re_import.search(lowercase					)
												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

						lowerCamelCase_							=   {'none': objects}
						# Let's continue with backend-specific objects
						while line_index < len(lowercase					):
												# If the line is an if is_backend_available, we grab all objects associated.
												lowerCamelCase_							=   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:
																		lowerCamelCase_							=   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

																		lowerCamelCase_							=   []
																		# Until we unindent, add backend objects to the list
																		while len(lines[line_index]					) <= 1 or lines[line_index].startswith(' ' * 8					):
																								lowerCamelCase_							=   lines[line_index]
																								lowerCamelCase_							=   _re_import.search(lowercase					)
																								if single_line_import_search is not None:
																														objects.extend(single_line_import_search.groups()[0].split(', '					)					)
																								elif line.startswith(' ' * 12					):
																														objects.append(line[12:-2]					)
																								line_index += 1

																		lowerCamelCase_							=   objects
												else:
																		line_index += 1

						return import_dict_objects, type_hint_objects

def       _SCREAMING_SNAKE_CASE      (							lowercase     :	Optional[int]     ,							lowercase     :	Any					):


						'''simple docstring'''



						def find_duplicates(lowercase     :	Tuple					):
												return [k for k, v in collections.Counter(lowercase					).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!"]

						lowerCamelCase_							=   []
						for key in import_dict_objects.keys():
												lowerCamelCase_							=   find_duplicates(import_dict_objects[key]					)
												if duplicate_imports:
																		errors.append(f"""Duplicate _import_structure definitions for: {duplicate_imports}"""					)
												lowerCamelCase_							=   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]					)					):
																		lowerCamelCase_							=   '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       _SCREAMING_SNAKE_CASE      (							):


						'''simple docstring'''



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

def       _SCREAMING_SNAKE_CASE      (							):


						'''simple docstring'''



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


lowerCamelCase    :		Optional[int]			   =       [
    "convert_pytorch_checkpoint_to_tf2",
    "modeling_flax_pytorch_utils",
]

def       _SCREAMING_SNAKE_CASE      (							):


						'''simple docstring'''



						lowerCamelCase_							=   importlib.util.spec_from_file_location(
						    'transformers'     ,							os.path.join(lowercase     ,							'__init__.py'					)     ,							submodule_search_locations=[PATH_TO_TRANSFORMERS]     ,							)
						lowerCamelCase_							=   spec.loader.load_module()

						lowerCamelCase_							=   [
						    module
						    for module in get_transformers_submodules()
						    if module not in IGNORE_SUBMODULES and module not in transformers._import_structure.keys()
						]
						if len(lowercase					) > 0:
												lowerCamelCase_							=   '\n'.join(f"""- {module}""" for module in module_not_registered					)
												raise ValueError(
												    'The following submodules are not properly registered 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 warnings
from typing import List

import numpy as np

from ...processing_utils import ProcessorMixin
from ...tokenization_utils_base import BatchEncoding
from ...utils import is_flax_available, is_tf_available, is_torch_available







class   A(						UpperCamelCase       ):



 '''simple docstring'''


 UpperCamelCase						       =						['''image_processor''', '''tokenizer''']
 UpperCamelCase						       =						'''OwlViTImageProcessor'''
 UpperCamelCase						       =						('''CLIPTokenizer''', '''CLIPTokenizerFast''')

 def __init__(    self :  Optional[Any]						,							A_ :  Tuple=None						,							A_ :  Tuple=None						,							**A_ :  List[str]  )       ->     Any:

       """simple docstring"""






       lowerCamelCase_							=   None
       if "feature_extractor" in kwargs:
             warnings.warn(
                 'The `feature_extractor` argument is deprecated and will be removed in v5, use `image_processor`'
                 ' instead.'						,							A_						,							)
             lowerCamelCase_							=   kwargs.pop('feature_extractor'  )

       lowerCamelCase_							=   image_processor if image_processor is not None else feature_extractor
       if image_processor is None:
             raise ValueError('You need to specify an `image_processor`.'  )
       if tokenizer is None:
             raise ValueError('You need to specify a `tokenizer`.'  )

       super().__init__(A_						,							A_  )

 def __call__(    self :  List[str]						,							A_ :  List[str]=None						,							A_ :  List[Any]=None						,							A_ :  Dict=None						,							A_ :  Tuple="max_length"						,							A_ :  int="np"						,							**A_ :  Union[str, Any]  )       ->     Union[str, Any]:

       """simple docstring"""






       if text is None and query_images is None and images is None:
             raise ValueError(
                 'You have to specify at least one text or query image or image. All three cannot be none.'  )

       if text is not None:
             if isinstance(A_						,							A_  ) or (isinstance(A_						,							A_  ) and not isinstance(text[0]						,							A_  )):
                   lowerCamelCase_							=   [self.tokenizer(A_						,							padding=A_						,							return_tensors=A_						,							**A_  )]

             elif isinstance(A_						,							A_  ) and isinstance(text[0]						,							A_  ):
                   lowerCamelCase_							=   []

                   # Maximum number of queries across batch
                   lowerCamelCase_							=   max([len(A_  ) for t in text]  )

                   # Pad all batch samples to max number of text queries
                   for t in text:
                         if len(A_  ) != max_num_queries:
                               lowerCamelCase_							=   t + [' '] * (max_num_queries - len(A_  ))

                         lowerCamelCase_							=   self.tokenizer(A_						,							padding=A_						,							return_tensors=A_						,							**A_  )
                         encodings.append(A_  )
             else:
                   raise TypeError('Input text should be a string, a list of strings or a nested list of strings'  )

             if return_tensors == "np":
                   lowerCamelCase_							=   np.concatenate([encoding['input_ids'] for encoding in encodings]						,							axis=0  )
                   lowerCamelCase_							=   np.concatenate([encoding['attention_mask'] for encoding in encodings]						,							axis=0  )

             elif return_tensors == "jax" and is_flax_available():
                   import jax.numpy as jnp

                   lowerCamelCase_							=   jnp.concatenate([encoding['input_ids'] for encoding in encodings]						,							axis=0  )
                   lowerCamelCase_							=   jnp.concatenate([encoding['attention_mask'] for encoding in encodings]						,							axis=0  )

             elif return_tensors == "pt" and is_torch_available():
                   import torch

                   lowerCamelCase_							=   torch.cat([encoding['input_ids'] for encoding in encodings]						,							dim=0  )
                   lowerCamelCase_							=   torch.cat([encoding['attention_mask'] for encoding in encodings]						,							dim=0  )

             elif return_tensors == "tf" and is_tf_available():
                   import tensorflow as tf

                   lowerCamelCase_							=   tf.stack([encoding['input_ids'] for encoding in encodings]						,							axis=0  )
                   lowerCamelCase_							=   tf.stack([encoding['attention_mask'] for encoding in encodings]						,							axis=0  )

             else:
                   raise ValueError('Target return tensor type could not be returned'  )

             lowerCamelCase_							=   BatchEncoding()
             lowerCamelCase_							=   input_ids
             lowerCamelCase_							=   attention_mask

       if query_images is not None:
             lowerCamelCase_							=   BatchEncoding()
             lowerCamelCase_							=   self.image_processor(
                 A_						,							return_tensors=A_						,							**A_  ).pixel_values
             lowerCamelCase_							=   query_pixel_values

       if images is not None:
             lowerCamelCase_							=   self.image_processor(A_						,							return_tensors=A_						,							**A_  )

       if text is not None and images is not None:
             lowerCamelCase_							=   image_features.pixel_values
             return encoding
       elif query_images is not None and images is not None:
             lowerCamelCase_							=   image_features.pixel_values
             return encoding
       elif text is not None or query_images is not None:
             return encoding
       else:
             return BatchEncoding(data=dict(**A_  )						,							tensor_type=A_  )

 def     a__			(    self :  Tuple						,							*A_ :  Dict						,							**A_ :  Dict  )       ->     Any:

       """simple docstring"""






       return self.image_processor.post_process(*A_						,							**A_  )

 def     a__			(    self :  List[str]						,							*A_ :  Any						,							**A_ :  List[Any]  )       ->     Optional[int]:

       """simple docstring"""






       return self.image_processor.post_process_object_detection(*A_						,							**A_  )

 def     a__			(    self :  Any						,							*A_ :  str						,							**A_ :  List[Any]  )       ->     Any:

       """simple docstring"""






       return self.image_processor.post_process_image_guided_detection(*A_						,							**A_  )

 def     a__			(    self :  Union[str, Any]						,							*A_ :  Any						,							**A_ :  Union[str, Any]  )       ->     str:

       """simple docstring"""






       return self.tokenizer.batch_decode(*A_						,							**A_  )

 def     a__			(    self :  Optional[int]						,							*A_ :  List[Any]						,							**A_ :  int  )       ->     int:

       """simple docstring"""






       return self.tokenizer.decode(*A_						,							**A_  )

 @property
 def     a__			(    self :  List[Any]  )       ->     List[Any]:

       """simple docstring"""






       warnings.warn(
           '`feature_extractor_class` is deprecated and will be removed in v5. Use `image_processor_class` instead.'						,							A_						,							)
       return self.image_processor_class





 @property
 def     a__			(    self :  str  )       ->     List[str]:

       """simple docstring"""






       warnings.warn(
           '`feature_extractor` is deprecated and will be removed in v5. Use `image_processor` instead.'						,							A_						,							)
       return self.image_processor



