

def        __SCREAMING_SNAKE_CASE    (      a__						:      int ,a__						:      str = 1000					)				->							str:
	if (not isinstance(a__ ,a__					)) or (digit_position <= 0):
		raise ValueError("""Digit position must be a positive integer"""					)
	elif (not isinstance(a__ ,a__					)) or (precision < 0):
		raise ValueError("""Precision must be a nonnegative integer"""					)

	# compute an approximation of (16 ** (n - 1)) * pi whose fractional part is mostly
	# accurate
	__A   : int								= (
	    4 * _subsum(a__ ,1 ,a__					)
	    - 2 * _subsum(a__ ,4 ,a__					)
	    - _subsum(a__ ,5 ,a__					)
	    - _subsum(a__ ,6 ,a__					)
	)

	# return the first hex digit of the fractional part of the result
	return hex(int((sum_result % 1) * 16					)					)[2:]
def        __SCREAMING_SNAKE_CASE    (      a__						:      Tuple ,a__						:      List[str] ,a__						:      Any					)				->							float:
	__A   : int								= 0.0
	for sum_index in range(digit_pos_to_extract + precision					):
		__A   : Tuple								= 8 * sum_index + denominator_addend
		if sum_index < digit_pos_to_extract:
			# if the exponential term is an integer and we mod it by the denominator
			# before dividing, only the integer part of the sum will change;
			# the fractional part will not
			__A   : Optional[int]								= pow(
			    16 ,digit_pos_to_extract - 1 - sum_index ,a__					)
		else:
			__A   : List[str]								= pow(16 ,digit_pos_to_extract - 1 - sum_index					)
		total += exponential_term / denominator
	return total


if __name__ == "__main__":
			import doctest

			doctest.testmod()








import unittest
from pathlib import Path

from transformers import is_vision_available, load_tool
from transformers.testing_utils import get_tests_dir

from .test_tools_common import ToolTesterMixin


if is_vision_available():
			from PIL import Image






class     lowerCamelCase_			(  unittest.TestCase	,			_lowercase  ):




	def 					lowerCAmelCase_					(    self	:    Dict       ):
		__A   : str								= load_tool("""image-captioning"""       )
		self.tool.setup()
		__A   : Dict								= load_tool("""image-captioning"""				,			remote=__A       )




	def 					lowerCAmelCase_					(    self	:    Optional[int]       ):
		__A   : List[Any]								= Image.open(Path(get_tests_dir("""fixtures/tests_samples/COCO"""       )       ) / """000000039769.png"""       )
		__A   : Optional[Any]								= self.tool(__A       )
		self.assertEqual(__A				,			"""two cats sleeping on a couch"""       )




	def 					lowerCAmelCase_					(    self	:    Dict       ):
		__A   : Any								= Image.open(Path(get_tests_dir("""fixtures/tests_samples/COCO"""       )       ) / """000000039769.png"""       )
		__A   : List[str]								= self.remote_tool(__A       )
		self.assertEqual(__A				,			"""two cats sleeping on a couch"""       )




	def 					lowerCAmelCase_					(    self	:    Union[str, Any]       ):
		__A   : Optional[Any]								= Image.open(Path(get_tests_dir("""fixtures/tests_samples/COCO"""       )       ) / """000000039769.png"""       )
		__A   : str								= self.tool(image=__A       )
		self.assertEqual(__A				,			"""two cats sleeping on a couch"""       )




	def 					lowerCAmelCase_					(    self	:    str       ):
		__A   : Dict								= Image.open(Path(get_tests_dir("""fixtures/tests_samples/COCO"""       )       ) / """000000039769.png"""       )
		__A   : List[Any]								= self.remote_tool(image=__A       )
		self.assertEqual(__A				,			"""two cats sleeping on a couch"""       )





