

'''simple docstring'''






import importlib
import importlib.metadata
import os
import warnings
from distutils.util import strtobool
from functools import lru_cache

import torch
from packaging import version
from packaging.version import parse

from .environment import parse_flag_from_env
from .versions import compare_versions, is_torch_version


try:
      import torch_xla.core.xla_model as xm  # noqa: F401

      snake_case_					  =	True
except ImportError:
      snake_case_					  =	False


# Cache this result has it's a C FFI call which can be pretty time-consuming
snake_case_					  =	torch.distributed.is_available()


def  __lowerCamelCase      (				SCREAMING_SNAKE_CASE_					:     str   )							->       Optional[Any]:
      """simple docstring"""

      SCREAMING_SNAKE_CASE_				:      Tuple					=	importlib.util.find_spec(SCREAMING_SNAKE_CASE_   ) is not None
      if package_exists:
            try:
                  SCREAMING_SNAKE_CASE_				:      Union[str, Any]					=	importlib.metadata.metadata(SCREAMING_SNAKE_CASE_   )
                  return True
            except importlib.metadata.PackageNotFoundError:
                  return False


def  __lowerCamelCase      (				)							->       bool:
      """simple docstring"""

      return _torch_distributed_available


def  __lowerCamelCase      (				)							->       Optional[int]:
      """simple docstring"""

      try:
            pass
      except ImportError:
            print(
                "Intel(R) oneCCL Bindings for PyTorch* is required to run DDP on Intel(R) GPUs, but it is not"
                " detected. If you see \"ValueError: Invalid backend: 'ccl'\" error, please install Intel(R) oneCCL"
                " Bindings for PyTorch*."   )
      return (
          importlib.util.find_spec("torch_ccl"   ) is not None
          or importlib.util.find_spec("oneccl_bindings_for_pytorch"   ) is not None
      )


def  __lowerCamelCase      (				)							->       List[Any]:
      """simple docstring"""

      return importlib.metadata.version("oneccl_bind_pt"   )


def  __lowerCamelCase      (				)							->       List[Any]:
      """simple docstring"""

      return _is_package_available("transformer_engine"   )


@lru_cache
def  __lowerCamelCase      (				SCREAMING_SNAKE_CASE_					:     int=True   )							->       List[Any]:
      """simple docstring"""

      if torch.cuda.is_available():
            return False
      if _tpu_available and check_device:
            try:
                  # Will raise a RuntimeError if no XLA configuration is found
                  SCREAMING_SNAKE_CASE_				:      Dict					=	xm.xla_device()
                  return True
            except RuntimeError:
                  return False
      return _tpu_available


def  __lowerCamelCase      (				)							->       List[Any]:
      """simple docstring"""

      return _is_package_available("deepspeed"   )


def  __lowerCamelCase      (				SCREAMING_SNAKE_CASE_					:     Tuple=False   )							->       Optional[Any]:
      """simple docstring"""

      if is_tpu_available():
            return not ignore_tpu
      if torch.cuda.is_available():
            return torch.cuda.is_bfaa_supported()
      if is_npu_available():
            return False
      return True


def  __lowerCamelCase      (				)							->       Tuple:
      """simple docstring"""

      SCREAMING_SNAKE_CASE_				:      Union[str, Any]					=	_is_package_available("bitsandbytes"   )
      if package_exists:
            SCREAMING_SNAKE_CASE_				:      Optional[int]					=	version.parse(importlib.metadata.version("bitsandbytes"   )   )
            return compare_versions(SCREAMING_SNAKE_CASE_  ,  ">="  ,  "0.39.0"   )
      return False


def  __lowerCamelCase      (				)							->       List[Any]:
      """simple docstring"""

      SCREAMING_SNAKE_CASE_				:      Any					=	_is_package_available("bitsandbytes"   )
      if package_exists:
            SCREAMING_SNAKE_CASE_				:      int					=	version.parse(importlib.metadata.version("bitsandbytes"   )   )
            return compare_versions(SCREAMING_SNAKE_CASE_  ,  ">="  ,  "0.37.2"   )
      return False


def  __lowerCamelCase      (				)							->       str:
      """simple docstring"""

      return _is_package_available("bitsandbytes"   )


def  __lowerCamelCase      (				)							->       Dict:
      """simple docstring"""

      if strtobool(os.environ.get("ACCELERATE_USE_MEGATRON_LM"  ,  "False"   )   ) == 1:
            SCREAMING_SNAKE_CASE_				:      Union[str, Any]					=	importlib.util.find_spec("megatron"   ) is not None
            if package_exists:
                  try:
                        SCREAMING_SNAKE_CASE_				:      Dict					=	parse(importlib.metadata.version("megatron-lm"   )   )
                        return compare_versions(SCREAMING_SNAKE_CASE_  ,  ">="  ,  "2.2.0"   )
                  except Exception as e:
                        warnings.warn(F"Parse Megatron version failed. Exception:{e}"   )
                        return False


def  __lowerCamelCase      (				)							->       Optional[Any]:
      """simple docstring"""

      return _is_package_available("safetensors"   )


def  __lowerCamelCase      (				)							->       List[Any]:
      """simple docstring"""

      return _is_package_available("transformers"   )


def  __lowerCamelCase      (				)							->       List[str]:
      """simple docstring"""

      return _is_package_available("datasets"   )


def  __lowerCamelCase      (				)							->       str:
      """simple docstring"""

      return _is_package_available("aim"   )


def  __lowerCamelCase      (				)							->       List[Any]:
      """simple docstring"""

      return _is_package_available("tensorboard"   ) or _is_package_available("tensorboardX"   )


def  __lowerCamelCase      (				)							->       List[str]:
      """simple docstring"""

      return _is_package_available("wandb"   )


def  __lowerCamelCase      (				)							->       List[str]:
      """simple docstring"""

      return _is_package_available("comet_ml"   )


def  __lowerCamelCase      (				)							->       Tuple:
      """simple docstring"""

      return _is_package_available("boto3"   )


def  __lowerCamelCase      (				)							->       Dict:
      """simple docstring"""

      if _is_package_available("rich"   ):
            if "ACCELERATE_DISABLE_RICH" in os.environ:
                  warnings.warn(
                      "`ACCELERATE_DISABLE_RICH` is deprecated and will be removed in v0.22.0 and deactivated by default. Please use `ACCELERATE_ENABLE_RICH` if you wish to use `rich`."   )
                  return not parse_flag_from_env("ACCELERATE_DISABLE_RICH"  ,  SCREAMING_SNAKE_CASE_   )
            return parse_flag_from_env("ACCELERATE_ENABLE_RICH"  ,  SCREAMING_SNAKE_CASE_   )
      return False


def  __lowerCamelCase      (				)							->       Optional[int]:
      """simple docstring"""

      return _is_package_available("sagemaker"   )


def  __lowerCamelCase      (				)							->       Optional[Any]:
      """simple docstring"""

      return _is_package_available("tqdm"   )


def  __lowerCamelCase      (				)							->       List[Any]:
      """simple docstring"""

      return _is_package_available("mlflow"   )


def  __lowerCamelCase      (				)							->       List[Any]:
      """simple docstring"""

      return is_torch_version(">="  ,  "1.12"   ) and torch.backends.mps.is_available() and torch.backends.mps.is_built()


def  __lowerCamelCase      (				)							->       Union[str, Any]:
      """simple docstring"""

      def get_major_and_minor_from_version(SCREAMING_SNAKE_CASE_					:     Dict   ):
            return str(version.parse(SCREAMING_SNAKE_CASE_   ).major   ) + "." + str(version.parse(SCREAMING_SNAKE_CASE_   ).minor   )

      SCREAMING_SNAKE_CASE_				:      Union[str, Any]					=	importlib.metadata.version("torch"   )
      if importlib.util.find_spec("intel_extension_for_pytorch"   ) is None:
            return False
      SCREAMING_SNAKE_CASE_				:      Optional[Any]					=	"N/A"
      try:
            SCREAMING_SNAKE_CASE_				:      str					=	importlib.metadata.version("intel_extension_for_pytorch"   )
      except importlib.metadata.PackageNotFoundError:
            return False
      SCREAMING_SNAKE_CASE_				:      Dict					=	get_major_and_minor_from_version(_torch_version   )
      SCREAMING_SNAKE_CASE_				:      Optional[int]					=	get_major_and_minor_from_version(_ipex_version   )
      if torch_major_and_minor != ipex_major_and_minor:
            warnings.warn(
                F"Intel Extension for PyTorch {ipex_major_and_minor} needs to work with PyTorch {ipex_major_and_minor}.*,"
                F" but PyTorch {_torch_version} is found. Please switch to the matching version and run again."   )
            return False
      return True


@lru_cache
def  __lowerCamelCase      (				SCREAMING_SNAKE_CASE_					:     Optional[int]=False   )							->       Dict:
      """simple docstring"""

      if importlib.util.find_spec("torch"   ) is None or importlib.util.find_spec("torch_npu"   ) is None:
            return False

      import torch
      import torch_npu  # noqa: F401

      if check_device:
            try:
                  # Will raise a RuntimeError if no NPU is found
                  SCREAMING_SNAKE_CASE_				:      Dict					=	torch.npu.device_count()
                  return torch.npu.is_available()
            except RuntimeError:
                  return False
      return hasattr(SCREAMING_SNAKE_CASE_  ,  "npu"   ) and torch.npu.is_available()





@lru_cache
def  __lowerCamelCase      (				SCREAMING_SNAKE_CASE_					:     Optional[int]=False   )							->       Union[str, Any]:
      """simple docstring"""

      if not parse_flag_from_env("ACCELERATE_USE_XPU"  ,  default=SCREAMING_SNAKE_CASE_   ):
            return False
      if is_ipex_available():
            import torch

            if is_torch_version("<="  ,  "1.12"   ):
                  return False
      else:
            return False

      import intel_extension_for_pytorch  # noqa: F401

      if check_device:
            try:
                  # Will raise a RuntimeError if no XPU  is found
                  SCREAMING_SNAKE_CASE_				:      List[str]					=	torch.xpu.device_count()
                  return torch.xpu.is_available()
            except RuntimeError:
                  return False
      return hasattr(SCREAMING_SNAKE_CASE_  ,  "xpu"   ) and torch.xpu.is_available()




'''simple docstring'''






import requests
from bsa import BeautifulSoup


def  __lowerCamelCase      (				SCREAMING_SNAKE_CASE_					:     int  ,  SCREAMING_SNAKE_CASE_					:     str   )							->       str:
      """simple docstring"""

      SCREAMING_SNAKE_CASE_				:      List[str]					=	(
          "https://www.horoscope.com/us/horoscopes/general/"
          F"horoscope-general-daily-{day}.aspx?sign={zodiac_sign}"
      )
      SCREAMING_SNAKE_CASE_				:      Dict					=	BeautifulSoup(requests.get(SCREAMING_SNAKE_CASE_   ).content  ,  "html.parser"   )
      return soup.find("div"  ,  class_="main-horoscope"   ).p.text


if __name__ == "__main__":
      print('Daily Horoscope. \n')
      print(
          'enter your Zodiac sign number:\n',
          '1. Aries\n',
          '2. Taurus\n',
          '3. Gemini\n',
          '4. Cancer\n',
          '5. Leo\n',
          '6. Virgo\n',
          '7. Libra\n',
          '8. Scorpio\n',
          '9. Sagittarius\n',
          '10. Capricorn\n',
          '11. Aquarius\n',
          '12. Pisces\n',
      )
      snake_case_					  =	int(input('number> ').strip())
      print('choose some day:\n', 'yesterday\n', 'today\n', 'tomorrow\n')
      snake_case_					  =	input('enter the day> ')
      snake_case_					  =	horoscope(zodiac_sign, day)
      print(horoscope_text)

