





import os
import sys
import tempfile

import torch

from .state import AcceleratorState
from .utils import PrecisionType, PrepareForLaunch, is_mps_available, patch_environment


def  SCREAMING_SNAKE_CASE   ( _UpperCAmelCase		,			_UpperCAmelCase=()		,			_UpperCAmelCase=None		,			_UpperCAmelCase="no"		,			_UpperCAmelCase="29500"				)    ->  str:
    lowerCamelCase__					:   int      				=	False
    lowerCamelCase__					:   Tuple      				=	False
    if any(key.startswith('KAGGLE'				) for key in os.environ.keys()				):
        lowerCamelCase__					:   Optional[Any]      				=	True
    elif "IPython" in sys.modules:
        lowerCamelCase__					:   int      				=	'google.colab' in str(sys.modules['IPython'].get_ipython()				)

    try:
        lowerCamelCase__					:   Any      				=	PrecisionType(mixed_precision.lower()				)
    except ValueError:
        raise ValueError(
            F"""Unknown mixed_precision mode: {args.mixed_precision.lower()}. Choose between {PrecisionType.list()}."""				)

    if (in_colab or in_kaggle) and (os.environ.get('TPU_NAME'		,			_UpperCAmelCase				) is not None):
        # TPU launch
        import torch_xla.distributed.xla_multiprocessing as xmp

        if len(AcceleratorState._shared_state				) > 0:
            raise ValueError(
                'To train on TPU in Colab or Kaggle Kernel, the `Accelerator` should only be initialized inside '
                'your training function. Restart your notebook and make sure no cells initializes an '
                '`Accelerator`.'				)
        if num_processes is None:
            lowerCamelCase__					:   List[Any]      				=	8

        lowerCamelCase__					:   Dict      				=	PrepareForLaunch(_UpperCAmelCase		,			distributed_type='TPU'				)
        print(F"""Launching a training on {num_processes} TPU cores."""				)
        xmp.spawn(_UpperCAmelCase		,			args=_UpperCAmelCase		,			nprocs=_UpperCAmelCase		,			start_method='fork'				)
    elif in_colab:
        # No need for a distributed launch otherwise as it's either CPU or one GPU.
        if torch.cuda.is_available():
            print('Launching training on one GPU.'				)
        else:
            print('Launching training on one CPU.'				)
        function(*_UpperCAmelCase				)
    else:
        if num_processes is None:
            raise ValueError(
                'You have to specify the number of GPUs you would like to use, add `num_processes=...` to your call.'				)

        if num_processes > 1:
            # Multi-GPU launch
            from torch.multiprocessing import start_processes
            from torch.multiprocessing.spawn import ProcessRaisedException

            if len(AcceleratorState._shared_state				) > 0:
                raise ValueError(
                    'To launch a multi-GPU training from your notebook, the `Accelerator` should only be initialized '
                    'inside your training function. Restart your notebook and make sure no cells initializes an '
                    '`Accelerator`.'				)

            if torch.cuda.is_initialized():
                raise ValueError(
                    'To launch a multi-GPU training from your notebook, you need to avoid running any instruction '
                    'using `torch.cuda` in any cell. Restart your notebook and make sure no cells use any CUDA '
                    'function.'				)

            # torch.distributed will expect a few environment variable to be here. We set the ones common to each
            # process here (the other ones will be set be the launcher).
            with patch_environment(
                world_size=_UpperCAmelCase		,			master_addr='127.0.01'		,			master_port=_UpperCAmelCase		,			mixed_precision=_UpperCAmelCase				):
                lowerCamelCase__					:   Optional[Any]      				=	PrepareForLaunch(_UpperCAmelCase		,			distributed_type='MULTI_GPU'				)
                print(F"""Launching training on {num_processes} GPUs."""				)
                try:
                    start_processes(_UpperCAmelCase		,			args=_UpperCAmelCase		,			nprocs=_UpperCAmelCase		,			start_method='fork'				)
                except ProcessRaisedException as e:
                    if "Cannot re-initialize CUDA in forked subprocess" in e.args[0]:
                        raise RuntimeError(
                            'CUDA has been initialized before the `notebook_launcher` could create a forked subprocess. '
                            'This likely stems from an outside import causing issues once the `notebook_launcher()` is called. '
                            'Please review your imports and test them when running the `notebook_launcher()` to identify '
                            'which one is problematic.'				) from e

        else:
            # No need for a distributed launch otherwise as it's either CPU, GPU or MPS.
            if is_mps_available():
                lowerCamelCase__					:   Dict      				=	'1'
                print('Launching training on MPS.'				)
            elif torch.cuda.is_available():
                print('Launching training on one GPU.'				)
            else:
                print('Launching training on CPU.'				)
            function(*_UpperCAmelCase				)


def  SCREAMING_SNAKE_CASE   ( _UpperCAmelCase		,			_UpperCAmelCase=()		,			_UpperCAmelCase=2				)    ->  str:
    from torch.multiprocessing import start_processes

    with tempfile.NamedTemporaryFile() as tmp_file:
        # torch.distributed will expect a few environment variable to be here. We set the ones common to each
        # process here (the other ones will be set be the launcher).
        with patch_environment(
            world_size=_UpperCAmelCase		,			master_addr='127.0.01'		,			master_port='29500'		,			accelerate_mixed_precision='no'		,			accelerate_debug_rdv_file=tmp_file.name		,			accelerate_use_cpu='yes'		,			):
            lowerCamelCase__					:   List[Any]      				=	PrepareForLaunch(_UpperCAmelCase		,			debug=_UpperCAmelCase				)
            start_processes(_UpperCAmelCase		,			args=_UpperCAmelCase		,			nprocs=_UpperCAmelCase		,			start_method='fork'				)












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      lowerCAmelCase							(      __UpperCamelCase    ):
 UpperCAmelCase__									=	["""image_processor""", """tokenizer"""]
 UpperCAmelCase__									=	"""OwlViTImageProcessor"""
 UpperCAmelCase__									=	("""CLIPTokenizer""", """CLIPTokenizerFast""")
 def __init__(   self						:   Optional[int]    ,  UpperCAmelCase						:   str=None    ,  UpperCAmelCase						:   Any=None    ,  **UpperCAmelCase						:   Optional[Any]			)    ->			Dict:
     lowerCamelCase__					:   Any      				=	None
     if "feature_extractor" in kwargs:
         warnings.warn(
             'The `feature_extractor` argument is deprecated and will be removed in v5, use `image_processor`'
             ' instead.'    ,  UpperCAmelCase    ,  )
         lowerCamelCase__					:   Optional[Any]      				=	kwargs.pop('feature_extractor'			)

     lowerCamelCase__					:   Dict      				=	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__(UpperCAmelCase    ,  UpperCAmelCase			)
 def __call__(   self						:   List[Any]    ,  UpperCAmelCase						:   List[Any]=None    ,  UpperCAmelCase						:   Tuple=None    ,  UpperCAmelCase						:   int=None    ,  UpperCAmelCase						:   Optional[int]="max_length"    ,  UpperCAmelCase						:   Dict="np"    ,  **UpperCAmelCase						:   Union[str, Any]			)    ->			Union[str, Any]:

     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(UpperCAmelCase    ,  UpperCAmelCase			) or (isinstance(UpperCAmelCase    ,  UpperCAmelCase			) and not isinstance(text[0]    ,  UpperCAmelCase			)):
             lowerCamelCase__					:   Any      				=	[self.tokenizer(UpperCAmelCase    ,  padding=UpperCAmelCase    ,  return_tensors=UpperCAmelCase    ,  **UpperCAmelCase			)]

         elif isinstance(UpperCAmelCase    ,  UpperCAmelCase			) and isinstance(text[0]    ,  UpperCAmelCase			):
             lowerCamelCase__					:   List[str]      				=	[]

             # Maximum number of queries across batch
             lowerCamelCase__					:   List[Any]      				=	max([len(UpperCAmelCase			) for t in text]			)

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

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

         if return_tensors == "np":
             lowerCamelCase__					:   Optional[Any]      				=	np.concatenate([encoding['input_ids'] for encoding in encodings]    ,  axis=0			)
             lowerCamelCase__					:   int      				=	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__					:   Optional[int]      				=	jnp.concatenate([encoding['input_ids'] for encoding in encodings]    ,  axis=0			)
             lowerCamelCase__					:   Any      				=	jnp.concatenate([encoding['attention_mask'] for encoding in encodings]    ,  axis=0			)

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

             lowerCamelCase__					:   Union[str, Any]      				=	torch.cat([encoding['input_ids'] for encoding in encodings]    ,  dim=0			)
             lowerCamelCase__					:   Dict      				=	torch.cat([encoding['attention_mask'] for encoding in encodings]    ,  dim=0			)

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

             lowerCamelCase__					:   Any      				=	tf.stack([encoding['input_ids'] for encoding in encodings]    ,  axis=0			)
             lowerCamelCase__					:   Optional[int]      				=	tf.stack([encoding['attention_mask'] for encoding in encodings]    ,  axis=0			)

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

         lowerCamelCase__					:   str      				=	BatchEncoding()
         lowerCamelCase__					:   int      				=	input_ids
         lowerCamelCase__					:   Any      				=	attention_mask

     if query_images is not None:
         lowerCamelCase__					:   Union[str, Any]      				=	BatchEncoding()
         lowerCamelCase__					:   Optional[Any]      				=	self.image_processor(
             UpperCAmelCase    ,  return_tensors=UpperCAmelCase    ,  **UpperCAmelCase			).pixel_values
         lowerCamelCase__					:   List[Any]      				=	query_pixel_values

     if images is not None:
         lowerCamelCase__					:   List[Any]      				=	self.image_processor(UpperCAmelCase    ,  return_tensors=UpperCAmelCase    ,  **UpperCAmelCase			)

     if text is not None and images is not None:
         lowerCamelCase__					:   Tuple      				=	image_features.pixel_values
         return encoding
     elif query_images is not None and images is not None:
         lowerCamelCase__					:   Dict      				=	image_features.pixel_values
         return encoding
     elif text is not None or query_images is not None:
         return encoding
     else:
         return BatchEncoding(data=dict(**UpperCAmelCase			)    ,  tensor_type=UpperCAmelCase			)
 def   A_			(   self						:   str    ,  *UpperCAmelCase						:   Dict    ,  **UpperCAmelCase						:   List[Any]			)    ->			Any:
     return self.image_processor.post_process(*UpperCAmelCase    ,  **UpperCAmelCase			)
 def   A_			(   self						:   int    ,  *UpperCAmelCase						:   List[Any]    ,  **UpperCAmelCase						:   Tuple			)    ->			str:
     return self.image_processor.post_process_object_detection(*UpperCAmelCase    ,  **UpperCAmelCase			)
 def   A_			(   self						:   Tuple    ,  *UpperCAmelCase						:   Dict    ,  **UpperCAmelCase						:   Optional[int]			)    ->			Optional[Any]:
     return self.image_processor.post_process_image_guided_detection(*UpperCAmelCase    ,  **UpperCAmelCase			)
 def   A_			(   self						:   Optional[Any]    ,  *UpperCAmelCase						:   Tuple    ,  **UpperCAmelCase						:   List[Any]			)    ->			Tuple:
     return self.tokenizer.batch_decode(*UpperCAmelCase    ,  **UpperCAmelCase			)
 def   A_			(   self						:   Union[str, Any]    ,  *UpperCAmelCase						:   List[Any]    ,  **UpperCAmelCase						:   List[Any]			)    ->			List[str]:
     return self.tokenizer.decode(*UpperCAmelCase    ,  **UpperCAmelCase			)
 @property
 def   A_			(   self						:   List[str]			)    ->			Optional[Any]:
     warnings.warn(
         '`feature_extractor_class` is deprecated and will be removed in v5. Use `image_processor_class` instead.'    ,  UpperCAmelCase    ,  )
     return self.image_processor_class







 @property
 def   A_			(   self						:   int			)    ->			int:
     warnings.warn(
         '`feature_extractor` is deprecated and will be removed in v5. Use `image_processor` instead.'    ,  UpperCAmelCase    ,  )
     return self.image_processor





