






"""simple docstring"""




import os
import socket
from contextlib import contextmanager

import torch

from ..commands.config.default import write_basic_config  # noqa: F401
from ..state import PartialState
from .dataclasses import DistributedType
from .imports import is_deepspeed_available, is_tpu_available
from .transformer_engine import convert_model
from .versions import is_torch_version


if is_deepspeed_available():
 from deepspeed import DeepSpeedEngine

if is_tpu_available(check_device=False):
 import torch_xla.core.xla_model as xm

def 			lowerCAmelCase__     (     UpperCamelCase__				):



  '''simple docstring'''
  if is_torch_version("""<"""     ,   """2.0.0"""				) or not hasattr(UpperCamelCase__     ,   """_dynamo"""				):
    return False
  return isinstance(UpperCamelCase__     ,   torch._dynamo.eval_frame.OptimizedModule				)

def 			lowerCAmelCase__     (     UpperCamelCase__     ,   UpperCamelCase__ = True				):



  '''simple docstring'''
  _a  :       Tuple             =	(torch.nn.parallel.DistributedDataParallel, torch.nn.DataParallel)

  _a  :       List[str]             =	is_compiled_module(UpperCamelCase__				)
  if is_compiled:
    _a  :       str             =	model
    _a  :       Union[str, Any]             =	model._orig_mod

  if is_deepspeed_available():
    options += (DeepSpeedEngine,)

  while isinstance(UpperCamelCase__     ,   UpperCamelCase__				):
    _a  :       Tuple             =	model.module

  if not keep_fpaa_wrapper:
    _a  :       Optional[int]             =	getattr(UpperCamelCase__     ,   """forward"""				)
    _a  :       Union[str, Any]             =	model.__dict__.pop("""_original_forward"""     ,   UpperCamelCase__				)
    if original_forward is not None:
      while hasattr(UpperCamelCase__     ,   """__wrapped__"""				):
        _a  :       Optional[Any]             =	forward.__wrapped__
        if forward == original_forward:
          break
      _a  :       List[str]             =	forward
    if getattr(UpperCamelCase__     ,   """_converted_to_transformer_engine"""     ,   UpperCamelCase__				):
      convert_model(UpperCamelCase__     ,   to_transformer_engine=UpperCamelCase__				)

  if is_compiled:
    _a  :       Optional[Any]             =	model
    _a  :       str             =	compiled_model

  return model

def 			lowerCAmelCase__     (     ):



  '''simple docstring'''
  PartialState().wait_for_everyone()

def 			lowerCAmelCase__     (     UpperCamelCase__     ,   UpperCamelCase__				):



  '''simple docstring'''
  if PartialState().distributed_type == DistributedType.TPU:
    xm.save(UpperCamelCase__     ,   UpperCamelCase__				)
  elif PartialState().local_process_index == 0:
    torch.save(UpperCamelCase__     ,   UpperCamelCase__				)

@contextmanager
def 			lowerCAmelCase__     (     **UpperCamelCase__				):



  '''simple docstring'''
  for key, value in kwargs.items():
    _a  :       Dict             =	str(UpperCamelCase__				)

  yield

  for key in kwargs:
    if key.upper() in os.environ:
      del os.environ[key.upper()]

def 			lowerCAmelCase__     (     UpperCamelCase__				):



  '''simple docstring'''
  if not hasattr(UpperCamelCase__     ,   """__qualname__"""				) and not hasattr(UpperCamelCase__     ,   """__name__"""				):
    _a  :       Optional[int]             =	getattr(UpperCamelCase__     ,   """__class__"""     ,   UpperCamelCase__				)
  if hasattr(UpperCamelCase__     ,   """__qualname__"""				):
    return obj.__qualname__
  if hasattr(UpperCamelCase__     ,   """__name__"""				):
    return obj.__name__
  return str(UpperCamelCase__				)

def 			lowerCAmelCase__     (     UpperCamelCase__     ,   UpperCamelCase__				):



  '''simple docstring'''
  for key, value in source.items():
    if isinstance(UpperCamelCase__     ,   UpperCamelCase__				):
      _a  :       List[str]             =	destination.setdefault(UpperCamelCase__     ,   {}				)
      merge_dicts(UpperCamelCase__     ,   UpperCamelCase__				)
    else:
      _a  :       Dict             =	value

  return destination



def 			lowerCAmelCase__     (     UpperCamelCase__ = None				):



  '''simple docstring'''
  if port is None:
    _a  :       Any             =	2_9_5_0_0
  with socket.socket(socket.AF_INET     ,   socket.SOCK_STREAM				) as s:
    return s.connect_ex(("""localhost""", port)				) == 0









"""simple docstring"""




import warnings

from ...utils import logging
from .image_processing_clip import CLIPImageProcessor


_snake_case          =   logging.get_logger(__name__)






class        UpperCamelCase			(	snake_case_      ):


 def __init__(     self		:						Any							,						*UpperCAmelCase__		:						Optional[Any]							,						**UpperCAmelCase__		:						Tuple							)					->       None:
   warnings.warn(
       """The class CLIPFeatureExtractor is deprecated and will be removed in version 5 of Transformers. Please"""
       """ use CLIPImageProcessor instead."""							,						UpperCAmelCase__							,						)
   super().__init__(*UpperCAmelCase__							,						**UpperCAmelCase__							)

