






'''simple docstring'''

def 					lowercase__				(   __UpperCamelCase	,		__UpperCamelCase					)->				str:
      if a < 0 or b < 0:
            raise ValueError("""the value of both inputs must be positive"""					)

      UpperCamelCase       						=      str(bin(__UpperCamelCase					)					)[2:]  # remove the leading "0b"
      UpperCamelCase       						=      str(bin(__UpperCamelCase					)					)[2:]  # remove the leading "0b"

      UpperCamelCase       						=      max(len(__UpperCamelCase					)	,		len(__UpperCamelCase					)					)

      return "0b" + "".join(
          str(int(char_a == """1""" and char_b == """1"""					)					)
          for char_a, char_b in zip(a_binary.zfill(__UpperCamelCase					)	,		b_binary.zfill(__UpperCamelCase					)					)					)


if __name__ == "__main__":
     import doctest

     doctest.testmod()








'''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 					lowercase__				(   __UpperCamelCase					)->				str:
      return EnvironmentCommand()







def 					lowercase__				(   __UpperCamelCase					)->				str:
      return EnvironmentCommand(args.accelerate_config_file					)






class        a_		(    lowerCamelCase       ):

  @staticmethod
  def 						A__		(   _SCREAMING_SNAKE_CASE   )						->   Optional[Any]:



        """simple docstring"""






        UpperCamelCase       						=      parser.add_parser("""env"""   )
        download_parser.set_defaults(func=_SCREAMING_SNAKE_CASE   )
        download_parser.add_argument(
            """--accelerate-config_file"""    ,	default=_SCREAMING_SNAKE_CASE    ,	help="""The accelerate config file to use for the default values in the launching script."""    ,	)
        download_parser.set_defaults(func=_SCREAMING_SNAKE_CASE   )

  def __init__(   self    ,	_SCREAMING_SNAKE_CASE    ,	*_SCREAMING_SNAKE_CASE   )						->   None:



        """simple docstring"""






        UpperCamelCase       						=      accelerate_config_file

  def 						A__		(   self   )						->   List[Any]:



        """simple docstring"""






        UpperCamelCase       						=      """not installed"""
        if is_safetensors_available():
              import safetensors

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

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

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

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

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

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

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

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

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

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

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

        UpperCamelCase       						=      {
            """`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(_SCREAMING_SNAKE_CASE   )   )

        return info


  @staticmethod
  def 						A__		(   _SCREAMING_SNAKE_CASE   )						->   Dict:



        """simple docstring"""






        return "\n".join([F"- {prop}: {val}" for prop, val in d.items()]   ) + "\n"
