


"""simple docstring"""






def 							A_					(   snake_case__					,				snake_case__					,				snake_case__					,				snake_case__		)				->     List[Any]:
			if start == end:
						return start if lst[start] > item else start + 1
			if start > end:
						return start

			_UpperCamelCase				:List[Any]				    =  (start + end) // 2
			if lst[mid] < item:
						return binary_search(snake_case__					,				snake_case__					,				mid + 1					,				snake_case__		)
			elif lst[mid] > item:
						return binary_search(snake_case__					,				snake_case__					,				snake_case__					,				mid - 1		)
			else:
						return mid





def 							A_					(   snake_case__		)				->     Tuple:
			_UpperCamelCase				:List[Any]				    =  len(snake_case__		)

			for index in range(1					,				snake_case__		):
						_UpperCamelCase				:Dict				    =  lst[index]
						_UpperCamelCase				:List[Any]				    =  binary_search(snake_case__					,				snake_case__					,				0					,				index - 1		)
						_UpperCamelCase				:str				    =  lst[:pos] + [value] + lst[pos:index] + lst[index + 1 :]

			return lst





def 							A_					(   snake_case__					,				snake_case__		)				->     Dict:
			if not left:
						return right

			if not right:
						return left

			if left[0] < right[0]:
						return [left[0], *merge(left[1:]					,				snake_case__		)]

			return [right[0], *merge(snake_case__					,				right[1:]		)]





def 							A_					(   snake_case__		)				->     str:
			_UpperCamelCase				:Union[str, Any]				    =  len(snake_case__		)
			_UpperCamelCase    ,			_UpperCamelCase				:Optional[int]				    =  [], []
			_UpperCamelCase				:int				    =  [lst[0]]
			_UpperCamelCase				:Union[str, Any]				    =  []
			_UpperCamelCase				:Dict				    =  1
			while i < length:
						if lst[i] < lst[i - 1]:
									runs.append(snake_case__		)
									_UpperCamelCase				:int				    =  [lst[i]]
						else:
									new_run.append(lst[i]		)
						i += 1
			runs.append(snake_case__		)

			for run in runs:
						sorted_runs.append(insertion_sort(snake_case__		)		)
			for run in sorted_runs:
						_UpperCamelCase				:List[str]				    =  merge(snake_case__					,				snake_case__		)

			return sorted_array





def 							A_					(   )				->     Dict:
			_UpperCamelCase				:List[Any]				    =  [5, 9, 10, 3, -4, 5, 1_78, 92, 46, -18, 0, 7]
			_UpperCamelCase				:int				    =  tim_sort(snake_case__		)
			print(snake_case__		)


if __name__ == "__main__":
					main()





"""simple docstring"""






import textwrap

import pyarrow as pa
import pytest

from datasets import Features, Value
from datasets.packaged_modules.json.json import Json





@pytest.fixture
def 							A_					(   snake_case__		)				->     Union[str, Any]:
			_UpperCamelCase				:int				    =  tmp_path / '''file.jsonl'''
			_UpperCamelCase				:Dict				    =  textwrap.dedent(
			    '''\
        {"col_1": -1}
        {"col_1": 1, "col_2": 2}
        {"col_1": 10, "col_2": 20}
        '''		)
			with open(snake_case__					,				'''w'''		) as f:
						f.write(snake_case__		)
			return str(snake_case__		)





@pytest.fixture
def 							A_					(   snake_case__		)				->     Optional[int]:
			_UpperCamelCase				:Dict				    =  tmp_path / '''file_utf16_encoded.jsonl'''
			_UpperCamelCase				:Dict				    =  textwrap.dedent(
			    '''\
        {"col_1": -1}
        {"col_1": 1, "col_2": 2}
        {"col_1": 10, "col_2": 20}
        '''		)
			with open(snake_case__					,				'''w'''					,				encoding='''utf-16'''		) as f:
						f.write(snake_case__		)
			return str(snake_case__		)





@pytest.fixture
def 							A_					(   snake_case__		)				->     Optional[int]:
			_UpperCamelCase				:Optional[Any]				    =  tmp_path / '''file_with_list_of_dicts.json'''
			_UpperCamelCase				:str				    =  textwrap.dedent(
			    '''\
        [
            {"col_1": -1},
            {"col_1": 1, "col_2": 2},
            {"col_1": 10, "col_2": 20}
        ]
        '''		)
			with open(snake_case__					,				'''w'''		) as f:
						f.write(snake_case__		)
			return str(snake_case__		)





@pytest.fixture
def 							A_					(   snake_case__		)				->     Union[str, Any]:
			_UpperCamelCase				:Dict				    =  tmp_path / '''file_with_list_of_dicts_field.json'''
			_UpperCamelCase				:Optional[int]				    =  textwrap.dedent(
			    '''\
        {
            "field1": 1,
            "field2": "aabb",
            "field3": [
                {"col_1": -1},
                {"col_1": 1, "col_2": 2},
                {"col_1": 10, "col_2": 20}
            ]
        }
        '''		)
			with open(snake_case__					,				'''w'''		) as f:
						f.write(snake_case__		)
			return str(snake_case__		)





@pytest.mark.parametrize(
    '''file_fixture, config_kwargs'''					,				[
        ('''jsonl_file''', {}),
        ('''jsonl_file_utf16_encoded''', {'''encoding''': '''utf-16'''}),
        ('''json_file_with_list_of_dicts''', {}),
        ('''json_file_with_list_of_dicts_field''', {'''field''': '''field3'''}),
    ]					,				)
def 							A_					(   snake_case__					,				snake_case__					,				snake_case__		)				->     int:
			_UpperCamelCase				:Any				    =  Json(**snake_case__		)
			_UpperCamelCase				:str				    =  json._generate_tables([[request.getfixturevalue(snake_case__		)]]		)
			_UpperCamelCase				:List[Any]				    =  pa.concat_tables([table for _, table in generator]		)
			assert pa_table.to_pydict() == {"col_1": [-1, 1, 10], "col_2": [None, 2, 20]}





@pytest.mark.parametrize(
    '''file_fixture, config_kwargs'''					,				[
        (
            '''jsonl_file''',
            {'''features''': Features({'''col_1''': Value('''int64'''		), '''col_2''': Value('''int64'''		), '''missing_col''': Value('''string'''		)}		)},
        ),
        (
            '''json_file_with_list_of_dicts''',
            {'''features''': Features({'''col_1''': Value('''int64'''		), '''col_2''': Value('''int64'''		), '''missing_col''': Value('''string'''		)}		)},
        ),
        (
            '''json_file_with_list_of_dicts_field''',
            {
                '''field''': '''field3''',
                '''features''': Features(
                    {'''col_1''': Value('''int64'''		), '''col_2''': Value('''int64'''		), '''missing_col''': Value('''string'''		)}		),
            },
        ),
    ]					,				)
def 							A_					(   snake_case__					,				snake_case__					,				snake_case__		)				->     Optional[int]:
			_UpperCamelCase				:Union[str, Any]				    =  Json(**snake_case__		)
			_UpperCamelCase				:List[str]				    =  json._generate_tables([[request.getfixturevalue(snake_case__		)]]		)
			_UpperCamelCase				:str				    =  pa.concat_tables([table for _, table in generator]		)
			assert pa_table.to_pydict() == {"col_1": [-1, 1, 10], "col_2": [None, 2, 20], "missing_col": [None, None, None]}

