

"""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 			_snake_case  (     UpperCAmelCase_	:       Tuple      ):
     A__				      =	tmp_path / '''file.jsonl'''
     A__				      =	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 			_snake_case  (     UpperCAmelCase_	:       Tuple      ):
     A__				      =	tmp_path / '''file_utf16_encoded.jsonl'''
     A__				      =	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 			_snake_case  (     UpperCAmelCase_	:       Tuple      ):
     A__				      =	tmp_path / '''file_with_list_of_dicts.json'''
     A__				      =	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 			_snake_case  (     UpperCAmelCase_	:       str      ):
     A__				      =	tmp_path / '''file_with_list_of_dicts_field.json'''
     A__				      =	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 			_snake_case  (     UpperCAmelCase_	:       List[Any]       , UpperCAmelCase_	:       Tuple       , UpperCAmelCase_	:       int      ):
     A__				      =	Json(**_snake_case      )
     A__				      =	json._generate_tables([[request.getfixturevalue(_snake_case      )]]      )
     A__				      =	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 			_snake_case  (     UpperCAmelCase_	:       List[Any]       , UpperCAmelCase_	:       Tuple       , UpperCAmelCase_	:       Optional[int]      ):
     A__				      =	Json(**_snake_case      )
     A__				      =	json._generate_tables([[request.getfixturevalue(_snake_case      )]]      )
     A__				      =	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]}










"""simple docstring"""
import unittest
from dataclasses import dataclass
from typing import Optional

from transformers.utils import ModelOutput



@dataclass
class      _UpperCAmelCase					(				__snake_case							):






		'''simple docstring'''

		lowerCamelCase__           =42
		lowerCamelCase__           =None
		lowerCamelCase__           =None



class      _UpperCAmelCase					(				unittest.TestCase							):






		'''simple docstring'''

		def 							SCREAMING_SNAKE_CASE    (self   ):





			'''simple docstring'''

			__snake_case      :		Union[str, Any]         =							ModelOutputTest(a=30   )
			self.assertEqual(x.a							,			30   )
			self.assertIsNone(x.b   )
			self.assertIsNone(x.c   )
			with self.assertRaises(a_   ):
				__snake_case      :		str         =							x.d



		def 							SCREAMING_SNAKE_CASE    (self   ):





			'''simple docstring'''

			__snake_case      :		Union[str, Any]         =							ModelOutputTest(a=30							,			b=10   )
			self.assertEqual(x[0]							,			30   )
			self.assertEqual(x[1]							,			10   )
			self.assertEqual(x[:2]							,			(30, 10)   )
			self.assertEqual(x[:]							,			(30, 10)   )

			__snake_case      :		List[Any]         =							ModelOutputTest(a=30							,			c=10   )
			self.assertEqual(x[0]							,			30   )
			self.assertEqual(x[1]							,			10   )
			self.assertEqual(x[:2]							,			(30, 10)   )
			self.assertEqual(x[:]							,			(30, 10)   )



		def 							SCREAMING_SNAKE_CASE    (self   ):





			'''simple docstring'''

			__snake_case      :		Optional[int]         =							ModelOutputTest(a=30							,			b=10   )
			self.assertEqual(x['''a''']							,			30   )
			self.assertEqual(x['''b''']							,			10   )
			with self.assertRaises(a_   ):
				__snake_case      :		Optional[int]         =							x['''c''']

			__snake_case      :		Any         =							ModelOutputTest(a=30							,			c=10   )
			self.assertEqual(x['''a''']							,			30   )
			self.assertEqual(x['''c''']							,			10   )
			with self.assertRaises(a_   ):
				__snake_case      :		Optional[int]         =							x['''b''']



		def 							SCREAMING_SNAKE_CASE    (self   ):





			'''simple docstring'''

			__snake_case      :		Optional[int]         =							ModelOutputTest(a=30   )
			self.assertEqual(list(x.keys()   )							,			['''a''']   )
			self.assertEqual(list(x.values()   )							,			[30]   )
			self.assertEqual(list(x.items()   )							,			[('''a''', 30)]   )
			self.assertEqual(list(a_   )							,			['''a''']   )

			__snake_case      :		Optional[int]         =							ModelOutputTest(a=30							,			b=10   )
			self.assertEqual(list(x.keys()   )							,			['''a''', '''b''']   )
			self.assertEqual(list(x.values()   )							,			[30, 10]   )
			self.assertEqual(list(x.items()   )							,			[('''a''', 30), ('''b''', 10)]   )
			self.assertEqual(list(a_   )							,			['''a''', '''b''']   )

			__snake_case      :		Optional[Any]         =							ModelOutputTest(a=30							,			c=10   )
			self.assertEqual(list(x.keys()   )							,			['''a''', '''c''']   )
			self.assertEqual(list(x.values()   )							,			[30, 10]   )
			self.assertEqual(list(x.items()   )							,			[('''a''', 30), ('''c''', 10)]   )
			self.assertEqual(list(a_   )							,			['''a''', '''c''']   )

			with self.assertRaises(a_   ):
				__snake_case      :		Optional[int]         =							x.update({'''d''': 20}   )
			with self.assertRaises(a_   ):
				del x["a"]
			with self.assertRaises(a_   ):
				__snake_case      :		Union[str, Any]         =							x.pop('''a'''   )
			with self.assertRaises(a_   ):
				__snake_case      :		Optional[Any]         =							x.setdefault('''d'''							,			32   )



		def 							SCREAMING_SNAKE_CASE    (self   ):





			'''simple docstring'''

			__snake_case      :		List[str]         =							ModelOutputTest(a=30   )
			__snake_case      :		Tuple         =							10
			self.assertEqual(x.a							,			10   )
			self.assertEqual(x['''a''']							,			10   )



		def 							SCREAMING_SNAKE_CASE    (self   ):





			'''simple docstring'''

			__snake_case      :		List[str]         =							ModelOutputTest(a=30   )
			__snake_case      :		Any         =							10
			self.assertEqual(x.a							,			10   )
			self.assertEqual(x['''a''']							,			10   )



		def 							SCREAMING_SNAKE_CASE    (self   ):





			'''simple docstring'''

			__snake_case      :		int         =							ModelOutputTest({'''a''': 30, '''b''': 10}   )
			self.assertEqual(list(x.keys()   )							,			['''a''', '''b''']   )
			self.assertEqual(x.a							,			30   )
			self.assertEqual(x.b							,			10   )



		def 							SCREAMING_SNAKE_CASE    (self   ):





			'''simple docstring'''

			__snake_case      :		Any         =							ModelOutputTest([('''a''', 30), ('''b''', 10)]   )
			self.assertEqual(list(x.keys()   )							,			['''a''', '''b''']   )
			self.assertEqual(x.a							,			30   )
			self.assertEqual(x.b							,			10   )

			with self.assertRaises(a_   ):
				__snake_case      :		List[Any]         =							ModelOutputTest([('''a''', 30), (10, 10)]   )

			__snake_case      :		Union[str, Any]         =							ModelOutputTest(a=(30, 30)   )
			self.assertEqual(list(x.keys()   )							,			['''a''']   )
			self.assertEqual(x.a							,			(30, 30)   )





