


import inspect
import unittest

from transformers import ResNetConfig
from transformers.testing_utils import require_torch, require_vision, slow, torch_device
from transformers.utils import cached_property, is_torch_available, is_vision_available

from ...test_backbone_common import BackboneTesterMixin
from ...test_configuration_common import ConfigTester
from ...test_modeling_common import ModelTesterMixin, floats_tensor, ids_tensor
from ...test_pipeline_mixin import PipelineTesterMixin


if is_torch_available():
      import torch
      from torch import nn

      from transformers import ResNetBackbone, ResNetForImageClassification, ResNetModel
      from transformers.models.resnet.modeling_resnet import RESNET_PRETRAINED_MODEL_ARCHIVE_LIST


if is_vision_available():
      from PIL import Image

      from transformers import AutoImageProcessor




class  A_ :







 """simple docstring"""





 def __init__(      self       :			Any							,     _a       :			List[str]							,     _a       :			Optional[Any]=3							,     _a       :			Optional[int]=3_2							,     _a       :			Optional[int]=3							,     _a       :			str=1_0							,     _a       :			Dict=[1_0, 2_0, 3_0, 4_0]							,     _a       :			List[Any]=[1, 1, 2, 1]							,     _a       :			Dict=True							,     _a       :			Union[str, Any]=True							,     _a       :			Tuple="relu"							,     _a       :			List[str]=3							,     _a       :			List[str]=None							,     _a       :			List[str]=["stage2", "stage3", "stage4"]							,     _a       :			str=[2, 3, 4]							,     )     ->      List[Any]:
      UpperCAmelCase    :					Tuple			=      parent
      UpperCAmelCase    :					int			=      batch_size
      UpperCAmelCase    :					Optional[int]			=      image_size
      UpperCAmelCase    :					List[str]			=      num_channels
      UpperCAmelCase    :					Dict			=      embeddings_size
      UpperCAmelCase    :					List[str]			=      hidden_sizes
      UpperCAmelCase    :					int			=      depths
      UpperCAmelCase    :					Dict			=      is_training
      UpperCAmelCase    :					Optional[int]			=      use_labels
      UpperCAmelCase    :					Union[str, Any]			=      hidden_act
      UpperCAmelCase    :					Optional[Any]			=      num_labels
      UpperCAmelCase    :					List[Any]			=      scope
      UpperCAmelCase    :					Tuple			=      len(snake_case_					)
      UpperCAmelCase    :					Dict			=      out_features
      UpperCAmelCase    :					Dict			=      out_indices
 def 	_UpperCamelCase     (      self       :			List[str]					)     ->      Optional[Any]:
      UpperCAmelCase    :					Optional[Any]			=      floats_tensor([self.batch_size, self.num_channels, self.image_size, self.image_size]					)

      UpperCAmelCase    :					List[str]			=      None
      if self.use_labels:
           UpperCAmelCase    :					str			=      ids_tensor([self.batch_size]							,     self.num_labels					)

      UpperCAmelCase    :					List[str]			=      self.get_config()

      return config, pixel_values, labels
 def 	_UpperCamelCase     (      self       :			str					)     ->      List[str]:
      return ResNetConfig(
          num_channels=self.num_channels							,     embeddings_size=self.embeddings_size							,     hidden_sizes=self.hidden_sizes							,     depths=self.depths							,     hidden_act=self.hidden_act							,     num_labels=self.num_labels							,     out_features=self.out_features							,     out_indices=self.out_indices							,     )
 def 	_UpperCamelCase     (      self       :			Dict							,     _a       :			List[Any]							,     _a       :			Union[str, Any]							,     _a       :			Optional[int]					)     ->      Optional[int]:
      UpperCAmelCase    :					Dict			=      ResNetModel(config=snake_case_					)
      model.to(snake_case_					)
      model.eval()
      UpperCAmelCase    :					List[Any]			=      model(snake_case_					)
      # expected last hidden states: B, C, H // 32, W // 32
      self.parent.assertEqual(
          result.last_hidden_state.shape							,     (self.batch_size, self.hidden_sizes[-1], self.image_size // 3_2, self.image_size // 3_2)							,     )
 def 	_UpperCamelCase     (      self       :			List[Any]							,     _a       :			str							,     _a       :			Optional[Any]							,     _a       :			Optional[Any]					)     ->      Any:
      UpperCAmelCase    :					Any			=      self.num_labels
      UpperCAmelCase    :					Optional[Any]			=      ResNetForImageClassification(snake_case_					)
      model.to(snake_case_					)
      model.eval()
      UpperCAmelCase    :					Optional[int]			=      model(snake_case_							,     labels=snake_case_					)
      self.parent.assertEqual(result.logits.shape							,     (self.batch_size, self.num_labels)					)
 def 	_UpperCamelCase     (      self       :			Any							,     _a       :			Union[str, Any]							,     _a       :			List[str]							,     _a       :			List[Any]					)     ->      Tuple:
      UpperCAmelCase    :					List[Any]			=      ResNetBackbone(config=snake_case_					)
      model.to(snake_case_					)
      model.eval()
      UpperCAmelCase    :					Dict			=      model(snake_case_					)

      # verify feature maps
      self.parent.assertEqual(len(result.feature_maps					)							,     len(config.out_features					)					)
      self.parent.assertListEqual(list(result.feature_maps[0].shape					)							,     [self.batch_size, self.hidden_sizes[1], 4, 4]					)

      # verify channels
      self.parent.assertEqual(len(model.channels					)							,     len(config.out_features					)					)
      self.parent.assertListEqual(model.channels							,     config.hidden_sizes[1:]					)

      # verify backbone works with out_features=None
      UpperCAmelCase    :					Tuple			=      None
      UpperCAmelCase    :					Tuple			=      ResNetBackbone(config=snake_case_					)
      model.to(snake_case_					)
      model.eval()
      UpperCAmelCase    :					List[Any]			=      model(snake_case_					)

      # verify feature maps
      self.parent.assertEqual(len(result.feature_maps					)							,     1					)
      self.parent.assertListEqual(list(result.feature_maps[0].shape					)							,     [self.batch_size, self.hidden_sizes[-1], 1, 1]					)

      # verify channels
      self.parent.assertEqual(len(model.channels					)							,     1					)
      self.parent.assertListEqual(model.channels							,     [config.hidden_sizes[-1]]					)

 def 	_UpperCamelCase     (      self       :			Union[str, Any]					)     ->      List[Any]:
      UpperCAmelCase    :					List[Any]			=      self.prepare_config_and_inputs()
      UpperCAmelCase    :					List[Any]			=      config_and_inputs
      UpperCAmelCase    :					str			=      {'pixel_values': pixel_values}
      return config, inputs_dict




@require_torch
class  A_ (			lowerCamelCase_   ,    lowerCamelCase_   ,    unittest.TestCase  ):







 """simple docstring"""





 _UpperCamelCase					:			str     	=       (
     (
         ResNetModel,
         ResNetForImageClassification,
         ResNetBackbone,
     )
     if is_torch_available()
     else ()
 )
 _UpperCamelCase					:			List[str]     	=       (
     {'''feature-extraction''': ResNetModel, '''image-classification''': ResNetForImageClassification}
     if is_torch_available()
     else {}
 )

 _UpperCamelCase					:			int     	=       True
 _UpperCamelCase					:			Optional[Any]     	=       False
 _UpperCamelCase					:			Union[str, Any]     	=       False
 _UpperCamelCase					:			int     	=       False
 _UpperCamelCase					:			str     	=       False
 def 	_UpperCamelCase     (      self       :			int					)     ->      Dict:
      UpperCAmelCase    :					Dict			=      ResNetModelTester(self					)
      UpperCAmelCase    :					int			=      ConfigTester(self							,     config_class=snake_case_							,     has_text_modality=snake_case_					)
 def 	_UpperCamelCase     (      self       :			Dict					)     ->      str:
      self.create_and_test_config_common_properties()
      self.config_tester.create_and_test_config_to_json_string()
      self.config_tester.create_and_test_config_to_json_file()
      self.config_tester.create_and_test_config_from_and_save_pretrained()
      self.config_tester.create_and_test_config_with_num_labels()
      self.config_tester.check_config_can_be_init_without_params()
      self.config_tester.check_config_arguments_init()
 def 	_UpperCamelCase     (      self       :			int					)     ->      Optional[Any]:
      return
 @unittest.skip(reason="ResNet does not use inputs_embeds"					)
 def 	_UpperCamelCase     (      self       :			Union[str, Any]					)     ->      Tuple:
      pass
 @unittest.skip(reason="ResNet does not support input and output embeddings"					)
 def 	_UpperCamelCase     (      self       :			Dict					)     ->      Tuple:
      pass
 def 	_UpperCamelCase     (      self       :			Any					)     ->      str:
      UpperCAmelCase    :					List[Any]			=      self.model_tester.prepare_config_and_inputs_for_common()

      for model_class in self.all_model_classes:
           UpperCAmelCase    :					Optional[int]			=      model_class(snake_case_					)
           UpperCAmelCase    :					Any			=      inspect.signature(model.forward					)
           # signature.parameters is an OrderedDict => so arg_names order is deterministic
           UpperCAmelCase    :					Any			=      [*signature.parameters.keys()]

           UpperCAmelCase    :					List[str]			=      ['pixel_values']
           self.assertListEqual(arg_names[:1]							,     snake_case_					)
 def 	_UpperCamelCase     (      self       :			Tuple					)     ->      Optional[Any]:
      UpperCAmelCase    :					Optional[int]			=      self.model_tester.prepare_config_and_inputs()
      self.model_tester.create_and_check_model(*snake_case_					)
 def 	_UpperCamelCase     (      self       :			Optional[Any]					)     ->      str:
      UpperCAmelCase    :					Any			=      self.model_tester.prepare_config_and_inputs()
      self.model_tester.create_and_check_backbone(*snake_case_					)
 def 	_UpperCamelCase     (      self       :			Optional[int]					)     ->      Tuple:
      UpperCAmelCase    :					List[str]			=      self.model_tester.prepare_config_and_inputs_for_common()

      for model_class in self.all_model_classes:
           UpperCAmelCase    :					List[Any]			=      model_class(config=snake_case_					)
           for name, module in model.named_modules():
                if isinstance(snake_case_							,     (nn.BatchNormad, nn.GroupNorm)					):
                     self.assertTrue(
                         torch.all(module.weight == 1					)							,     msg=f'Parameter {name} of model {model_class} seems not properly initialized'							,     )
                     self.assertTrue(
                         torch.all(module.bias == 0					)							,     msg=f'Parameter {name} of model {model_class} seems not properly initialized'							,     )
 def 	_UpperCamelCase     (      self       :			Tuple					)     ->      int:

      def check_hidden_states_output(_a       :			Optional[Any]							,     _a       :			Optional[int]							,     _a       :			int					):
           UpperCAmelCase    :					int			=      model_class(snake_case_					)
           model.to(snake_case_					)
           model.eval()

           with torch.no_grad():
                UpperCAmelCase    :					str			=      model(**self._prepare_for_class(snake_case_							,     snake_case_					)					)

           UpperCAmelCase    :					Union[str, Any]			=      outputs.encoder_hidden_states if config.is_encoder_decoder else outputs.hidden_states

           UpperCAmelCase    :					str			=      self.model_tester.num_stages
           self.assertEqual(len(snake_case_					)							,     expected_num_stages + 1					)

           # ResNet's feature maps are of shape (batch_size, num_channels, height, width)
           self.assertListEqual(
               list(hidden_states[0].shape[-2:]					)							,     [self.model_tester.image_size // 4, self.model_tester.image_size // 4]							,     )

      UpperCAmelCase    :					Any			=      self.model_tester.prepare_config_and_inputs_for_common()
      UpperCAmelCase    :					Optional[Any]			=      ['basic', 'bottleneck']
      for model_class in self.all_model_classes:
           for layer_type in layers_type:
                UpperCAmelCase    :					Any			=      layer_type
                UpperCAmelCase    :					str			=      True
                check_hidden_states_output(snake_case_							,     snake_case_							,     snake_case_					)

                # check that output_hidden_states also work using config
                del inputs_dict["output_hidden_states"]
                UpperCAmelCase    :					List[Any]			=      True

                check_hidden_states_output(snake_case_							,     snake_case_							,     snake_case_					)
 @unittest.skip(reason="ResNet does not use feedforward chunking"					)
 def 	_UpperCamelCase     (      self       :			List[str]					)     ->      str:
      pass
 def 	_UpperCamelCase     (      self       :			List[Any]					)     ->      str:
      UpperCAmelCase    :					Dict			=      self.model_tester.prepare_config_and_inputs()
      self.model_tester.create_and_check_for_image_classification(*snake_case_					)

 @slow
 def 	_UpperCamelCase     (      self       :			List[str]					)     ->      Optional[int]:

      for model_name in RESNET_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
           UpperCAmelCase    :					str			=      ResNetModel.from_pretrained(snake_case_					)
           self.assertIsNotNone(snake_case_					)







def 	A (		):
     UpperCAmelCase    :					Union[str, Any]			=      Image.open("./tests/fixtures/tests_samples/COCO/000000039769.png"			)
     return image




@require_torch
@require_vision
class  A_ (			unittest.TestCase  ):







 """simple docstring"""





 @cached_property
 def 	_UpperCamelCase     (      self       :			int					)     ->      Tuple:
      return (
          AutoImageProcessor.from_pretrained(RESNET_PRETRAINED_MODEL_ARCHIVE_LIST[0]					)
          if is_vision_available()
          else None
      )

 @slow
 def 	_UpperCamelCase     (      self       :			List[str]					)     ->      List[Any]:
      UpperCAmelCase    :					str			=      ResNetForImageClassification.from_pretrained(RESNET_PRETRAINED_MODEL_ARCHIVE_LIST[0]					).to(snake_case_					)

      UpperCAmelCase    :					str			=      self.default_image_processor
      UpperCAmelCase    :					Union[str, Any]			=      prepare_img()
      UpperCAmelCase    :					Union[str, Any]			=      image_processor(images=snake_case_							,     return_tensors="pt"					).to(snake_case_					)

      # forward pass
      with torch.no_grad():
           UpperCAmelCase    :					Union[str, Any]			=      model(**snake_case_					)

      # verify the logits
      UpperCAmelCase    :					Union[str, Any]			=      torch.Size((1, 1_0_0_0)					)
      self.assertEqual(outputs.logits.shape							,     snake_case_					)

      UpperCAmelCase    :					Optional[int]			=      torch.tensor([-1_1.1_0_6_9, -9.7_8_7_7, -8.3_7_7_7]					).to(snake_case_					)

      self.assertTrue(torch.allclose(outputs.logits[0, :3]							,     snake_case_							,     atol=1E-4					)					)




@require_torch
class  A_ (			lowerCamelCase_   ,    unittest.TestCase  ):







 """simple docstring"""





 _UpperCamelCase					:			Any     	=       (ResNetBackbone,) if is_torch_available() else ()
 _UpperCamelCase					:			List[str]     	=       False
 _UpperCamelCase					:			Optional[Any]     	=       ResNetConfig
 def 	_UpperCamelCase     (      self       :			Union[str, Any]					)     ->      int:
      UpperCAmelCase    :					List[Any]			=      ResNetModelTester(self					)




'''simple docstring'''


import sys
from dataclasses import dataclass
from typing import TYPE_CHECKING, Dict, List, Optional, Tuple, Union

import pandas as pd
import pyarrow as pa

import datasets
import datasets.config
from datasets.features.features import require_storage_cast
from datasets.table import table_cast


if TYPE_CHECKING:
 import sqlitea

 import sqlalchemy


snake_case__	:     int      =    datasets.utils.logging.get_logger(__name__)






@dataclass
class 	__SCREAMING_SNAKE_CASE		(			datasets.BuilderConfig			):







  '''simple docstring'''






  lowerCamelCase_						:Union[str, "sqlalchemy.sql.Selectable"]		       =						None
  lowerCamelCase_						:Union[str, "sqlalchemy.engine.Connection", "sqlalchemy.engine.Engine", "sqlite3.Connection"]		       =						None
  lowerCamelCase_						:Optional[Union[str, List[str]]]		       =						None
  lowerCamelCase_						:bool		       =						True
  lowerCamelCase_						:Optional[Union[List, Tuple, Dict]]		       =						None
  lowerCamelCase_						:Optional[Union[List, Dict]]		       =						None
  lowerCamelCase_						:Optional[List[str]]		       =						None
  lowerCamelCase_						:Optional[int]		       =						1_0000
  lowerCamelCase_						:Optional[datasets.Features]		       =						None


  def _UpperCamelCase	(					self		):




       '''simple docstring'''

       if self.sql is None:
            raise ValueError('sql must be specified'		)
       if self.con is None:
            raise ValueError('con must be specified'		)


  def _UpperCamelCase	(					self ,						snake_case_ ,						snake_case_ = None ,						):




       '''simple docstring'''

       UpperCAmelCase_				:  List[Any]  = config_kwargs.copy()
       # We need to stringify the Selectable object to make its hash deterministic

       # The process of stringifying is explained here: http://docs.sqlalchemy.org/en/latest/faq/sqlexpressions.html
       UpperCAmelCase_				:  str  = config_kwargs['sql']
       if not isinstance(snake_case_ ,						snake_case_		):
            if datasets.config.SQLALCHEMY_AVAILABLE and "sqlalchemy" in sys.modules:
                 import sqlalchemy

                 if isinstance(snake_case_ ,						sqlalchemy.sql.Selectable		):
                      UpperCAmelCase_				:  Any  = sqlalchemy.create_engine(config_kwargs['con'].split('://'		)[0] + '://'		)
                      UpperCAmelCase_				:  int  = str(sql.compile(dialect=engine.dialect		)		)
                      UpperCAmelCase_				:  str  = sql_str
                 else:
                      raise TypeError(
                          F'''Supported types for \'sql\' are string and sqlalchemy.sql.Selectable but got {type(snake_case_		)}: {sql}'''		)
            else:
                 raise TypeError(
                     F'''Supported types for \'sql\' are string and sqlalchemy.sql.Selectable but got {type(snake_case_		)}: {sql}'''		)
       UpperCAmelCase_				:  Union[str, Any]  = config_kwargs['con']
       if not isinstance(snake_case_ ,						snake_case_		):
            UpperCAmelCase_				:  Optional[Any]  = id(snake_case_		)
            logger.info(
                F'''SQL connection \'con\' of type {type(snake_case_		)} couldn\'t be hashed properly. To enable hashing, specify \'con\' as URI string instead.'''		)

       return super().create_config_id(snake_case_ ,						custom_features=snake_case_		)






  @property
  def _UpperCamelCase	(					self		):




       '''simple docstring'''

       UpperCAmelCase_				:  List[Any]  = {
           'index_col': self.index_col,
           'columns': self.columns,
           'params': self.params,
           'coerce_float': self.coerce_float,
           'parse_dates': self.parse_dates,
       }
       return pd_read_sql_kwargs







class 	__SCREAMING_SNAKE_CASE		(			datasets.ArrowBasedBuilder			):







  '''simple docstring'''






  lowerCamelCase_						:Any		       =						SqlConfig


  def _UpperCamelCase	(					self		):




       '''simple docstring'''

       return datasets.DatasetInfo(features=self.config.features		)


  def _UpperCamelCase	(					self ,						snake_case_		):




       '''simple docstring'''

       return [datasets.SplitGenerator(name=datasets.Split.TRAIN ,						gen_kwargs={}		)]


  def _UpperCamelCase	(					self ,						snake_case_		):




       '''simple docstring'''

       if self.config.features is not None:
            UpperCAmelCase_				:  Tuple  = self.config.features.arrow_schema
            if all(not require_storage_cast(snake_case_		) for feature in self.config.features.values()		):
                 # cheaper cast
                 UpperCAmelCase_				:  Tuple  = pa.Table.from_arrays([pa_table[field.name] for field in schema] ,						schema=snake_case_		)
            else:
                 # more expensive cast; allows str <-> int/float or str to Audio for example
                 UpperCAmelCase_				:  Union[str, Any]  = table_cast(snake_case_ ,						snake_case_		)
       return pa_table






  def _UpperCamelCase	(					self		):




       '''simple docstring'''

       UpperCAmelCase_				:  Optional[Any]  = self.config.chunksize
       UpperCAmelCase_				:  Optional[Any]  = pd.read_sql(
           self.config.sql ,						self.config.con ,						chunksize=snake_case_ ,						**self.config.pd_read_sql_kwargs		)
       UpperCAmelCase_				:  int  = [sql_reader] if chunksize is None else sql_reader
       for chunk_idx, df in enumerate(snake_case_		):
            UpperCAmelCase_				:  Optional[Any]  = pa.Table.from_pandas(snake_case_		)
            yield chunk_idx, self._cast_table(snake_case_		)






