


'''simple docstring'''


import contextlib
import importlib
import io
import unittest

import transformers

# Try to import everything from transformers to ensure every object can be loaded.
from transformers import *  # noqa F406
from transformers.testing_utils import DUMMY_UNKNOWN_IDENTIFIER, require_flax, require_tf, require_torch
from transformers.utils import ContextManagers, find_labels, is_flax_available, is_tf_available, is_torch_available


if is_torch_available():
     from transformers import BertForPreTraining, BertForQuestionAnswering, BertForSequenceClassification

if is_tf_available():
     from transformers import TFBertForPreTraining, TFBertForQuestionAnswering, TFBertForSequenceClassification

if is_flax_available():
     from transformers import FlaxBertForPreTraining, FlaxBertForQuestionAnswering, FlaxBertForSequenceClassification


__magic_name__			=      DUMMY_UNKNOWN_IDENTIFIER
# An actual model hosted on huggingface.co

__magic_name__			=      'main'
# Default branch name
__magic_name__			=      'f2c752cfc5c0ab6f4bdec59acea69eefbee381c2'
# One particular commit (not the top of `main`)
__magic_name__			=      'aaaaaaa'
# This commit does not exist, so we should 404.

__magic_name__			=      'd9e9f15bc825e4b2c9249e9578f884bbcb5e3684'
# Sha-1 of config.json on the top of `main`, for checking purposes
__magic_name__			=      '4b243c475af8d0a7754e87d7d096c92e5199ec2fe168a2ee7998e3b8e9bcb1d3'




@contextlib.contextmanager
def      lowerCamelCase					(      ):
      print("""Welcome!""")
      yield
      print("""Bye!""")




@contextlib.contextmanager
def      lowerCamelCase					(      ):
      print("""Bonjour!""")
      yield
      print("""Au revoir!""")



class 	__lowerCAmelCase		(							unittest.TestCase    ):


  '''simple docstring'''







  def        _a							(							self :       Union[str, Any] ):

        '''simple docstring'''




        assert transformers.__spec__ is not None
        assert importlib.util.find_spec("""transformers""" ) is not None







class 	__lowerCAmelCase		(							unittest.TestCase    ):


  '''simple docstring'''







  @unittest.mock.patch("""sys.stdout"""	,new_callable=io.StringIO )
  def        _a							(							self :       Any	,_a :       Optional[int] ):

        '''simple docstring'''




        with ContextManagers([] ):
              print("""Transformers are awesome!""" )
        # The print statement adds a new line at the end of the output
        self.assertEqual(mock_stdout.getvalue()	,"""Transformers are awesome!\n""" )






  @unittest.mock.patch("""sys.stdout"""	,new_callable=io.StringIO )
  def        _a							(							self :       List[Any]	,_a :       Dict ):

        '''simple docstring'''




        with ContextManagers([context_en()] ):
              print("""Transformers are awesome!""" )
        # The output should be wrapped with an English welcome and goodbye
        self.assertEqual(mock_stdout.getvalue()	,"""Welcome!\nTransformers are awesome!\nBye!\n""" )






  @unittest.mock.patch("""sys.stdout"""	,new_callable=io.StringIO )
  def        _a							(							self :       str	,_a :       int ):

        '''simple docstring'''




        with ContextManagers([context_fr(), context_en()] ):
              print("""Transformers are awesome!""" )
        # The output should be wrapped with an English and French welcome and goodbye
        self.assertEqual(mock_stdout.getvalue()	,"""Bonjour!\nWelcome!\nTransformers are awesome!\nBye!\nAu revoir!\n""" )






  @require_torch
  def        _a							(							self :       int ):

        '''simple docstring'''




        self.assertEqual(find_labels(_a )	,["""labels"""] )
        self.assertEqual(find_labels(_a )	,["""labels""", """next_sentence_label"""] )
        self.assertEqual(find_labels(_a )	,["""start_positions""", """end_positions"""] )



        class 	__lowerCAmelCase		(							UpperCAmelCase__    ):


          '''simple docstring'''







          pass







        self.assertEqual(find_labels(_a )	,["""labels"""] )






  @require_tf
  def        _a							(							self :       Optional[Any] ):

        '''simple docstring'''




        self.assertEqual(find_labels(_a )	,["""labels"""] )
        self.assertEqual(find_labels(_a )	,["""labels""", """next_sentence_label"""] )
        self.assertEqual(find_labels(_a )	,["""start_positions""", """end_positions"""] )



        class 	__lowerCAmelCase		(							UpperCAmelCase__    ):


          '''simple docstring'''







          pass







        self.assertEqual(find_labels(_a )	,["""labels"""] )






  @require_flax
  def        _a							(							self :       List[Any] ):

        '''simple docstring'''




        self.assertEqual(find_labels(_a )	,[] )
        self.assertEqual(find_labels(_a )	,[] )
        self.assertEqual(find_labels(_a )	,[] )



        class 	__lowerCAmelCase		(							UpperCAmelCase__    ):


          '''simple docstring'''







          pass







        self.assertEqual(find_labels(_a )	,[] )




'''simple docstring'''


from sympy import diff, lambdify, symbols
from sympy.functions import *  # noqa: F403




def      lowerCamelCase					(      lowerCamelCase  :      str							,						lowerCamelCase  :      complex							,						lowerCamelCase  :      str = "x"							,						lowerCamelCase  :      float = 10**-10							,						lowerCamelCase  :      int = 1							,						):
      A_						:  int          =				symbols(lowerCamelCase)
      A_						:  List[Any]          =				lambdify(lowerCamelCase							,						lowerCamelCase)
      A_						:  List[str]          =				lambdify(lowerCamelCase							,						diff(lowerCamelCase							,						lowerCamelCase))

      A_						:  str          =				starting_point

      while True:
            if diff_function(lowerCamelCase) != 0:
                  A_						:  int          =				prev_guess - multiplicity * func(lowerCamelCase) / diff_function(
                      lowerCamelCase)
            else:
                  raise ZeroDivisionError("""Could not find root""") from None

            # Precision is checked by comparing the difference of consecutive guesses
            if abs(next_guess - prev_guess) < precision:
                  return next_guess

            A_						:  Union[str, Any]          =				next_guess


# Let's Execute
if __name__ == "__main__":
     # Find root of trigonometric function
     # Find value of pi
     print(f"""The root of sin(x) = 0 is {newton_raphson('sin(x)', 2)}""")

     # Find root of polynomial
     # Find fourth Root of 5
     print(f"""The root of x**4 - 5 = 0 is {newton_raphson('x**4 -5', 0.4 +5j)}""")

     # Find value of e
     print(
         'The root of log(y) - 1 = 0 is ',
         f"""{newton_raphson('log(y) - 1', 2, variable='y')}""",
     )

     # Exponential Roots
     print(
         'The root of exp(x) - 1 = 0 is',
         f"""{newton_raphson('exp(x) - 1', 10, precision=0.0_0_5)}""",
     )

     # Find root of cos(x)
     print(f"""The root of cos(x) = 0 is {newton_raphson('cos(x)', 0)}""")
