
"""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__ ( a :					Union[str, Any]		):

  """simple docstring"""







  _snake_case  :    str            = tmp_path / "file.jsonl"
  _snake_case  :    Optional[Any]            = textwrap.dedent(
      "\\n        {\"col_1\": -1}\n        {\"col_1\": 1, \"col_2\": 2}\n        {\"col_1\": 10, \"col_2\": 20}\n        "		)
  with open(a							,  "w"		) as f:
    f.write(a		)
  return str(a		)
@pytest.fixture
def 					a__ ( a :					Dict		):

  """simple docstring"""







  _snake_case  :    str            = tmp_path / "file_utf16_encoded.jsonl"
  _snake_case  :    int            = textwrap.dedent(
      "\\n        {\"col_1\": -1}\n        {\"col_1\": 1, \"col_2\": 2}\n        {\"col_1\": 10, \"col_2\": 20}\n        "		)
  with open(a							,  "w"							,  encoding="utf-16"		) as f:
    f.write(a		)
  return str(a		)
@pytest.fixture
def 					a__ ( a :					Any		):

  """simple docstring"""







  _snake_case  :    List[str]            = tmp_path / "file_with_list_of_dicts.json"
  _snake_case  :    Dict            = textwrap.dedent(
      "\\n        [\n            {\"col_1\": -1},\n            {\"col_1\": 1, \"col_2\": 2},\n            {\"col_1\": 10, \"col_2\": 20}\n        ]\n        "		)
  with open(a							,  "w"		) as f:
    f.write(a		)
  return str(a		)
@pytest.fixture
def 					a__ ( a :					List[Any]		):

  """simple docstring"""







  _snake_case  :    Union[str, Any]            = tmp_path / "file_with_list_of_dicts_field.json"
  _snake_case  :    Tuple            = textwrap.dedent(
      "\\n        {\n            \"field1\": 1,\n            \"field2\": \"aabb\",\n            \"field3\": [\n                {\"col_1\": -1},\n                {\"col_1\": 1, \"col_2\": 2},\n                {\"col_1\": 10, \"col_2\": 20}\n            ]\n        }\n        "		)
  with open(a							,  "w"		) as f:
    f.write(a		)
  return str(a		)
@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__ ( a :					Any							,  a :					Any							,  a :					List[str]		):

  """simple docstring"""







  _snake_case  :    Optional[Any]            = Json(**a		)
  _snake_case  :    Optional[int]            = json._generate_tables([[request.getfixturevalue(a		)]]		)
  _snake_case  :    Tuple            = 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__ ( a :					int							,  a :					Dict							,  a :					Dict		):

  """simple docstring"""







  _snake_case  :    str            = Json(**a		)
  _snake_case  :    Optional[int]            = json._generate_tables([[request.getfixturevalue(a		)]]		)
  _snake_case  :    List[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]}









def    UpperCamelCase__  (   UpperCAmelCase     )     ->		tuple[int, int]:







							"""simple docstring"""





							if len(UpperCAmelCase     ) == 1:
														return a[0], a[0]
							else:
														# split A into half.
														_a  :    Union[str, Any]			=						a[: len(UpperCAmelCase     ) // 2]
														_a  :    Optional[Any]			=						a[len(UpperCAmelCase     ) // 2 :]

														# 2 sub problems, 1/2 of original size.
														_a		,					_a  :    Union[str, Any]			=						max_difference(UpperCAmelCase     )
														_a		,					_a  :    List[Any]			=						max_difference(UpperCAmelCase     )

														# get min of first and max of second
														# linear time
														_a  :    Union[str, Any]			=						min(UpperCAmelCase     )
														_a  :    Any			=						max(UpperCAmelCase     )

														# 3 cases, either (small1, big1),
														# (min_first, max_second), (small2, big2)
														# constant comparisons
														if biga - smalla > max_second - min_first and biga - smalla > biga - smalla:
																					return smalla, biga
														elif biga - smalla > max_second - min_first:
																					return smalla, biga
														else:
																					return min_first, max_second


if __name__ == "__main__":
						import doctest

						doctest.testmod()