


'''simple docstring'''

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      (A  , A       )       ->       str:






       """simple docstring"""







       assert isinstance(A  , A       )
       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      (A  , A  , A       )       ->       Tuple:






       """simple docstring"""







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

@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      (A  , A  , A       )       ->       Any:






       """simple docstring"""







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

@pytest.mark.parametrize(
    '''features'''  , [
        None,
        {'''col_3''': '''float64''', '''col_1''': '''string''', '''col_2''': '''int64'''},
    ]  , )
def _SCREAMING_SNAKE_CASE      (A  , A  , A       )       ->       List[str]:






       """simple docstring"""







       lowercase__      			= tmp_path / '''cache'''
       lowercase__      			= {'''col_3''': '''float64''', '''col_1''': '''string''', '''col_2''': '''int64'''}
       lowercase__      			= features.copy() if features else default_expected_features
       lowercase__      			= (
           Features({feature: Value(A       ) for feature, dtype in features.items()}       ) if features is not None else None
       )
       lowercase__      			= JsonDatasetReader(A  , features=A  , cache_dir=A       ).read()
       assert isinstance(A  , A       )
       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      (A  , A       )       ->       Union[str, Any]:






       """simple docstring"""







       lowercase__      			= {'''col_2''': '''int64''', '''col_3''': '''float64''', '''col_1''': '''string'''}
       lowercase__      			= features.copy()
       lowercase__      			= (
           Features({feature: Value(A       ) for feature, dtype in features.items()}       ) if features is not None else None
       )
       lowercase__      			= tmp_path / '''cache'''
       lowercase__      			= JsonDatasetReader(A  , features=A  , cache_dir=A       ).read()
       assert isinstance(A  , A       )
       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      (A  , A  , A       )       ->       Union[str, Any]:






       """simple docstring"""







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

@pytest.mark.parametrize('''path_type'''  , [str, list]       )
def _SCREAMING_SNAKE_CASE      (A  , A  , A       )       ->       Tuple:






       """simple docstring"""







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

def _SCREAMING_SNAKE_CASE      (A  , A  , A=("train",)       )       ->       Tuple:






       """simple docstring"""







       assert isinstance(A  , A       )
       for split in splits:
              lowercase__      			= 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      (A  , A  , A       )       ->       str:






       """simple docstring"""







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

@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      (A  , A  , A       )       ->       List[Any]:






       """simple docstring"""







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

@pytest.mark.parametrize('''split'''  , [None, NamedSplit('''train'''       ), '''train''', '''test''']       )
def _SCREAMING_SNAKE_CASE      (A  , A  , A       )       ->       Union[str, Any]:






       """simple docstring"""







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

def _SCREAMING_SNAKE_CASE      (A       )       ->       Dict:






       """simple docstring"""







       return json.load(A       )

def _SCREAMING_SNAKE_CASE      (A       )       ->       int:






       """simple docstring"""







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

class   __lowerCAmelCase						:





      '''simple docstring'''






      @pytest.mark.parametrize('''lines, load_json_function'''   ,						[(True, load_json_lines), (False, load_json)] )
      def       UpperCamelCase__		(self    :    int   ,						UpperCamelCase    :    Tuple   ,						UpperCamelCase    :    Optional[int]   ,						UpperCamelCase    :    Dict ):

             '''simple docstring'''







             with io.BytesIO() as buffer:
                    JsonDatasetWriter(UpperCamelCase   ,						UpperCamelCase   ,						lines=UpperCamelCase ).write()
                    buffer.seek(0 )
                    lowercase__      			= load_json_function(UpperCamelCase )
             assert isinstance(UpperCamelCase   ,						UpperCamelCase )
             assert isinstance(exported_content[0]   ,						UpperCamelCase )
             assert len(UpperCamelCase ) == 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       UpperCamelCase__		(self    :    List[Any]   ,						UpperCamelCase    :    Optional[Any]   ,						UpperCamelCase    :    int   ,						UpperCamelCase    :    Optional[int]   ,						UpperCamelCase    :    Optional[int]   ,						UpperCamelCase    :    List[str] ):

             '''simple docstring'''







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



      @pytest.mark.parametrize('''lines, load_json_function'''   ,						[(True, load_json_lines), (False, load_json)] )
      def       UpperCamelCase__		(self    :    Optional[Any]   ,						UpperCamelCase    :    Union[str, Any]   ,						UpperCamelCase    :    Tuple   ,						UpperCamelCase    :    Union[str, Any] ):

             '''simple docstring'''







             with io.BytesIO() as buffer:
                    JsonDatasetWriter(UpperCamelCase   ,						UpperCamelCase   ,						lines=UpperCamelCase   ,						num_proc=2 ).write()
                    buffer.seek(0 )
                    lowercase__      			= load_json_function(UpperCamelCase )
             assert isinstance(UpperCamelCase   ,						UpperCamelCase )
             assert isinstance(exported_content[0]   ,						UpperCamelCase )
             assert len(UpperCamelCase ) == 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       UpperCamelCase__		(self    :    Tuple   ,						UpperCamelCase    :    Optional[int]   ,						UpperCamelCase    :    Optional[int]   ,						UpperCamelCase    :    int   ,						UpperCamelCase    :    List[str]   ,						UpperCamelCase    :    Tuple ):

             '''simple docstring'''







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



      def       UpperCamelCase__		(self    :    Dict   ,						UpperCamelCase    :    Any ):

             '''simple docstring'''







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






      @pytest.mark.parametrize('''compression, extension'''   ,						[('''gzip''', '''gz'''), ('''bz2''', '''bz2'''), ('''xz''', '''xz''')] )
      def       UpperCamelCase__		(self    :    str   ,						UpperCamelCase    :    Dict   ,						UpperCamelCase    :    Optional[Any]   ,						UpperCamelCase    :    List[Any]   ,						UpperCamelCase    :    Any   ,						UpperCamelCase    :    List[Any] ):

             '''simple docstring'''







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

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












"""simple docstring"""





from cva import destroyAllWindows, imread, imshow, waitKey







def      lowerCamelCase__       (							_lowerCamelCase       :		Tuple )      ->				Dict:
  # getting number of pixels in the image
  lowerCamelCase_     ,	lowerCamelCase_         =						img.shape[0], img.shape[1]

  # converting each pixel's color to its negative
  for i in range(_lowerCamelCase ):
    for j in range(_lowerCamelCase ):
      lowerCamelCase_         =						[255, 255, 255] - img[i][j]

  return img


if __name__ == "__main__":
  # read original image
  _SCREAMING_SNAKE_CASE					:				List[Any]					    =						imread('''image_data/lena.jpg''', 1)

  # convert to its negative
  _SCREAMING_SNAKE_CASE					:				List[Any]					    =						convert_to_negative(img)

  # show result image
  imshow('''negative of original image''', img)
  waitKey(0)
  destroyAllWindows()




