


import copy
import os
import tempfile
from unittest import TestCase
from unittest.mock import patch

import numpy as np
import pyarrow as pa
import pyarrow.parquet as pq
import pytest

from datasets.arrow_writer import ArrowWriter, OptimizedTypedSequence, ParquetWriter, TypedSequence
from datasets.features import ArrayaD, ClassLabel, Features, Image, Value
from datasets.features.features import ArrayaDExtensionType, cast_to_python_objects
from datasets.keyhash import DuplicatedKeysError, InvalidKeyError

from .utils import require_pil






class 	__lowercase					(	__snake_case	):





      def 							_lowercase					(		self    :       str							)     -> str:






         """simple docstring"""







         UpperCAmelCase      					=  pa.array(TypedSequence([1, 2, 3]							)							)
         self.assertEqual(arr.type       ,							pa.intaa()							)





      def 							_lowercase					(		self    :       Tuple							)     -> Optional[int]:






         """simple docstring"""







         with self.assertRaises(__lowerCamelCase							):
            UpperCAmelCase      					=  pa.array(TypedSequence([1, 2, 3]							)       ,							type=pa.intaa()							)





      def 							_lowercase					(		self    :       List[str]							)     -> Any:






         """simple docstring"""







         with self.assertRaises(__lowerCamelCase							):
            UpperCAmelCase      					=  pa.array(TypedSequence([1, 2, 3]       ,							try_type=Value("""bool"""							)       ,							type=Value("""int64"""							)							)							)





      def 							_lowercase					(		self    :       Optional[Any]							)     -> Tuple:






         """simple docstring"""







         UpperCAmelCase      					=  pa.array(TypedSequence([1, 2, 3]       ,							type=Value("""int32"""							)							)							)
         self.assertEqual(arr.type       ,							pa.intaa()							)





      def 							_lowercase					(		self    :       Tuple							)     -> str:






         """simple docstring"""







         with self.assertRaises((TypeError, pa.lib.ArrowInvalid)							):
            UpperCAmelCase      					=  pa.array(TypedSequence(["""foo""", """bar"""]       ,							type=Value("""int64"""							)							)							)





      def 							_lowercase					(		self    :       Tuple							)     -> List[Any]:






         """simple docstring"""







         UpperCAmelCase      					=  pa.array(TypedSequence([1, 2, 3]       ,							try_type=Value("""int32"""							)							)							)
         self.assertEqual(arr.type       ,							pa.intaa()							)





      def 							_lowercase					(		self    :       Tuple							)     -> str:






         """simple docstring"""







         UpperCAmelCase      					=  pa.array(TypedSequence(["""foo""", """bar"""]       ,							try_type=Value("""int64"""							)							)							)
         self.assertEqual(arr.type       ,							pa.string()							)





      def 							_lowercase					(		self    :       str							)     -> List[str]:






         """simple docstring"""







         UpperCAmelCase      					=  pa.array(TypedSequence([[[1, 2, 3]]]       ,							type=ArrayaD((1, 3)       ,							"""int64"""							)							)							)
         self.assertEqual(arr.type       ,							ArrayaDExtensionType((1, 3)       ,							"""int64"""							)							)





      def 							_lowercase					(		self    :       Union[str, Any]							)     -> int:






         """simple docstring"""







         with self.assertRaises((TypeError, pa.lib.ArrowInvalid)							):
            UpperCAmelCase      					=  pa.array(TypedSequence(["""foo""", """bar"""]       ,							type=ArrayaD((1, 3)       ,							"""int64"""							)							)							)





      def 							_lowercase					(		self    :       List[str]							)     -> Dict:






         """simple docstring"""







         UpperCAmelCase      					=  pa.array(TypedSequence([[[1, 2, 3]]]       ,							try_type=ArrayaD((1, 3)       ,							"""int64"""							)							)							)
         self.assertEqual(arr.type       ,							ArrayaDExtensionType((1, 3)       ,							"""int64"""							)							)





      def 							_lowercase					(		self    :       List[Any]							)     -> Union[str, Any]:






         """simple docstring"""







         UpperCAmelCase      					=  pa.array(TypedSequence(["""foo""", """bar"""]       ,							try_type=ArrayaD((1, 3)       ,							"""int64"""							)							)							)
         self.assertEqual(arr.type       ,							pa.string()							)





      @require_pil
      def 							_lowercase					(		self    :       int							)     -> Tuple:






         """simple docstring"""







         import PIL.Image

         UpperCAmelCase      					=  PIL.Image.fromarray(np.arange(1_0       ,							dtype=np.uinta							).reshape(2       ,							5							)							)
         with patch(
             """datasets.arrow_writer.cast_to_python_objects"""       ,							side_effect=__lowerCamelCase							) as mock_cast_to_python_objects:
            UpperCAmelCase      					=  pa.array(TypedSequence([{"""path""": None, """bytes""": B"""image_bytes"""}, pil_image]       ,							type=Image()							)							)
            UpperCAmelCase					,	UpperCAmelCase      					=  mock_cast_to_python_objects.call_args_list[-1]
            self.assertIn("""optimize_list_casting"""       ,							__lowerCamelCase							)
            self.assertFalse(kwargs["""optimize_list_casting"""]							)

def 	_UpperCamelCase					(    lowerCAmelCase_	,    lowerCAmelCase_ )    ->List[Any]:
   UpperCAmelCase      					=  pa.BufferReader(lowerCAmelCase_ ) if isinstance(lowerCAmelCase_	,    pa.Buffer ) else pa.memory_map(lowerCAmelCase_ )
   UpperCAmelCase      					=  pa.ipc.open_stream(lowerCAmelCase_ )
   UpperCAmelCase      					=  f.read_all()
   assert len(pa_table.to_batches() ) == expected_num_chunks
   assert pa_table.to_pydict() == {"col_1": ["foo", "bar"], "col_2": [1, 2]}
   del pa_table
@pytest.mark.parametrize("""writer_batch_size"""	,    [None, 1, 1_0] )
@pytest.mark.parametrize(
    """fields"""	,    [None, {"""col_1""": pa.string(), """col_2""": pa.intaa()}, {"""col_1""": pa.string(), """col_2""": pa.intaa()}] )
def 	_UpperCamelCase					(    lowerCAmelCase_	,    lowerCAmelCase_ )    ->int:
   UpperCAmelCase      					=  pa.BufferOutputStream()
   UpperCAmelCase      					=  pa.schema(lowerCAmelCase_ ) if fields else None
   with ArrowWriter(stream=lowerCAmelCase_	,    schema=lowerCAmelCase_	,    writer_batch_size=lowerCAmelCase_ ) as writer:
      writer.write({"""col_1""": """foo""", """col_2""": 1} )
      writer.write({"""col_1""": """bar""", """col_2""": 2} )
      UpperCAmelCase					,	UpperCAmelCase      					=  writer.finalize()
   assert num_examples == 2
   assert num_bytes > 0
   if not fields:
      UpperCAmelCase      					=  {"""col_1""": pa.string(), """col_2""": pa.intaa()}
   assert writer._schema == pa.schema(lowerCAmelCase_	,    metadata=writer._schema.metadata )
   _check_output(output.getvalue()	,    expected_num_chunks=num_examples if writer_batch_size == 1 else 1 )
def 	_UpperCamelCase					(    )    ->Any:
   UpperCAmelCase      					=  pa.BufferOutputStream()
   UpperCAmelCase      					=  Features({"""labels""": ClassLabel(names=["""neg""", """pos"""] )} )
   with ArrowWriter(stream=lowerCAmelCase_	,    features=lowerCAmelCase_ ) as writer:
      writer.write({"""labels""": 0} )
      writer.write({"""labels""": 1} )
      UpperCAmelCase					,	UpperCAmelCase      					=  writer.finalize()
   assert num_examples == 2
   assert num_bytes > 0
   assert writer._schema == features.arrow_schema
   assert writer._schema.metadata == features.arrow_schema.metadata
   UpperCAmelCase      					=  pa.BufferReader(output.getvalue() )
   UpperCAmelCase      					=  pa.ipc.open_stream(lowerCAmelCase_ )
   UpperCAmelCase      					=  f.read_all()
   UpperCAmelCase      					=  pa_table.schema
   assert pa_table.num_rows == 2
   assert schema == features.arrow_schema
   assert schema.metadata == features.arrow_schema.metadata
   assert features == Features.from_arrow_schema(lowerCAmelCase_ )
@pytest.mark.parametrize("""writer_batch_size"""	,    [None, 1, 1_0] )
def 	_UpperCamelCase					(    lowerCAmelCase_ )    ->Union[str, Any]:
   UpperCAmelCase      					=  pa.BufferOutputStream()
   with ArrowWriter(
       stream=lowerCAmelCase_	,    writer_batch_size=lowerCAmelCase_	,    hash_salt="""split_name"""	,    check_duplicates=lowerCAmelCase_	,    ) as writer:
      with pytest.raises(lowerCAmelCase_ ):
         writer.write({"""col_1""": """foo""", """col_2""": 1}	,    key=[1, 2] )
         UpperCAmelCase					,	UpperCAmelCase      					=  writer.finalize()
@pytest.mark.parametrize("""writer_batch_size"""	,    [None, 2, 1_0] )
def 	_UpperCamelCase					(    lowerCAmelCase_ )    ->List[str]:
   UpperCAmelCase      					=  pa.BufferOutputStream()
   with ArrowWriter(
       stream=lowerCAmelCase_	,    writer_batch_size=lowerCAmelCase_	,    hash_salt="""split_name"""	,    check_duplicates=lowerCAmelCase_	,    ) as writer:
      with pytest.raises(lowerCAmelCase_ ):
         writer.write({"""col_1""": """foo""", """col_2""": 1}	,    key=1_0 )
         writer.write({"""col_1""": """bar""", """col_2""": 2}	,    key=1_0 )
         UpperCAmelCase					,	UpperCAmelCase      					=  writer.finalize()
@pytest.mark.parametrize("""writer_batch_size"""	,    [None, 2, 1_0] )
def 	_UpperCamelCase					(    lowerCAmelCase_ )    ->Dict:
   UpperCAmelCase      					=  pa.BufferOutputStream()
   with ArrowWriter(
       stream=lowerCAmelCase_	,    writer_batch_size=lowerCAmelCase_	,    hash_salt="""split_name"""	,    check_duplicates=lowerCAmelCase_	,    ) as writer:
      writer.write({"""col_1""": """foo""", """col_2""": 1}	,    key=1 )
      writer.write({"""col_1""": """bar""", """col_2""": 2}	,    key=2 )
      UpperCAmelCase					,	UpperCAmelCase      					=  writer.finalize()
   assert num_examples == 2
   assert num_bytes > 0
   _check_output(output.getvalue()	,    expected_num_chunks=num_examples if writer_batch_size == 1 else 1 )
@pytest.mark.parametrize("""writer_batch_size"""	,    [None, 1, 1_0] )
@pytest.mark.parametrize(
    """fields"""	,    [None, {"""col_1""": pa.string(), """col_2""": pa.intaa()}, {"""col_1""": pa.string(), """col_2""": pa.intaa()}] )
def 	_UpperCamelCase					(    lowerCAmelCase_	,    lowerCAmelCase_ )    ->str:
   UpperCAmelCase      					=  pa.BufferOutputStream()
   UpperCAmelCase      					=  pa.schema(lowerCAmelCase_ ) if fields else None
   with ArrowWriter(stream=lowerCAmelCase_	,    schema=lowerCAmelCase_	,    writer_batch_size=lowerCAmelCase_ ) as writer:
      writer.write_batch({"""col_1""": ["""foo""", """bar"""], """col_2""": [1, 2]} )
      writer.write_batch({"""col_1""": [], """col_2""": []} )
      UpperCAmelCase					,	UpperCAmelCase      					=  writer.finalize()
   assert num_examples == 2
   assert num_bytes > 0
   if not fields:
      UpperCAmelCase      					=  {"""col_1""": pa.string(), """col_2""": pa.intaa()}
   assert writer._schema == pa.schema(lowerCAmelCase_	,    metadata=writer._schema.metadata )
   _check_output(output.getvalue()	,    expected_num_chunks=num_examples if writer_batch_size == 1 else 1 )
@pytest.mark.parametrize("""writer_batch_size"""	,    [None, 1, 1_0] )
@pytest.mark.parametrize(
    """fields"""	,    [None, {"""col_1""": pa.string(), """col_2""": pa.intaa()}, {"""col_1""": pa.string(), """col_2""": pa.intaa()}] )
def 	_UpperCamelCase					(    lowerCAmelCase_	,    lowerCAmelCase_ )    ->Dict:
   UpperCAmelCase      					=  pa.BufferOutputStream()
   UpperCAmelCase      					=  pa.schema(lowerCAmelCase_ ) if fields else None
   with ArrowWriter(stream=lowerCAmelCase_	,    schema=lowerCAmelCase_	,    writer_batch_size=lowerCAmelCase_ ) as writer:
      writer.write_table(pa.Table.from_pydict({"""col_1""": ["""foo""", """bar"""], """col_2""": [1, 2]} ) )
      UpperCAmelCase					,	UpperCAmelCase      					=  writer.finalize()
   assert num_examples == 2
   assert num_bytes > 0
   if not fields:
      UpperCAmelCase      					=  {"""col_1""": pa.string(), """col_2""": pa.intaa()}
   assert writer._schema == pa.schema(lowerCAmelCase_	,    metadata=writer._schema.metadata )
   _check_output(output.getvalue()	,    expected_num_chunks=num_examples if writer_batch_size == 1 else 1 )
@pytest.mark.parametrize("""writer_batch_size"""	,    [None, 1, 1_0] )
@pytest.mark.parametrize(
    """fields"""	,    [None, {"""col_1""": pa.string(), """col_2""": pa.intaa()}, {"""col_1""": pa.string(), """col_2""": pa.intaa()}] )
def 	_UpperCamelCase					(    lowerCAmelCase_	,    lowerCAmelCase_ )    ->int:
   UpperCAmelCase      					=  pa.BufferOutputStream()
   UpperCAmelCase      					=  pa.schema(lowerCAmelCase_ ) if fields else None
   with ArrowWriter(stream=lowerCAmelCase_	,    schema=lowerCAmelCase_	,    writer_batch_size=lowerCAmelCase_ ) as writer:
      writer.write_row(pa.Table.from_pydict({"""col_1""": ["""foo"""], """col_2""": [1]} ) )
      writer.write_row(pa.Table.from_pydict({"""col_1""": ["""bar"""], """col_2""": [2]} ) )
      UpperCAmelCase					,	UpperCAmelCase      					=  writer.finalize()
   assert num_examples == 2
   assert num_bytes > 0
   if not fields:
      UpperCAmelCase      					=  {"""col_1""": pa.string(), """col_2""": pa.intaa()}
   assert writer._schema == pa.schema(lowerCAmelCase_	,    metadata=writer._schema.metadata )
   _check_output(output.getvalue()	,    expected_num_chunks=num_examples if writer_batch_size == 1 else 1 )
def 	_UpperCamelCase					(    )    ->Union[str, Any]:
   with tempfile.TemporaryDirectory() as tmp_dir:
      UpperCAmelCase      					=  {"""col_1""": pa.string(), """col_2""": pa.intaa()}
      UpperCAmelCase      					=  os.path.join(lowerCAmelCase_	,    """test.arrow""" )
      with ArrowWriter(path=lowerCAmelCase_	,    schema=pa.schema(lowerCAmelCase_ ) ) as writer:
         writer.write_batch({"""col_1""": ["""foo""", """bar"""], """col_2""": [1, 2]} )
         UpperCAmelCase					,	UpperCAmelCase      					=  writer.finalize()
      assert num_examples == 2
      assert num_bytes > 0
      assert writer._schema == pa.schema(lowerCAmelCase_	,    metadata=writer._schema.metadata )
      _check_output(lowerCAmelCase_	,    1 )
def 	_UpperCamelCase					(    lowerCAmelCase_ )    ->str:
   if pa.types.is_list(lowerCAmelCase_ ):
      return get_base_dtype(arr_type.value_type )
   else:
      return arr_type
def 	_UpperCamelCase					(    lowerCAmelCase_	,    lowerCAmelCase_ )    ->int:
   if isinstance(lst[0]	,    lowerCAmelCase_ ):
      change_first_primitive_element_in_list(lst[0]	,    lowerCAmelCase_ )
   else:
      UpperCAmelCase      					=  value
@pytest.mark.parametrize("""optimized_int_type, expected_dtype"""	,    [(None, pa.intaa()), (Value("""int32""" ), pa.intaa())] )
@pytest.mark.parametrize("""sequence"""	,    [[1, 2, 3], [[1, 2, 3]], [[[1, 2, 3]]]] )
def 	_UpperCamelCase					(    lowerCAmelCase_	,    lowerCAmelCase_	,    lowerCAmelCase_ )    ->List[str]:
   UpperCAmelCase      					=  pa.array(TypedSequence(lowerCAmelCase_	,    optimized_int_type=lowerCAmelCase_ ) )
   assert get_base_dtype(arr.type ) == expected_dtype
@pytest.mark.parametrize(
    """col, expected_dtype"""	,    [
        ("""attention_mask""", pa.inta()),
        ("""special_tokens_mask""", pa.inta()),
        ("""token_type_ids""", pa.inta()),
        ("""input_ids""", pa.intaa()),
        ("""other""", pa.intaa()),
    ]	,    )
@pytest.mark.parametrize("""sequence"""	,    [[1, 2, 3], [[1, 2, 3]], [[[1, 2, 3]]]] )
def 	_UpperCamelCase					(    lowerCAmelCase_	,    lowerCAmelCase_	,    lowerCAmelCase_ )    ->str:
   # in range
   UpperCAmelCase      					=  pa.array(OptimizedTypedSequence(lowerCAmelCase_	,    col=lowerCAmelCase_ ) )
   assert get_base_dtype(arr.type ) == expected_dtype

   # not in range
   if col != "other":
      # avoids errors due to in-place modifications
      UpperCAmelCase      					=  copy.deepcopy(lowerCAmelCase_ )
      UpperCAmelCase      					=  np.iinfo(expected_dtype.to_pandas_dtype() ).max + 1
      change_first_primitive_element_in_list(lowerCAmelCase_	,    lowerCAmelCase_ )
      UpperCAmelCase      					=  pa.array(OptimizedTypedSequence(lowerCAmelCase_	,    col=lowerCAmelCase_ ) )
      assert get_base_dtype(arr.type ) == pa.intaa()
@pytest.mark.parametrize("""raise_exception"""	,    [False, True] )
def 	_UpperCamelCase					(    lowerCAmelCase_	,    lowerCAmelCase_ )    ->Optional[Any]:
   UpperCAmelCase      					=  str(tmp_path / """dataset-train.arrow""" )
   try:
      with ArrowWriter(path=lowerCAmelCase_ ) as writer:
         if raise_exception:
            raise pa.lib.ArrowInvalid()
         else:
            writer.stream.close()
   except pa.lib.ArrowInvalid:
      pass
   finally:
      assert writer.stream.closed
def 	_UpperCamelCase					(    lowerCAmelCase_ )    ->Dict:
   UpperCAmelCase      					=  """mock://dataset-train.arrow"""
   with ArrowWriter(path=lowerCAmelCase_	,    storage_options=mockfs.storage_options ) as writer:
      assert isinstance(writer._fs	,    type(lowerCAmelCase_ ) )
      assert writer._fs.storage_options == mockfs.storage_options
      writer.write({"""col_1""": """foo""", """col_2""": 1} )
      writer.write({"""col_1""": """bar""", """col_2""": 2} )
      UpperCAmelCase					,	UpperCAmelCase      					=  writer.finalize()
   assert num_examples == 2
   assert num_bytes > 0
   assert mockfs.exists(lowerCAmelCase_ )
def 	_UpperCamelCase					(    )    ->List[str]:
   UpperCAmelCase      					=  pa.BufferOutputStream()
   with ParquetWriter(stream=lowerCAmelCase_ ) as writer:
      writer.write({"""col_1""": """foo""", """col_2""": 1} )
      writer.write({"""col_1""": """bar""", """col_2""": 2} )
      UpperCAmelCase					,	UpperCAmelCase      					=  writer.finalize()
   assert num_examples == 2
   assert num_bytes > 0
   UpperCAmelCase      					=  pa.BufferReader(output.getvalue() )
   UpperCAmelCase      					=  pq.read_table(lowerCAmelCase_ )
   assert pa_table.to_pydict() == {"col_1": ["foo", "bar"], "col_2": [1, 2]}
@require_pil
@pytest.mark.parametrize("""embed_local_files"""	,    [False, True] )
def 	_UpperCamelCase					(    lowerCAmelCase_	,    lowerCAmelCase_ )    ->Any:
   import PIL.Image

   UpperCAmelCase      					=  str(tmp_path / """test_image_rgb.jpg""" )
   PIL.Image.fromarray(np.zeros((5, 5)	,    dtype=np.uinta ) ).save(lowerCAmelCase_	,    format="""png""" )
   UpperCAmelCase      					=  pa.BufferOutputStream()
   with ParquetWriter(
       stream=lowerCAmelCase_	,    features=Features({"""image""": Image()} )	,    embed_local_files=lowerCAmelCase_ ) as writer:
      writer.write({"""image""": image_path} )
      writer.finalize()
   UpperCAmelCase      					=  pa.BufferReader(output.getvalue() )
   UpperCAmelCase      					=  pq.read_table(lowerCAmelCase_ )
   UpperCAmelCase      					=  pa_table.to_pydict()
   if embed_local_files:
      assert isinstance(out["""image"""][0]["""path"""]	,    lowerCAmelCase_ )
      with open(lowerCAmelCase_	,    """rb""" ) as f:
         assert out["image"][0]["bytes"] == f.read()
   else:
      assert out["image"][0]["path"] == image_path
      assert out["image"][0]["bytes"] is None







def 	_UpperCamelCase					(    )    ->Dict:
   UpperCAmelCase      					=  pa.schema([pa.field("""col_1"""	,    pa.string()	,    nullable=lowerCAmelCase_ )] )
   UpperCAmelCase      					=  pa.BufferOutputStream()
   with ArrowWriter(stream=lowerCAmelCase_ ) as writer:
      writer._build_writer(inferred_schema=lowerCAmelCase_ )
      assert writer._schema == pa.schema([pa.field("""col_1"""	,    pa.string() )] )







def 	_UpperCamelCase					(    lowerCAmelCase_ )    ->int:
   if n == 1 or not isinstance(lowerCAmelCase_	,    lowerCAmelCase_ ):
      return 0
   elif n == 2:
      return 1
   else:
      UpperCAmelCase      					=  [0, 1]
      for i in range(2	,    n + 1 ):
         sequence.append(sequence[i - 1] + sequence[i - 2] )

      return sequence[n]
def 	_UpperCamelCase					(    lowerCAmelCase_ )    ->int:
   UpperCAmelCase      					=  0
   UpperCAmelCase      					=  2

   while digits < n:
      index += 1
      UpperCAmelCase      					=  len(str(fibonacci(lowerCAmelCase_ ) ) )

   return index
def 	_UpperCamelCase					(    lowerCAmelCase_ = 1_0_0_0 )    ->int:
   return fibonacci_digits_index(lowerCAmelCase_ )


if __name__ == "__main__":
 print(solution(int(str(input()).strip())))



