




import io
import json

import fsspec
import pytest

from datasets import Dataset, DatasetDict, Features, NamedSplit, Value
from datasets.io.json import JsonDatasetReader, JsonDatasetWriter

from ..utils import assert_arrow_memory_doesnt_increase, assert_arrow_memory_increases

def     _SCREAMING_SNAKE_CASE    (							lowercase			: Tuple			,							lowercase			: Optional[Any]  ):


      '''simple docstring'''



      assert isinstance(lowercase			,							lowercase  )
      assert dataset.num_rows == 4
      assert dataset.num_columns == 3
      assert dataset.column_names == ["col_1", "col_2", "col_3"]
      for feature, expected_dtype in expected_features.items():
            assert dataset.features[feature].dtype == expected_dtype

@pytest.mark.parametrize('keep_in_memory'			,							[False, True]  )
def     _SCREAMING_SNAKE_CASE    (							lowercase			: Any			,							lowercase			: int			,							lowercase			: List[str]  ):


      '''simple docstring'''



      lowerCamelCase_	  =					tmp_path / 'cache'
      lowerCamelCase_	  =					{'col_1': 'string', 'col_2': 'int64', 'col_3': 'float64'}
      with assert_arrow_memory_increases() if keep_in_memory else assert_arrow_memory_doesnt_increase():
            lowerCamelCase_	  =					JsonDatasetReader(lowercase			,							cache_dir=lowercase			,							keep_in_memory=lowercase  ).read()
      _check_json_dataset(lowercase			,							lowercase  )

@pytest.mark.parametrize(
    'features'			,							[
        None,
        {'col_1': 'string', 'col_2': 'int64', 'col_3': 'float64'},
        {'col_1': 'string', 'col_2': 'string', 'col_3': 'string'},
        {'col_1': 'int32', 'col_2': 'int32', 'col_3': 'int32'},
        {'col_1': 'float32', 'col_2': 'float32', 'col_3': 'float32'},
    ]			,							)
def     _SCREAMING_SNAKE_CASE    (							lowercase			: Tuple			,							lowercase			: Optional[int]			,							lowercase			: str  ):


      '''simple docstring'''



      lowerCamelCase_	  =					tmp_path / 'cache'
      lowerCamelCase_	  =					{'col_1': 'string', 'col_2': 'int64', 'col_3': 'float64'}
      lowerCamelCase_	  =					features.copy() if features else default_expected_features
      lowerCamelCase_	  =					(
          Features({feature: Value(lowercase  ) for feature, dtype in features.items()}  ) if features is not None else None
      )
      lowerCamelCase_	  =					JsonDatasetReader(lowercase			,							features=lowercase			,							cache_dir=lowercase  ).read()
      _check_json_dataset(lowercase			,							lowercase  )

@pytest.mark.parametrize(
    'features'			,							[
        None,
        {'col_3': 'float64', 'col_1': 'string', 'col_2': 'int64'},
    ]			,							)
def     _SCREAMING_SNAKE_CASE    (							lowercase			: List[str]			,							lowercase			: Optional[int]			,							lowercase			: List[Any]  ):


      '''simple docstring'''



      lowerCamelCase_	  =					tmp_path / 'cache'
      lowerCamelCase_	  =					{'col_3': 'float64', 'col_1': 'string', 'col_2': 'int64'}
      lowerCamelCase_	  =					features.copy() if features else default_expected_features
      lowerCamelCase_	  =					(
          Features({feature: Value(lowercase  ) for feature, dtype in features.items()}  ) if features is not None else None
      )
      lowerCamelCase_	  =					JsonDatasetReader(lowercase			,							features=lowercase			,							cache_dir=lowercase  ).read()
      assert isinstance(lowercase			,							lowercase  )
      assert dataset.num_rows == 2
      assert dataset.num_columns == 3
      assert dataset.column_names == ["col_3", "col_1", "col_2"]
      for feature, expected_dtype in expected_features.items():
            assert dataset.features[feature].dtype == expected_dtype

def     _SCREAMING_SNAKE_CASE    (							lowercase			: List[Any]			,							lowercase			: Optional[int]  ):


      '''simple docstring'''



      lowerCamelCase_	  =					{'col_2': 'int64', 'col_3': 'float64', 'col_1': 'string'}
      lowerCamelCase_	  =					features.copy()
      lowerCamelCase_	  =					(
          Features({feature: Value(lowercase  ) for feature, dtype in features.items()}  ) if features is not None else None
      )
      lowerCamelCase_	  =					tmp_path / 'cache'
      lowerCamelCase_	  =					JsonDatasetReader(lowercase			,							features=lowercase			,							cache_dir=lowercase  ).read()
      assert isinstance(lowercase			,							lowercase  )
      assert dataset.num_rows == 2
      assert dataset.num_columns == 3
      assert dataset.column_names == ["col_2", "col_3", "col_1"]
      for feature, expected_dtype in expected_features.items():
            assert dataset.features[feature].dtype == expected_dtype

@pytest.mark.parametrize('split'			,							[None, NamedSplit('train'  ), 'train', 'test']  )
def     _SCREAMING_SNAKE_CASE    (							lowercase			: Optional[int]			,							lowercase			: Tuple			,							lowercase			: List[str]  ):


      '''simple docstring'''



      lowerCamelCase_	  =					tmp_path / 'cache'
      lowerCamelCase_	  =					{'col_1': 'string', 'col_2': 'int64', 'col_3': 'float64'}
      lowerCamelCase_	  =					JsonDatasetReader(lowercase			,							cache_dir=lowercase			,							split=lowercase  ).read()
      _check_json_dataset(lowercase			,							lowercase  )
      assert dataset.split == split if split else "train"

@pytest.mark.parametrize('path_type'			,							[str, list]  )
def     _SCREAMING_SNAKE_CASE    (							lowercase			: str			,							lowercase			: List[str]			,							lowercase			: List[str]  ):


      '''simple docstring'''



      if issubclass(lowercase			,							lowercase  ):
            lowerCamelCase_	  =					jsonl_path
      elif issubclass(lowercase			,							lowercase  ):
            lowerCamelCase_	  =					[jsonl_path]
      lowerCamelCase_	  =					tmp_path / 'cache'
      lowerCamelCase_	  =					{'col_1': 'string', 'col_2': 'int64', 'col_3': 'float64'}
      lowerCamelCase_	  =					JsonDatasetReader(lowercase			,							cache_dir=lowercase  ).read()
      _check_json_dataset(lowercase			,							lowercase  )

def     _SCREAMING_SNAKE_CASE    (							lowercase			: List[Any]			,							lowercase			: int			,							lowercase			: int=("train",)  ):


      '''simple docstring'''



      assert isinstance(lowercase			,							lowercase  )
      for split in splits:
            lowerCamelCase_	  =					dataset_dict[split]
            assert dataset.num_rows == 4
            assert dataset.num_columns == 3
            assert dataset.column_names == ["col_1", "col_2", "col_3"]
            for feature, expected_dtype in expected_features.items():
                  assert dataset.features[feature].dtype == expected_dtype

@pytest.mark.parametrize('keep_in_memory'			,							[False, True]  )
def     _SCREAMING_SNAKE_CASE    (							lowercase			: int			,							lowercase			: Any			,							lowercase			: Any  ):


      '''simple docstring'''



      lowerCamelCase_	  =					tmp_path / 'cache'
      lowerCamelCase_	  =					{'col_1': 'string', 'col_2': 'int64', 'col_3': 'float64'}
      with assert_arrow_memory_increases() if keep_in_memory else assert_arrow_memory_doesnt_increase():
            lowerCamelCase_	  =					JsonDatasetReader({'train': jsonl_path}			,							cache_dir=lowercase			,							keep_in_memory=lowercase  ).read()
      _check_json_datasetdict(lowercase			,							lowercase  )

@pytest.mark.parametrize(
    'features'			,							[
        None,
        {'col_1': 'string', 'col_2': 'int64', 'col_3': 'float64'},
        {'col_1': 'string', 'col_2': 'string', 'col_3': 'string'},
        {'col_1': 'int32', 'col_2': 'int32', 'col_3': 'int32'},
        {'col_1': 'float32', 'col_2': 'float32', 'col_3': 'float32'},
    ]			,							)
def     _SCREAMING_SNAKE_CASE    (							lowercase			: List[str]			,							lowercase			: List[str]			,							lowercase			: Tuple  ):


      '''simple docstring'''



      lowerCamelCase_	  =					tmp_path / 'cache'
      lowerCamelCase_	  =					{'col_1': 'string', 'col_2': 'int64', 'col_3': 'float64'}
      lowerCamelCase_	  =					features.copy() if features else default_expected_features
      lowerCamelCase_	  =					(
          Features({feature: Value(lowercase  ) for feature, dtype in features.items()}  ) if features is not None else None
      )
      lowerCamelCase_	  =					JsonDatasetReader({'train': jsonl_path}			,							features=lowercase			,							cache_dir=lowercase  ).read()
      _check_json_datasetdict(lowercase			,							lowercase  )

@pytest.mark.parametrize('split'			,							[None, NamedSplit('train'  ), 'train', 'test']  )
def     _SCREAMING_SNAKE_CASE    (							lowercase			: Any			,							lowercase			: List[Any]			,							lowercase			: List[str]  ):


      '''simple docstring'''



      if split:
            lowerCamelCase_	  =					{split: jsonl_path}
      else:
            lowerCamelCase_	  =					'train'
            lowerCamelCase_	  =					{'train': jsonl_path, 'test': jsonl_path}
      lowerCamelCase_	  =					tmp_path / 'cache'
      lowerCamelCase_	  =					{'col_1': 'string', 'col_2': 'int64', 'col_3': 'float64'}
      lowerCamelCase_	  =					JsonDatasetReader(lowercase			,							cache_dir=lowercase  ).read()
      _check_json_datasetdict(lowercase			,							lowercase			,							splits=list(path.keys()  )  )
      assert all(dataset[split].split == split for split in path.keys()  )

def     _SCREAMING_SNAKE_CASE    (							lowercase			: List[str]  ):


      '''simple docstring'''



      return json.load(lowercase  )

def     _SCREAMING_SNAKE_CASE    (							lowercase			: int  ):


      '''simple docstring'''



      return [json.loads(lowercase  ) for line in buffer]







class 						A:



 '''simple docstring'''


 @pytest.mark.parametrize('lines, load_json_function'		,							[(True, load_json_lines), (False, load_json)]						)
 def        a__				(       self      :						Optional[Any]		,							A_      :						Dict		,							A_      :						List[Any]		,							A_      :						List[str]						)     ->			Optional[int]:

       """simple docstring"""






       with io.BytesIO() as buffer:
             JsonDatasetWriter(A_		,							A_		,							lines=A_						).write()
             buffer.seek(0						)
             lowerCamelCase_	  =					load_json_function(A_						)
       assert isinstance(A_		,							A_						)
       assert isinstance(exported_content[0]		,							A_						)
       assert len(A_						) == 10

 @pytest.mark.parametrize(
     'orient, container, keys, len_at'		,							[
         ('records', list, {'tokens', 'labels', 'answers', 'id'}, None),
         ('split', dict, {'columns', 'data'}, 'data'),
         ('index', dict, set('0123456789'						), None),
         ('columns', dict, {'tokens', 'labels', 'answers', 'id'}, 'tokens'),
         ('values', list, None, None),
         ('table', dict, {'schema', 'data'}, 'data'),
     ]		,							)
 def        a__				(       self      :						Union[str, Any]		,							A_      :						List[str]		,							A_      :						List[Any]		,							A_      :						List[str]		,							A_      :						Dict		,							A_      :						List[str]						)     ->			List[Any]:

       """simple docstring"""






       with io.BytesIO() as buffer:
             JsonDatasetWriter(A_		,							A_		,							lines=A_		,							orient=A_						).write()
             buffer.seek(0						)
             lowerCamelCase_	  =					load_json(A_						)
       assert isinstance(A_		,							A_						)
       if keys:
             if container is dict:
                   assert exported_content.keys() == keys
             else:
                   assert exported_content[0].keys() == keys
       else:
             assert not hasattr(A_		,							'keys'						) and not hasattr(exported_content[0]		,							'keys'						)
       if len_at:
             assert len(exported_content[len_at]						) == 10
       else:
             assert len(A_						) == 10

 @pytest.mark.parametrize('lines, load_json_function'		,							[(True, load_json_lines), (False, load_json)]						)
 def        a__				(       self      :						str		,							A_      :						Tuple		,							A_      :						List[Any]		,							A_      :						List[str]						)     ->			Optional[int]:

       """simple docstring"""






       with io.BytesIO() as buffer:
             JsonDatasetWriter(A_		,							A_		,							lines=A_		,							num_proc=2						).write()
             buffer.seek(0						)
             lowerCamelCase_	  =					load_json_function(A_						)
       assert isinstance(A_		,							A_						)
       assert isinstance(exported_content[0]		,							A_						)
       assert len(A_						) == 10

 @pytest.mark.parametrize(
     'orient, container, keys, len_at'		,							[
         ('records', list, {'tokens', 'labels', 'answers', 'id'}, None),
         ('split', dict, {'columns', 'data'}, 'data'),
         ('index', dict, set('0123456789'						), None),
         ('columns', dict, {'tokens', 'labels', 'answers', 'id'}, 'tokens'),
         ('values', list, None, None),
         ('table', dict, {'schema', 'data'}, 'data'),
     ]		,							)
 def        a__				(       self      :						str		,							A_      :						int		,							A_      :						Union[str, Any]		,							A_      :						Tuple		,							A_      :						int		,							A_      :						Union[str, Any]						)     ->			Optional[int]:

       """simple docstring"""






       with io.BytesIO() as buffer:
             JsonDatasetWriter(A_		,							A_		,							lines=A_		,							orient=A_		,							num_proc=2						).write()
             buffer.seek(0						)
             lowerCamelCase_	  =					load_json(A_						)
       assert isinstance(A_		,							A_						)
       if keys:
             if container is dict:
                   assert exported_content.keys() == keys
             else:
                   assert exported_content[0].keys() == keys
       else:
             assert not hasattr(A_		,							'keys'						) and not hasattr(exported_content[0]		,							'keys'						)
       if len_at:
             assert len(exported_content[len_at]						) == 10
       else:
             assert len(A_						) == 10

 def        a__				(       self      :						Dict		,							A_      :						str						)     ->			List[str]:

       """simple docstring"""






       with pytest.raises(A_						):
             with io.BytesIO() as buffer:
                   JsonDatasetWriter(A_		,							A_		,							num_proc=0						)





 @pytest.mark.parametrize('compression, extension'		,							[('gzip', 'gz'), ('bz2', 'bz2'), ('xz', 'xz')]						)
 def        a__				(       self      :						Any		,							A_      :						Union[str, Any]		,							A_      :						int		,							A_      :						Tuple		,							A_      :						Union[str, Any]		,							A_      :						Optional[int]						)     ->			List[Any]:

       """simple docstring"""






       lowerCamelCase_	  =					tmp_path_factory.mktemp('data'						) / f"""test.json.{extension}"""
       lowerCamelCase_	  =					str(shared_datadir / f"""test_file.json.{extension}"""						)
       JsonDatasetWriter(A_		,							A_		,							compression=A_						).write()

       with fsspec.open(A_		,							'rb'		,							compression='infer'						) as f:
             lowerCamelCase_	  =					f.read()
       with fsspec.open(A_		,							'rb'		,							compression='infer'						) as f:
             lowerCamelCase_	  =					f.read()
       assert exported_content == original_content









from __future__ import annotations

from fractions import Fraction

def     _SCREAMING_SNAKE_CASE    (							lowercase			: int			,							lowercase			: int  ):


      '''simple docstring'''



      return (
          num != den and num % 10 == den // 10 and (num // 10) / (den % 10) == num / den
      )

def     _SCREAMING_SNAKE_CASE    (							lowercase			: int  ):


      '''simple docstring'''



      lowerCamelCase_	  =					[]
      lowerCamelCase_	  =					11
      lowerCamelCase_	  =					int('1' + '0' * digit_len  )
      for num in range(lowercase			,							lowercase  ):
            while den <= 99:
                  if (num != den) and (num % 10 == den // 10) and (den % 10 != 0):
                        if is_digit_cancelling(lowercase			,							lowercase  ):
                              solutions.append(f"""{num}/{den}"""  )
                  den += 1
            num += 1
            lowerCamelCase_	  =					10
      return solutions

def     _SCREAMING_SNAKE_CASE    (							lowercase			: int = 2  ):


      '''simple docstring'''



      lowerCamelCase_	  =					1.0
      for fraction in fraction_list(lowercase  ):
            lowerCamelCase_	  =					Fraction(lowercase  )
            result *= frac.denominator / frac.numerator
      return int(lowercase  )


if __name__ == "__main__":
 print(solution())



