

"""simple docstring"""




from typing import List, Optional, Tuple, Union

from . import logging
from .import_utils import is_torch_available, is_torch_version


if is_torch_available():
	import torch

__A	:       Dict        =						logging.get_logger(__name__)  # pylint: disable=invalid-name

try:
	from torch._dynamo import allow_in_graph as maybe_allow_in_graph
except (ImportError, ModuleNotFoundError):
	def   __SCREAMING_SNAKE_CASE		(		cls ):
						"""simple docstring"""
						return cls
def   __SCREAMING_SNAKE_CASE		(		lowercase__     ,				lowercase__ = None     ,				lowercase__ = None     ,				lowercase__ = None     ,				lowercase__ = None     ,				):
					"""simple docstring"""
					A     =   device
					A     =   shape[0]

					A     =   layout or torch.strided
					A     =   device or torch.device("cpu" )

					if generator is not None:
										A     =   generator.device.type if not isinstance(lowercase__     ,				lowercase__ ) else generator[0].device.type
										if gen_device_type != device.type and gen_device_type == "cpu":
															A     =   "cpu"
															if device != "mps":
																				logger.info(
																				    F"""The passed generator was created on 'cpu' even though a tensor on {device} was expected."""
																				    F""" Tensors will be created on 'cpu' and then moved to {device}. Note that one can probably"""
																				    F""" slighly speed up this function by passing a generator that was created on the {device} device.""" )
										elif gen_device_type != device.type and gen_device_type == "cuda":
															raise ValueError(F"""Cannot generate a {device} tensor from a generator of type {gen_device_type}.""" )

					if isinstance(lowercase__     ,				lowercase__ ):
										A     =   (1,) + shape[1:]
										A     =   [
										    torch.randn(lowercase__     ,				generator=generator[i]     ,				device=lowercase__     ,				dtype=lowercase__     ,				layout=lowercase__ )
										    for i in range(lowercase__ )
										]
										A     =   torch.cat(lowercase__     ,				dim=0 ).to(lowercase__ )
					else:
										A     =   torch.randn(lowercase__     ,				generator=lowercase__     ,				device=lowercase__     ,				dtype=lowercase__     ,				layout=lowercase__ ).to(lowercase__ )

					return latents
def   __SCREAMING_SNAKE_CASE		(		lowercase__ ):
					"""simple docstring"""
					if is_torch_version("<"     ,				"2.0.0" ) or not hasattr(lowercase__     ,				"_dynamo" ):
										return False
					return isinstance(lowercase__     ,				torch._dynamo.eval_frame.OptimizedModule )








"""simple docstring"""




from typing import TYPE_CHECKING

from ...utils import OptionalDependencyNotAvailable, _LazyModule, is_tf_available, is_torch_available


__A	:       Dict        =						{'configuration_cvt': ['CVT_PRETRAINED_CONFIG_ARCHIVE_MAP', 'CvtConfig']}


try:
	if not is_torch_available():
		raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
	pass
else:
	__A	:       Any        =						[
	    'CVT_PRETRAINED_MODEL_ARCHIVE_LIST',
	    'CvtForImageClassification',
	    'CvtModel',
	    'CvtPreTrainedModel',
	]

try:
	if not is_tf_available():
		raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
	pass
else:
	__A	:       List[str]        =						[
	    'TF_CVT_PRETRAINED_MODEL_ARCHIVE_LIST',
	    'TFCvtForImageClassification',
	    'TFCvtModel',
	    'TFCvtPreTrainedModel',
	]

if TYPE_CHECKING:
	from .configuration_cvt import CVT_PRETRAINED_CONFIG_ARCHIVE_MAP, CvtConfig

	try:
		if not is_torch_available():
			raise OptionalDependencyNotAvailable()
	except OptionalDependencyNotAvailable:
		pass
	else:
		from .modeling_cvt import (
		    CVT_PRETRAINED_MODEL_ARCHIVE_LIST,
		    CvtForImageClassification,
		    CvtModel,
		    CvtPreTrainedModel,
		)

	try:
		if not is_tf_available():
			raise OptionalDependencyNotAvailable()
	except OptionalDependencyNotAvailable:
		pass
	else:
		from .modeling_tf_cvt import (
		    TF_CVT_PRETRAINED_MODEL_ARCHIVE_LIST,
		    TFCvtForImageClassification,
		    TFCvtModel,
		    TFCvtPreTrainedModel,
		)


else:
	import sys

	__A	:       str        =						_LazyModule(__name__, globals()['__file__'], _import_structure, module_spec=__spec__)





