




'''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							:    Optional[Any]     )							->		List[Any]:



       """simple docstring"""
       lowerCamelCase_							=tmp_path / '''file.jsonl'''
       lowerCamelCase_							=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							:    List[Any]     )							->		str:



       """simple docstring"""
       lowerCamelCase_							=tmp_path / '''file_utf16_encoded.jsonl'''
       lowerCamelCase_							=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							:    List[str]     )							->		Dict:



       """simple docstring"""
       lowerCamelCase_							=tmp_path / '''file_with_list_of_dicts.json'''
       lowerCamelCase_							=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							:    List[Any]     )							->		Dict:



       """simple docstring"""
       lowerCamelCase_							=tmp_path / '''file_with_list_of_dicts_field.json'''
       lowerCamelCase_							=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							:    Optional[int]     , __snake_case							:    List[str]     , __snake_case							:    Any     )							->		str:



       """simple docstring"""
       lowerCamelCase_							=Json(**__snake_case     )
       lowerCamelCase_							=json._generate_tables([[request.getfixturevalue(__snake_case     )]]     )
       lowerCamelCase_							=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							:    str     , __snake_case							:    int     , __snake_case							:    Dict     )							->		Optional[Any]:



       """simple docstring"""
       lowerCamelCase_							=Json(**__snake_case     )
       lowerCamelCase_							=json._generate_tables([[request.getfixturevalue(__snake_case     )]]     )
       lowerCamelCase_							=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'''




from typing import TYPE_CHECKING

from ...utils import (
    OptionalDependencyNotAvailable,
    _LazyModule,
    is_tf_available,
    is_tokenizers_available,
    is_torch_available,
)


a_   :	Union[str, Any]							   = {
    """configuration_openai""": ["""OPENAI_GPT_PRETRAINED_CONFIG_ARCHIVE_MAP""", """OpenAIGPTConfig"""],
    """tokenization_openai""": ["""OpenAIGPTTokenizer"""],
}

try:
     if not is_tokenizers_available():
          raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
     pass
else:
     a_   :	Optional[int]							   = ["""OpenAIGPTTokenizerFast"""]

try:
     if not is_torch_available():
          raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
     pass
else:
     a_   :	int							   = [
         """OPENAI_GPT_PRETRAINED_MODEL_ARCHIVE_LIST""",
         """OpenAIGPTDoubleHeadsModel""",
         """OpenAIGPTForSequenceClassification""",
         """OpenAIGPTLMHeadModel""",
         """OpenAIGPTModel""",
         """OpenAIGPTPreTrainedModel""",
         """load_tf_weights_in_openai_gpt""",
     ]

try:
     if not is_tf_available():
          raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
     pass
else:
     a_   :	Dict							   = [
         """TF_OPENAI_GPT_PRETRAINED_MODEL_ARCHIVE_LIST""",
         """TFOpenAIGPTDoubleHeadsModel""",
         """TFOpenAIGPTForSequenceClassification""",
         """TFOpenAIGPTLMHeadModel""",
         """TFOpenAIGPTMainLayer""",
         """TFOpenAIGPTModel""",
         """TFOpenAIGPTPreTrainedModel""",
     ]


if TYPE_CHECKING:
     from .configuration_openai import OPENAI_GPT_PRETRAINED_CONFIG_ARCHIVE_MAP, OpenAIGPTConfig
     from .tokenization_openai import OpenAIGPTTokenizer

     try:
          if not is_tokenizers_available():
               raise OptionalDependencyNotAvailable()
     except OptionalDependencyNotAvailable:
          pass
     else:
          from .tokenization_openai_fast import OpenAIGPTTokenizerFast

     try:
          if not is_torch_available():
               raise OptionalDependencyNotAvailable()
     except OptionalDependencyNotAvailable:
          pass
     else:
          from .modeling_openai import (
              OPENAI_GPT_PRETRAINED_MODEL_ARCHIVE_LIST,
              OpenAIGPTDoubleHeadsModel,
              OpenAIGPTForSequenceClassification,
              OpenAIGPTLMHeadModel,
              OpenAIGPTModel,
              OpenAIGPTPreTrainedModel,
              load_tf_weights_in_openai_gpt,
          )

     try:
          if not is_tf_available():
               raise OptionalDependencyNotAvailable()
     except OptionalDependencyNotAvailable:
          pass
     else:
          from .modeling_tf_openai import (
              TF_OPENAI_GPT_PRETRAINED_MODEL_ARCHIVE_LIST,
              TFOpenAIGPTDoubleHeadsModel,
              TFOpenAIGPTForSequenceClassification,
              TFOpenAIGPTLMHeadModel,
              TFOpenAIGPTMainLayer,
              TFOpenAIGPTModel,
              TFOpenAIGPTPreTrainedModel,
          )

else:
     import sys

     a_   :	List[Any]							   = _LazyModule(__name__, globals()["""__file__"""], _import_structure, module_spec=__spec__)




