code: 
  
  """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      __SCREAMING_SNAKE_CASE		(		lowercase__   ):
  					"""simple docstring"""
  					A    =      tmp_path / "file.jsonl"
  					A    =      textwrap.dedent(
  					    "\\n        {\"col_1\": -1}\n        {\"col_1\": 1, \"col_2\": 2}\n        {\"col_1\": 10, \"col_2\": 20}\n        "   )
  					with open(lowercase__    ,							"w"   ) as f:
  										f.write(lowercase__   )
  					return str(lowercase__   )
  @pytest.fixture
  def      __SCREAMING_SNAKE_CASE		(		lowercase__   ):
  					"""simple docstring"""
  					A    =      tmp_path / "file_utf16_encoded.jsonl"
  					A    =      textwrap.dedent(
  					    "\\n        {\"col_1\": -1}\n        {\"col_1\": 1, \"col_2\": 2}\n        {\"col_1\": 10, \"col_2\": 20}\n        "   )
  					with open(lowercase__    ,							"w"    ,							encoding="utf-16"   ) as f:
  										f.write(lowercase__   )
  					return str(lowercase__   )
  @pytest.fixture
  def      __SCREAMING_SNAKE_CASE		(		lowercase__   ):
  					"""simple docstring"""
  					A    =      tmp_path / "file_with_list_of_dicts.json"
  					A    =      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(lowercase__    ,							"w"   ) as f:
  										f.write(lowercase__   )
  					return str(lowercase__   )
  @pytest.fixture
  def      __SCREAMING_SNAKE_CASE		(		lowercase__   ):
  					"""simple docstring"""
  					A    =      tmp_path / "file_with_list_of_dicts_field.json"
  					A    =      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(lowercase__    ,							"w"   ) as f:
  										f.write(lowercase__   )
  					return str(lowercase__   )
  @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      __SCREAMING_SNAKE_CASE		(		lowercase__    ,							lowercase__    ,							lowercase__   ):
  					"""simple docstring"""
  					A    =      Json(**lowercase__   )
  					A    =      json._generate_tables([[request.getfixturevalue(lowercase__   )]]   )
  					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      __SCREAMING_SNAKE_CASE		(		lowercase__    ,							lowercase__    ,							lowercase__   ):
  					"""simple docstring"""
  					A    =      Json(**lowercase__   )
  					A    =      json._generate_tables([[request.getfixturevalue(lowercase__   )]]   )
  					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]}
  
  
  
  
  
  
style_context: 
  
  """simple docstring"""
  
  
  
  
  from typing import Mapping
  
  from ...configuration_utils import PretrainedConfig
  from ...onnx import OnnxSeqaSeqConfigWithPast
  from ...utils import logging
  
  
  __A  :					List[str]												=	logging.get_logger(__name__)
  
  
  
  
  
  class     __UpperCamelCase				(     _A		):
  		SCREAMING_SNAKE_CASE              =					"mt5"
  		SCREAMING_SNAKE_CASE              =					["past_key_values"]
  
  
  		def __init__(self				:	Optional[Any]  ,  __SCREAMING_SNAKE_CASE				:	Union[str, Any]=2_5_0_1_1_2  ,  __SCREAMING_SNAKE_CASE				:	int=5_1_2  ,  __SCREAMING_SNAKE_CASE				:	Tuple=6_4  ,  __SCREAMING_SNAKE_CASE				:	Union[str, Any]=1_0_2_4  ,  __SCREAMING_SNAKE_CASE				:	Optional[int]=8  ,  __SCREAMING_SNAKE_CASE				:	Any=None  ,  __SCREAMING_SNAKE_CASE				:	Tuple=6  ,  __SCREAMING_SNAKE_CASE				:	int=3_2  ,  __SCREAMING_SNAKE_CASE				:	List[Any]=1_2_8  ,  __SCREAMING_SNAKE_CASE				:	Tuple=0.1  ,  __SCREAMING_SNAKE_CASE				:	Tuple=1E-6  ,  __SCREAMING_SNAKE_CASE				:	List[Any]=1.0  ,  __SCREAMING_SNAKE_CASE				:	Optional[int]="gated-gelu"  ,  __SCREAMING_SNAKE_CASE				:	List[str]=True  ,  __SCREAMING_SNAKE_CASE				:	str=True  ,  __SCREAMING_SNAKE_CASE				:	int="T5Tokenizer"  ,  __SCREAMING_SNAKE_CASE				:	Optional[int]=False  ,  __SCREAMING_SNAKE_CASE				:	Optional[Any]=0  ,  __SCREAMING_SNAKE_CASE				:	Tuple=1  ,  __SCREAMING_SNAKE_CASE				:	List[str]=0  ,  **__SCREAMING_SNAKE_CASE				:	str  ,  ):
  							super().__init__(
  							    is_encoder_decoder=__SCREAMING_SNAKE_CASE  ,  tokenizer_class=__SCREAMING_SNAKE_CASE  ,  tie_word_embeddings=__SCREAMING_SNAKE_CASE  ,  pad_token_id=__SCREAMING_SNAKE_CASE  ,  eos_token_id=__SCREAMING_SNAKE_CASE  ,  decoder_start_token_id=__SCREAMING_SNAKE_CASE  ,  **__SCREAMING_SNAKE_CASE  ,  )
  							A    =      vocab_size
  							A    =      d_model
  							A    =      d_kv
  							A    =      d_ff
  							A    =      num_layers
  							A    =      (
  							    num_decoder_layers if num_decoder_layers is not None else self.num_layers
  							)  # default = symmetry
  							A    =      num_heads
  							A    =      relative_attention_num_buckets
  							A    =      relative_attention_max_distance
  							A    =      dropout_rate
  							A    =      layer_norm_epsilon
  							A    =      initializer_factor
  							A    =      feed_forward_proj
  							A    =      use_cache
  
  							A    =      self.feed_forward_proj.split("-")
  							A    =      act_info[-1]
  							A    =      act_info[0] == "gated"
  
  							if len(__SCREAMING_SNAKE_CASE) > 1 and act_info[0] != "gated" or len(__SCREAMING_SNAKE_CASE) > 2:
  												raise ValueError(
  												    F"""`feed_forward_proj`: {feed_forward_proj} is not a valid activation function of the dense layer."""
  												    "Please make sure `feed_forward_proj` is of the format `gated-{ACT_FN}` or `{ACT_FN}`, e.g. "
  												    "'gated-gelu' or 'relu'")
  
  							# for backwards compatibility
  							if feed_forward_proj == "gated-gelu":
  												A    =      "gelu_new"
  
  
  		@property
  		def       SCREAMING_SNAKE_CASE__     (self				:	List[Any]):
  							return self.d_model
  
  
  		@property
  		def       SCREAMING_SNAKE_CASE__     (self				:	Optional[int]):
  							return self.num_heads
  
  
  		@property
  		def       SCREAMING_SNAKE_CASE__     (self				:	Optional[int]):
  							return self.num_layers
  
  
  
  
  
  class     __UpperCamelCase				(     _A		):
  
  
  		@property
  		# Copied from transformers.models.t5.configuration_t5.T5OnnxConfig.inputs
  		def       SCREAMING_SNAKE_CASE__     (self				:	int):
  							A    =      {
  							    "input_ids": {0: "batch", 1: "encoder_sequence"},
  							    "attention_mask": {0: "batch", 1: "encoder_sequence"},
  							}
  							if self.use_past:
  												A    =      "past_encoder_sequence + sequence"
  												A    =      {0: "batch"}
  												A    =      {0: "batch", 1: "past_decoder_sequence + sequence"}
  							else:
  												A    =      {0: "batch", 1: "decoder_sequence"}
  												A    =      {0: "batch", 1: "decoder_sequence"}
  
  							if self.use_past:
  												self.fill_with_past_key_values_(__SCREAMING_SNAKE_CASE  ,  direction="inputs")
  
  							return common_inputs
  
  
  		@property
  		# Copied from transformers.models.t5.configuration_t5.T5OnnxConfig.default_onnx_opset
  		def       SCREAMING_SNAKE_CASE__     (self				:	Union[str, Any]):
  							return 1_3
  
  
  		@property
  		def       SCREAMING_SNAKE_CASE__     (self				:	int):
  							return 5E-4
  
  
  
  
  
  