code: 
  
  
  
  
  """simple docstring"""
  
  class 			lowerCamelCase__    :
  
  
  			def __init__(     self							):
  
  
  
  					"""simple docstring"""
  
  
  
  
  
  
  
  					snake_case		:						Dict								=				{}
  					# indexmap keys are an index and it's values are the number at that index
  					snake_case		:						List[str]								=				{}
  
  
  			def 							lowerCamelCase_				(     self				, SCREAMING_SNAKE_CASE				, SCREAMING_SNAKE_CASE							):
  
  
  
  					"""simple docstring"""
  
  
  
  
  
  
  
  					if isinstance(__SCREAMING_SNAKE_CASE				, (range, str)							):
  							snake_case		:						Any								=				list(__SCREAMING_SNAKE_CASE							)
  					elif not isinstance(__SCREAMING_SNAKE_CASE				, __SCREAMING_SNAKE_CASE							):
  							raise TypeError(
  							    "binary_search_delete() only accepts either a list, range or str"							)
  
  					snake_case		:						Optional[Any]								=				0
  					snake_case		:						Tuple								=				len(__SCREAMING_SNAKE_CASE							) - 1
  
  					while low <= high:
  							snake_case		:						Dict								=				(low + high) // 2
  							if array[mid] == item:
  									array.pop(__SCREAMING_SNAKE_CASE							)
  									return array
  							elif array[mid] < item:
  									snake_case		:						Optional[int]								=				mid + 1
  							else:
  									snake_case		:						Dict								=				mid - 1
  					raise ValueError(
  					    "Either the item is not in the array or the array was unsorted"							)
  
  
  			def 							lowerCamelCase_				(     self				, SCREAMING_SNAKE_CASE				, SCREAMING_SNAKE_CASE							):
  
  
  
  					"""simple docstring"""
  
  
  
  
  
  
  
  					if isinstance(__SCREAMING_SNAKE_CASE				, (range, str)							):
  							snake_case		:						str								=				list(__SCREAMING_SNAKE_CASE							)
  					elif not isinstance(__SCREAMING_SNAKE_CASE				, __SCREAMING_SNAKE_CASE							):
  							raise TypeError(
  							    "binary_search_insert() only accepts either a list, range or str"							)
  
  					snake_case		:						int								=				0
  					snake_case		:						Optional[Any]								=				len(__SCREAMING_SNAKE_CASE							) - 1
  
  					while low <= high:
  							snake_case		:						Dict								=				(low + high) // 2
  							if array[mid] == index:
  									# If the item already exists in the array,
  									# insert it after the existing item
  									array.insert(mid + 1				, __SCREAMING_SNAKE_CASE							)
  									return array
  							elif array[mid] < index:
  									snake_case		:						List[Any]								=				mid + 1
  							else:
  									snake_case		:						List[str]								=				mid - 1
  
          # If the item doesn't exist in the array, insert it at the appropriate position
  					array.insert(__SCREAMING_SNAKE_CASE				, __SCREAMING_SNAKE_CASE							)
  					return array
  
  
  			def 							lowerCamelCase_				(     self				, SCREAMING_SNAKE_CASE				, SCREAMING_SNAKE_CASE							):
  
  
  
  					"""simple docstring"""
  
  
  
  
  
  
  
  					if index in self.indexmap:
  							snake_case		:						List[Any]								=				self.indexmap[index]
  							if len(self.numbermap[n]							) == 1:
  									del self.numbermap[n]
  							else:
  									snake_case		:						Union[str, Any]								=				self.binary_search_delete(self.numbermap[n]				, __SCREAMING_SNAKE_CASE							)
  
          # Set new index
  					snake_case		:						int								=				number
  
  					# Number not seen before or empty so insert number value
  					if number not in self.numbermap:
  							snake_case		:						Union[str, Any]								=				[index]
  
  					# Here we need to perform a binary search insertion in order to insert
  					# The item in the correct place
  					else:
  							snake_case		:						List[Any]								=				self.binary_search_insert(
  							    self.numbermap[number]				, __SCREAMING_SNAKE_CASE							)
  
  
  
  			def 							lowerCamelCase_				(     self				, SCREAMING_SNAKE_CASE							):
  
  
  
  					"""simple docstring"""
  
  
  
  
  
  
  
  					return self.numbermap.get(__SCREAMING_SNAKE_CASE				, [-1]							)[0]
  
  
  if __name__ == "__main__":
  							import doctest
  
  							doctest.testmod()
  
  
style_context: 
  
  
  
  
  """simple docstring"""
  
  import textwrap
  
  import pyarrow as pa
  import pytest
  
  from datasets import Features, Image
  from datasets.packaged_modules.text.text import Text
  
  from ..utils import require_pil
  
  
  
  @pytest.fixture
  def   UpperCamelCase__     (		lowercase__  :     str   ):
  		snake_case		:						List[str]								=				tmp_path / "text.txt"
  		snake_case		:						Tuple								=				textwrap.dedent(
  		    "\\n        Lorem ipsum dolor sit amet, consectetur adipiscing elit, sed do eiusmod tempor incididunt ut labore et dolore magna aliqua.\n        Ut enim ad minim veniam, quis nostrud exercitation ullamco laboris nisi ut aliquip ex ea commodo consequat.\n        Duis aute irure dolor in reprehenderit in voluptate velit esse cillum dolore eu fugiat nulla pariatur.\n        Excepteur sint occaecat cupidatat non proident, sunt in culpa qui officia deserunt mollit anim id est laborum.\n\n        Second paragraph:\n        Lorem ipsum dolor sit amet, consectetur adipiscing elit, sed do eiusmod tempor incididunt ut labore et dolore magna aliqua.\n        Ut enim ad minim veniam, quis nostrud exercitation ullamco laboris nisi ut aliquip ex ea commodo consequat.\n        Duis aute irure dolor in reprehenderit in voluptate velit esse cillum dolore eu fugiat nulla pariatur.\n        Excepteur sint occaecat cupidatat non proident, sunt in culpa qui officia deserunt mollit anim id est laborum.\n        "   )
  		with open(lowercase__       ,     "w"       ,     encoding="utf-8"   ) as f:
  				f.write(lowercase__   )
  		return str(lowercase__   )
  
  
  
  @pytest.fixture
  def   UpperCamelCase__     (		lowercase__  :     str       ,     lowercase__  :     Dict   ):
  		snake_case		:						Any								=				tmp_path / "text_with_image.txt"
  		with open(lowercase__       ,     "w"       ,     encoding="utf-8"   ) as f:
  				f.write(lowercase__   )
  		return str(lowercase__   )
  
  
  
  @pytest.mark.parametrize("keep_linebreaks"       ,     [True, False]   )
  def   UpperCamelCase__     (		lowercase__  :     Union[str, Any]       ,     lowercase__  :     Tuple   ):
  		with open(lowercase__       ,     encoding="utf-8"   ) as f:
  				snake_case		:						List[Any]								=				f.read().splitlines(keepends=lowercase__   )
  		snake_case		:						List[Any]								=				Text(keep_linebreaks=lowercase__       ,     encoding="utf-8"   )
  		snake_case		:						Optional[int]								=				text._generate_tables([[text_file]]   )
  		snake_case		:						int								=				pa.concat_tables([table for _, table in generator]   ).to_pydict()["text"]
  		assert generated_content == expected_content
  
  
  
  @require_pil
  def   UpperCamelCase__     (		lowercase__  :     Optional[Any]   ):
  		with open(lowercase__       ,     encoding="utf-8"   ) as f:
  				snake_case		:						Union[str, Any]								=				f.read().splitlines()[0]
  		snake_case		:						List[Any]								=				Text(encoding="utf-8"       ,     features=Features({"image": Image()}   )   )
  		snake_case		:						Tuple								=				text._generate_tables([[text_file_with_image]]   )
  		snake_case		:						List[str]								=				pa.concat_tables([table for _, table in generator]   )
  		assert pa_table.schema.field("image"   ).type == Image()()
  		snake_case		:						Optional[Any]								=				pa_table.to_pydict()["image"]
  		assert generated_content == [{"path": image_file, "bytes": None}]
  
  
  
  @pytest.mark.parametrize("sample_by"       ,     ["line", "paragraph", "document"]   )
  def   UpperCamelCase__     (		lowercase__  :     Union[str, Any]       ,     lowercase__  :     List[str]   ):
  		with open(lowercase__       ,     encoding="utf-8"   ) as f:
  				snake_case		:						Tuple								=				f.read()
  		if sample_by == "line":
  				snake_case		:						Optional[int]								=				expected_content.splitlines()
  		elif sample_by == "paragraph":
  				snake_case		:						str								=				expected_content.split("\n\n"   )
  		elif sample_by == "document":
  				snake_case		:						List[Any]								=				[expected_content]
  		snake_case		:						str								=				Text(sample_by=lowercase__       ,     encoding="utf-8"       ,     chunksize=100   )
  		snake_case		:						Optional[int]								=				text._generate_tables([[text_file]]   )
  		snake_case		:						Optional[Any]								=				pa.concat_tables([table for _, table in generator]   ).to_pydict()["text"]
  		assert generated_content == expected_content
  
  