


'''simple docstring'''

# Copyright 2022 The HuggingFace Team. All rights reserved.
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
#     http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.

import argparse
import os
import platform

import numpy as np
import psutil
import torch

from accelerate import __version__ as version
from accelerate.commands.config import default_config_file, load_config_from_file

from ..utils import is_npu_available, is_xpu_available

def _SCREAMING_SNAKE_CASE (A=None			)			->			Tuple:






       """simple docstring"""







       if subparsers is not None:
              lowercase__      =					subparsers.add_parser('''env'''			)
       else:
              lowercase__      =					argparse.ArgumentParser('''Accelerate env command'''			)

       parser.add_argument(
           '''--config_file'''    ,					default=A    ,					help='''The config file to use for the default values in the launching script.'''			)

       if subparsers is not None:
              parser.set_defaults(func=A			)
       return parser

def _SCREAMING_SNAKE_CASE (A			)			->			Dict:






       """simple docstring"""







       lowercase__      =					torch.__version__
       lowercase__      =					torch.cuda.is_available()
       lowercase__      =					is_xpu_available()
       lowercase__      =					is_npu_available()

       lowercase__      =					'''Not found'''
       # Get the default from the config file.
       if args.config_file is not None or os.path.isfile(A			):
              lowercase__      =					load_config_from_file(args.config_file			).to_dict()

       lowercase__      =					{
           '''`Accelerate` version''': version,
           '''Platform''': platform.platform(),
           '''Python version''': platform.python_version(),
           '''Numpy version''': np.__version__,
           '''PyTorch version (GPU?)''': f"{pt_version} ({pt_cuda_available})",
           '''PyTorch XPU available''': str(A			),
           '''PyTorch NPU available''': str(A			),
           '''System RAM''': f"{psutil.virtual_memory().total / 1_024 ** 3:.2f} GB",
       }
       if pt_cuda_available:
              lowercase__      =					torch.cuda.get_device_name()

       print('''\nCopy-and-paste the text below in your GitHub issue\n'''			)
       print('''\n'''.join([f"- {prop}: {val}" for prop, val in info.items()]			)			)

       print('''- `Accelerate` default config:''' if args.config_file is None else '''- `Accelerate` config passed:'''			)
       lowercase__      =					(
           '''\n'''.join([f"\t- {prop}: {val}" for prop, val in accelerate_config.items()]			)
           if isinstance(A    ,					A			)
           else f"\t{accelerate_config}"
       )
       print(A			)

       lowercase__      =					accelerate_config

       return info

def _SCREAMING_SNAKE_CASE ()			->			int:






       """simple docstring"""







       lowercase__      =					env_command_parser()
       lowercase__      =					parser.parse_args()
       env_command(A			)
       return 0


if __name__ == "__main__":
 raise SystemExit(main())








'''simple docstring'''

# Lint as: python3
import sys
from collections.abc import Mapping
from typing import TYPE_CHECKING

import numpy as np
import pyarrow as pa

from .. import config
from ..utils.py_utils import map_nested
from .formatting import TensorFormatter


if TYPE_CHECKING:
 import torch
class     __lowerCAmelCase		(TensorFormatter[Mapping, """torch.Tensor""", Mapping]	):





      '''simple docstring'''






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

             '''simple docstring'''







             super().__init__(features=UpperCamelCase					)
             lowercase__      =					torch_tensor_kwargs
             import torch  # noqa import torch at initialization



      def  UpperCamelCase__						(self       :       List[str]  ,		UpperCamelCase       :       Union[str, Any]					):

             '''simple docstring'''







             import torch

             if isinstance(UpperCamelCase  ,		UpperCamelCase					) and column:
                    if all(
                        isinstance(UpperCamelCase  ,		torch.Tensor					) and x.shape == column[0].shape and x.dtype == column[0].dtype
                        for x in column					):
                           return torch.stack(UpperCamelCase					)
             return column



      def  UpperCamelCase__						(self       :       List[Any]  ,		UpperCamelCase       :       Optional[Any]					):

             '''simple docstring'''







             import torch

             if isinstance(UpperCamelCase  ,		(str, bytes, type(UpperCamelCase					))					):
                    return value
             elif isinstance(UpperCamelCase  ,		(np.character, np.ndarray)					) and np.issubdtype(value.dtype  ,		np.character					):
                    return value.tolist()

             lowercase__      =					{}

             if isinstance(UpperCamelCase  ,		(np.number, np.ndarray)					) and np.issubdtype(value.dtype  ,		np.integer					):
                    lowercase__      =					{'''dtype''': torch.intaa}
             elif isinstance(UpperCamelCase  ,		(np.number, np.ndarray)					) and np.issubdtype(value.dtype  ,		np.floating					):
                    lowercase__      =					{'''dtype''': torch.floataa}
             elif config.PIL_AVAILABLE and "PIL" in sys.modules:
                    import PIL.Image

                    if isinstance(UpperCamelCase  ,		PIL.Image.Image					):
                           lowercase__      =					np.asarray(UpperCamelCase					)
             return torch.tensor(UpperCamelCase  ,		**{**default_dtype, **self.torch_tensor_kwargs}					)



      def  UpperCamelCase__						(self       :       Optional[int]  ,		UpperCamelCase       :       Dict					):

             '''simple docstring'''







             import torch

             # support for torch, tf, jax etc.
             if hasattr(UpperCamelCase  ,		'''__array__'''					) and not isinstance(UpperCamelCase  ,		torch.Tensor					):
                    lowercase__      =					data_struct.__array__()
             # support for nested types like struct of list of struct
             if isinstance(UpperCamelCase  ,		np.ndarray					):
                    if data_struct.dtype == object:  # torch tensors cannot be instantied from an array of objects
                           return self._consolidate([self.recursive_tensorize(UpperCamelCase					) for substruct in data_struct]					)
             elif isinstance(UpperCamelCase  ,		(list, tuple)					):
                    return self._consolidate([self.recursive_tensorize(UpperCamelCase					) for substruct in data_struct]					)
             return self._tensorize(UpperCamelCase					)



      def  UpperCamelCase__						(self       :       List[str]  ,		UpperCamelCase       :       dict					):

             '''simple docstring'''







             return map_nested(self._recursive_tensorize  ,		UpperCamelCase  ,		map_list=UpperCamelCase					)



      def  UpperCamelCase__						(self       :       Dict  ,		UpperCamelCase       :       pa.Table					):

             '''simple docstring'''







             lowercase__      =					self.numpy_arrow_extractor().extract_row(UpperCamelCase					)
             lowercase__      =					self.python_features_decoder.decode_row(UpperCamelCase					)
             return self.recursive_tensorize(UpperCamelCase					)



      def  UpperCamelCase__						(self       :       List[Any]  ,		UpperCamelCase       :       pa.Table					):

             '''simple docstring'''







             lowercase__      =					self.numpy_arrow_extractor().extract_column(UpperCamelCase					)
             lowercase__      =					self.python_features_decoder.decode_column(UpperCamelCase  ,		pa_table.column_names[0]					)
             lowercase__      =					self.recursive_tensorize(UpperCamelCase					)
             lowercase__      =					self._consolidate(UpperCamelCase					)
             return column






      def  UpperCamelCase__						(self       :       Tuple  ,		UpperCamelCase       :       pa.Table					):

             '''simple docstring'''







             lowercase__      =					self.numpy_arrow_extractor().extract_batch(UpperCamelCase					)
             lowercase__      =					self.python_features_decoder.decode_batch(UpperCamelCase					)
             lowercase__      =					self.recursive_tensorize(UpperCamelCase					)
             for column_name in batch:
                    lowercase__      =					self._consolidate(batch[column_name]					)
             return batch




