


"""simple docstring"""







import importlib.util
import os
import platform
from argparse import ArgumentParser

import huggingface_hub

from .. import __version__ as version
from ..utils import (
    is_accelerate_available,
    is_flax_available,
    is_safetensors_available,
    is_tf_available,
    is_torch_available,
)
from . import BaseTransformersCLICommand




def        UpperCAmelCase__	(lowerCAmelCase_       ):




					'''simple docstring'''


					return EnvironmentCommand()




def        UpperCAmelCase__	(lowerCAmelCase_       ):




					'''simple docstring'''


					return EnvironmentCommand(args.accelerate_config_file       )




class 			UpperCamelCase_     (			UpperCamelCase):

	"""simple docstring"""





	@staticmethod
	def   UpperCAmelCase_				(			UpperCAmelCase__      :    ArgumentParser       )	->     List[str]:
						__SCREAMING_SNAKE_CASE						       =    parser.add_parser("env"       )
						download_parser.set_defaults(func=UpperCAmelCase__       )
						download_parser.add_argument(
						    "--accelerate-config_file"      ,      default=UpperCAmelCase__      ,      help="The accelerate config file to use for the default values in the launching script."      ,      )
						download_parser.set_defaults(func=UpperCAmelCase__       )




	def __init__(			self      :    List[str]      ,      UpperCAmelCase__      :    List[Any]      ,      *UpperCAmelCase__      :    List[Any]       )	->     None:
						__SCREAMING_SNAKE_CASE						       =    accelerate_config_file




	def   UpperCAmelCase_				(			self      :    Any       )	->     Optional[Any]:
						__SCREAMING_SNAKE_CASE						       =    "not installed"
						if is_safetensors_available():
											import safetensors

											__SCREAMING_SNAKE_CASE						       =    safetensors.__version__
						elif importlib.util.find_spec("safetensors"       ) is not None:
											import safetensors

											__SCREAMING_SNAKE_CASE						       =    F"""{safetensors.__version__} but is ignored because of PyTorch version too old."""

						__SCREAMING_SNAKE_CASE						       =    "not installed"
						__SCREAMING_SNAKE_CASE						       =    __SCREAMING_SNAKE_CASE						       =    "not found"
						if is_accelerate_available():
											import accelerate
											from accelerate.commands.config import default_config_file, load_config_from_file

											__SCREAMING_SNAKE_CASE						       =    accelerate.__version__
											# Get the default from the config file.
											if self._accelerate_config_file is not None or os.path.isfile(UpperCAmelCase__       ):
																__SCREAMING_SNAKE_CASE						       =    load_config_from_file(self._accelerate_config_file       ).to_dict()

											__SCREAMING_SNAKE_CASE						       =    (
											    "\n".join([F"""\t- {prop}: {val}""" for prop, val in accelerate_config.items()]       )
											    if isinstance(UpperCAmelCase__      ,      UpperCAmelCase__       )
											    else F"""\t{accelerate_config}"""
											)

						__SCREAMING_SNAKE_CASE						       =    "not installed"
						__SCREAMING_SNAKE_CASE						       =    "NA"
						if is_torch_available():
											import torch

											__SCREAMING_SNAKE_CASE						       =    torch.__version__
											__SCREAMING_SNAKE_CASE						       =    torch.cuda.is_available()

						__SCREAMING_SNAKE_CASE						       =    "not installed"
						__SCREAMING_SNAKE_CASE						       =    "NA"
						if is_tf_available():
											import tensorflow as tf

											__SCREAMING_SNAKE_CASE						       =    tf.__version__
											try:
																# deprecated in v2.1
																__SCREAMING_SNAKE_CASE						       =    tf.test.is_gpu_available()
											except AttributeError:
																# returns list of devices, convert to bool
																__SCREAMING_SNAKE_CASE						       =    bool(tf.config.list_physical_devices("GPU"       )       )

						__SCREAMING_SNAKE_CASE						       =    "not installed"
						__SCREAMING_SNAKE_CASE						       =    "not installed"
						__SCREAMING_SNAKE_CASE						       =    "not installed"
						__SCREAMING_SNAKE_CASE						       =    "NA"
						if is_flax_available():
											import flax
											import jax
											import jaxlib

											__SCREAMING_SNAKE_CASE						       =    flax.__version__
											__SCREAMING_SNAKE_CASE						       =    jax.__version__
											__SCREAMING_SNAKE_CASE						       =    jaxlib.__version__
											__SCREAMING_SNAKE_CASE						       =    jax.lib.xla_bridge.get_backend().platform

						__SCREAMING_SNAKE_CASE						       =    {
						    "`transformers` version": version,
						    "Platform": platform.platform(),
						    "Python version": platform.python_version(),
						    "Huggingface_hub version": huggingface_hub.__version__,
						    "Safetensors version": F"""{safetensors_version}""",
						    "Accelerate version": F"""{accelerate_version}""",
						    "Accelerate config": F"""{accelerate_config_str}""",
						    "PyTorch version (GPU?)": F"""{pt_version} ({pt_cuda_available})""",
						    "Tensorflow version (GPU?)": F"""{tf_version} ({tf_cuda_available})""",
						    "Flax version (CPU?/GPU?/TPU?)": F"""{flax_version} ({jax_backend})""",
						    "Jax version": F"""{jax_version}""",
						    "JaxLib version": F"""{jaxlib_version}""",
						    "Using GPU in script?": "<fill in>",
						    "Using distributed or parallel set-up in script?": "<fill in>",
						}

						print("\nCopy-and-paste the text below in your GitHub issue and FILL OUT the two last points.\n"       )
						print(self.format_dict(UpperCAmelCase__       )       )

						return info




	@staticmethod
	def   UpperCAmelCase_				(			UpperCAmelCase__      :    List[Any]       )	->     int:
						return "\n".join([F"""- {prop}: {val}""" for prop, val in d.items()]       ) + "\n"




"""simple docstring"""







from ...utils import (
    OptionalDependencyNotAvailable,
    is_torch_available,
    is_transformers_available,
    is_transformers_version,
)


try:
		if not (is_transformers_available() and is_torch_available()):
				raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
		from ...utils.dummy_torch_and_transformers_objects import KandinskyPipeline, KandinskyPriorPipeline
else:
		from .pipeline_kandinsky import KandinskyPipeline
		from .pipeline_kandinsky_imgaimg import KandinskyImgaImgPipeline
		from .pipeline_kandinsky_inpaint import KandinskyInpaintPipeline
		from .pipeline_kandinsky_prior import KandinskyPriorPipeline, KandinskyPriorPipelineOutput
		from .text_encoder import MultilingualCLIP
