


'''simple docstring'''



import contextlib
import os
import sqlitea

import pytest

from datasets import Dataset, Features, Value
from datasets.io.sql import SqlDatasetReader, SqlDatasetWriter

from ..utils import assert_arrow_memory_doesnt_increase, assert_arrow_memory_increases, require_sqlalchemy



def      UpperCAmelCase__   (      UpperCAmelCase_       :							List[Any] ,       UpperCAmelCase_       :							int				)	->						Optional[int]:
     assert isinstance(UpperCAmelCase_ ,       UpperCAmelCase_				)
     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



@require_sqlalchemy
@pytest.mark.parametrize('keep_in_memory' ,       [False, True]				)
def      UpperCAmelCase__   (      UpperCAmelCase_       :							Tuple ,       UpperCAmelCase_       :							Any ,       UpperCAmelCase_       :							Optional[Any] ,       UpperCAmelCase_       :							str				)	->						Union[str, Any]:
     __lowerCamelCase  :      List[Any]														=						tmp_path / 'cache'
     __lowerCamelCase  :      Any														=						{'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  :      str														=						SqlDatasetReader(
              'dataset' ,       'sqlite:///' + sqlite_path ,       cache_dir=UpperCAmelCase_ ,       keep_in_memory=UpperCAmelCase_				).read()
     _check_sql_dataset(UpperCAmelCase_ ,       UpperCAmelCase_				)



@require_sqlalchemy
@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      UpperCAmelCase__   (      UpperCAmelCase_       :							Any ,       UpperCAmelCase_       :							int ,       UpperCAmelCase_       :							Optional[int] ,       UpperCAmelCase_       :							List[Any]				)	->						Optional[Any]:
     __lowerCamelCase  :      Tuple														=						tmp_path / 'cache'
     __lowerCamelCase  :      Tuple														=						{'col_1': 'string', 'col_2': 'int64', 'col_3': 'float64'}
     __lowerCamelCase  :      str														=						features.copy() if features else default_expected_features
     __lowerCamelCase  :      List[Any]														=						(
         Features({feature: Value(UpperCAmelCase_				) for feature, dtype in features.items()}				) if features is not None else None
     )
     __lowerCamelCase  :      Optional[Any]														=						SqlDatasetReader('dataset' ,       'sqlite:///' + sqlite_path ,       features=UpperCAmelCase_ ,       cache_dir=UpperCAmelCase_				).read()
     _check_sql_dataset(UpperCAmelCase_ ,       UpperCAmelCase_				)



def      UpperCAmelCase__   (      UpperCAmelCase_       :							Any				)	->						Any:
     with contextlib.closing(sqlitea.connect(UpperCAmelCase_				)				) as con:
          __lowerCamelCase  :      List[str]														=						con.cursor()
          cur.execute('SELECT * FROM dataset'				)
          for row in cur:
               yield row



@require_sqlalchemy
def      UpperCAmelCase__   (      UpperCAmelCase_       :							Optional[Any] ,       UpperCAmelCase_       :							Tuple ,       UpperCAmelCase_       :							Optional[Any]				)	->						Union[str, Any]:
     __lowerCamelCase  :      Optional[int]														=						tmp_path / 'cache'
     __lowerCamelCase  :      Any														=						os.path.join(UpperCAmelCase_ ,       'tmp.sql'				)
     __lowerCamelCase  :      List[str]														=						SqlDatasetReader('dataset' ,       'sqlite:///' + sqlite_path ,       cache_dir=UpperCAmelCase_				).read()
     SqlDatasetWriter(UpperCAmelCase_ ,       'dataset' ,       'sqlite:///' + output_sqlite_path ,       num_proc=1				).write()

     __lowerCamelCase  :      Optional[Any]														=						iter_sql_file(UpperCAmelCase_				)
     __lowerCamelCase  :      int														=						iter_sql_file(UpperCAmelCase_				)

     for rowa, rowa in zip(UpperCAmelCase_ ,       UpperCAmelCase_				):
          assert rowa == rowa



@require_sqlalchemy
def      UpperCAmelCase__   (      UpperCAmelCase_       :							List[Any] ,       UpperCAmelCase_       :							Tuple ,       UpperCAmelCase_       :							Dict				)	->						List[Any]:
     __lowerCamelCase  :      List[str]														=						tmp_path / 'cache'
     __lowerCamelCase  :      Dict														=						os.path.join(UpperCAmelCase_ ,       'tmp.sql'				)
     __lowerCamelCase  :      Union[str, Any]														=						SqlDatasetReader('dataset' ,       'sqlite:///' + sqlite_path ,       cache_dir=UpperCAmelCase_				).read()
     SqlDatasetWriter(UpperCAmelCase_ ,       'dataset' ,       'sqlite:///' + output_sqlite_path ,       num_proc=2				).write()

     __lowerCamelCase  :      str														=						iter_sql_file(UpperCAmelCase_				)
     __lowerCamelCase  :      List[Any]														=						iter_sql_file(UpperCAmelCase_				)

     for rowa, rowa in zip(UpperCAmelCase_ ,       UpperCAmelCase_				):
          assert rowa == rowa



@require_sqlalchemy
def      UpperCAmelCase__   (      UpperCAmelCase_       :							str ,       UpperCAmelCase_       :							Union[str, Any] ,       UpperCAmelCase_       :							List[str]				)	->						int:
     __lowerCamelCase  :      str														=						tmp_path / 'cache'
     __lowerCamelCase  :      Dict														=						os.path.join(UpperCAmelCase_ ,       'tmp.sql'				)
     __lowerCamelCase  :      int														=						SqlDatasetReader('dataset' ,       'sqlite:///' + sqlite_path ,       cache_dir=UpperCAmelCase_				).read()
     with pytest.raises(UpperCAmelCase_				):
          SqlDatasetWriter(UpperCAmelCase_ ,       'dataset' ,       'sqlite:///' + output_sqlite_path ,       num_proc=0				).write()










'''simple docstring'''



# coding=utf-8
# Copyright 2023 The HuggingFace Inc. team.
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
#     http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.

# this script dumps information about the environment

import os
import platform
import sys


A__						:   List[str]				=    """3"""

print("""Python version:""", sys.version)

print("""OS platform:""", platform.platform())
print("""OS architecture:""", platform.machine())

try:
      import torch

      print("""Torch version:""", torch.__version__)
      print("""Cuda available:""", torch.cuda.is_available())
      print("""Cuda version:""", torch.version.cuda)
      print("""CuDNN version:""", torch.backends.cudnn.version())
      print("""Number of GPUs available:""", torch.cuda.device_count())
except ImportError:
      print("""Torch version:""", None)

try:
      import transformers

      print("""transformers version:""", transformers.__version__)
except ImportError:
      print("""transformers version:""", None)






