
'''simple docstring'''







import unittest

from knapsack import greedy_knapsack as kp


class 					A__      (      unittest.TestCase			):



    def 					snake_case_			(					self       )						->      Any:





           '''simple docstring'''
           A_						=      [10, 20, 30, 40, 50, 60]
           A_						=      [2, 4, 6, 8, 10, 12]
           A_						=      100
           self.assertEqual(kp.calc_profit(UpperCamelCase_		,				UpperCamelCase_		,				UpperCamelCase_       )		,				210       )



    def 					snake_case_			(					self       )						->      int:





           '''simple docstring'''
           self.assertRaisesRegex(UpperCamelCase_		,				"""max_weight must greater than zero."""       )



    def 					snake_case_			(					self       )						->      Optional[Any]:





           '''simple docstring'''
           self.assertRaisesRegex(UpperCamelCase_		,				"""Weight can not be negative."""       )



    def 					snake_case_			(					self       )						->      Optional[Any]:





           '''simple docstring'''
           self.assertRaisesRegex(UpperCamelCase_		,				"""Profit can not be negative."""       )



    def 					snake_case_			(					self       )						->      List[str]:





           '''simple docstring'''
           self.assertRaisesRegex(UpperCamelCase_		,				"""max_weight must greater than zero."""       )







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





           '''simple docstring'''
           self.assertRaisesRegex(
               UpperCamelCase_		,				"""The length of profit and weight must be same."""       )


if __name__ == "__main__":
      unittest.main()



'''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__    (      UpperCAmelCase__				)			->			Tuple:
       return EnvironmentCommand()
def       UpperCAmelCase__    (      UpperCAmelCase__				)			->			int:
       return EnvironmentCommand(args.accelerate_config_file				)







class 					A__      (      _snake_case			):



    @staticmethod
    def 					snake_case_			(					UpperCamelCase__       )						->      Union[str, Any]:





           '''simple docstring'''
           A_						=      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		,				UpperCamelCase__		,				*UpperCamelCase__       )						->      None:





           '''simple docstring'''
           A_						=      accelerate_config_file



    def 					snake_case_			(					self       )						->      List[str]:





           '''simple docstring'''
           A_						=      """not installed"""
           if is_safetensors_available():
                  import safetensors

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

                  A_						=      f'''{safetensors.__version__} but is ignored because of PyTorch version too old.'''

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

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

                  A_						=      (
                      """\n""".join([f'''\t- {prop}: {val}''' for prop, val in accelerate_config.items()]       )
                      if isinstance(UpperCamelCase__		,				UpperCamelCase__       )
                      else f'''\t{accelerate_config}'''
                  )

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

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

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

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

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

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

           A_						=      {
               """`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 					snake_case_			(					UpperCamelCase__       )						->      List[str]:





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