
"""simple docstring"""



import json
import os
from pathlib import Path

import pytest

from datasets.download.download_config import DownloadConfig
from datasets.download.download_manager import DownloadManager
from datasets.utils.file_utils import hash_url_to_filename


UpperCAmelCase__          = 'http://www.mocksite.com/file1.txt'
UpperCAmelCase__          = '"text": ["foo", "foo"]'
UpperCAmelCase__          = '6d8ce9aa78a471c7477201efbeabd3bb01ac2e7d100a6dc024ba1608361f90a8'

class       lowerCAmelCase__				:
     __a						=					200
     __a						=					{"""Content-Length""": """100"""}
     __a						=					{}







     def      lowercase	(							self			:			List[str]    ,      **_lowerCamelCase			:			List[str]			):
       return [bytes(_lowerCamelCase    ,      '''utf-8'''			)]






def 					_UpperCAmelCase      ( *__lowerCamelCase   :       List[str] ,					**__lowerCamelCase   :       Dict		)     ->					Dict:
  return MockResponse()
@pytest.mark.parametrize('''urls_type''' ,					[str, list, dict]		)
def 					_UpperCAmelCase      ( __lowerCamelCase   :       Union[str, Any] ,					__lowerCamelCase   :       List[str] ,					__lowerCamelCase   :       str		)     ->					int:
  import requests

  monkeypatch.setattr(__lowerCamelCase ,					'''request''' ,					__lowerCamelCase		)

  _snake_case					     =       URL
  if issubclass(__lowerCamelCase ,					__lowerCamelCase		):
    _snake_case					     =       url
  elif issubclass(__lowerCamelCase ,					__lowerCamelCase		):
    _snake_case					     =       [url]
  elif issubclass(__lowerCamelCase ,					__lowerCamelCase		):
    _snake_case					     =       {'''train''': url}
  _snake_case					     =       '''dummy'''
  _snake_case					     =       '''downloads'''
  _snake_case					     =       tmp_path
  _snake_case					     =       DownloadConfig(
      cache_dir=os.path.join(__lowerCamelCase ,					__lowerCamelCase		) ,					use_etag=__lowerCamelCase ,					)
  _snake_case					     =       DownloadManager(dataset_name=__lowerCamelCase ,					download_config=__lowerCamelCase		)
  _snake_case					     =       dl_manager.download(__lowerCamelCase		)
  _snake_case					     =       urls
  for downloaded_paths in [downloaded_paths]:
    if isinstance(__lowerCamelCase ,					__lowerCamelCase		):
      _snake_case					     =       [downloaded_paths]
      _snake_case					     =       [urls]
    elif isinstance(__lowerCamelCase ,					__lowerCamelCase		):
      assert "train" in downloaded_paths.keys()
      _snake_case					     =       downloaded_paths.values()
      _snake_case					     =       urls.values()
    assert downloaded_paths
    for downloaded_path, input_url in zip(__lowerCamelCase ,					__lowerCamelCase		):
      assert downloaded_path == dl_manager.downloaded_paths[input_url]
      _snake_case					     =       Path(__lowerCamelCase		)
      _snake_case					     =       downloaded_path.parts
      assert parts[-1] == HASH
      assert parts[-2] == cache_subdir
      assert downloaded_path.exists()
      _snake_case					     =       downloaded_path.read_text()
      assert content == CONTENT
      _snake_case					     =       downloaded_path.with_suffix('''.json'''		)
      assert metadata_downloaded_path.exists()
      _snake_case					     =       json.loads(metadata_downloaded_path.read_text()		)
      assert metadata_content == {"url": URL, "etag": None}
@pytest.mark.parametrize('''paths_type''' ,					[str, list, dict]		)
def 					_UpperCAmelCase      ( __lowerCamelCase   :       int ,					__lowerCamelCase   :       str ,					__lowerCamelCase   :       Optional[int]		)     ->					int:
  _snake_case					     =       str(__lowerCamelCase		)
  if issubclass(__lowerCamelCase ,					__lowerCamelCase		):
    _snake_case					     =       filename
  elif issubclass(__lowerCamelCase ,					__lowerCamelCase		):
    _snake_case					     =       [filename]
  elif issubclass(__lowerCamelCase ,					__lowerCamelCase		):
    _snake_case					     =       {'''train''': filename}
  _snake_case					     =       '''dummy'''
  _snake_case					     =       xz_file.parent
  _snake_case					     =       '''extracted'''
  _snake_case					     =       DownloadConfig(
      cache_dir=__lowerCamelCase ,					use_etag=__lowerCamelCase ,					)
  _snake_case					     =       DownloadManager(dataset_name=__lowerCamelCase ,					download_config=__lowerCamelCase		)
  _snake_case					     =       dl_manager.extract(__lowerCamelCase		)
  _snake_case					     =       paths
  for extracted_paths in [extracted_paths]:
    if isinstance(__lowerCamelCase ,					__lowerCamelCase		):
      _snake_case					     =       [extracted_paths]
      _snake_case					     =       [paths]
    elif isinstance(__lowerCamelCase ,					__lowerCamelCase		):
      assert "train" in extracted_paths.keys()
      _snake_case					     =       extracted_paths.values()
      _snake_case					     =       paths.values()
    assert extracted_paths
    for extracted_path, input_path in zip(__lowerCamelCase ,					__lowerCamelCase		):
      assert extracted_path == dl_manager.extracted_paths[input_path]
      _snake_case					     =       Path(__lowerCamelCase		)
      _snake_case					     =       extracted_path.parts
      assert parts[-1] == hash_url_to_filename(__lowerCamelCase ,					etag=__lowerCamelCase		)
      assert parts[-2] == extracted_subdir
      assert extracted_path.exists()
      _snake_case					     =       extracted_path.read_text()
      _snake_case					     =       text_file.read_text()
      assert extracted_file_content == expected_file_content
def 					_UpperCAmelCase      ( __lowerCamelCase   :       Tuple ,					__lowerCamelCase   :       List[Any]		)     ->					Dict:
  assert path.endswith('''.jsonl'''		)
  for num_items, line in enumerate(__lowerCamelCase ,					start=1		):
    _snake_case					     =       json.loads(line.decode('''utf-8'''		)		)
    assert item.keys() == {"col_1", "col_2", "col_3"}
  assert num_items == 4
@pytest.mark.parametrize('''archive_jsonl''' ,					['''tar_jsonl_path''', '''zip_jsonl_path''']		)
def 					_UpperCAmelCase      ( __lowerCamelCase   :       Dict ,					__lowerCamelCase   :       str		)     ->					Dict:
  _snake_case					     =       request.getfixturevalue(__lowerCamelCase		)
  _snake_case					     =       DownloadManager()
  for num_jsonl, (path, file) in enumerate(dl_manager.iter_archive(__lowerCamelCase		) ,					start=1		):
    _test_jsonl(__lowerCamelCase ,					__lowerCamelCase		)
  assert num_jsonl == 2
@pytest.mark.parametrize('''archive_nested_jsonl''' ,					['''tar_nested_jsonl_path''', '''zip_nested_jsonl_path''']		)
def 					_UpperCAmelCase      ( __lowerCamelCase   :       str ,					__lowerCamelCase   :       List[Any]		)     ->					Tuple:
  _snake_case					     =       request.getfixturevalue(__lowerCamelCase		)
  _snake_case					     =       DownloadManager()
  for num_tar, (path, file) in enumerate(dl_manager.iter_archive(__lowerCamelCase		) ,					start=1		):
    for num_jsonl, (subpath, subfile) in enumerate(dl_manager.iter_archive(__lowerCamelCase		) ,					start=1		):
      _test_jsonl(__lowerCamelCase ,					__lowerCamelCase		)
  assert num_tar == 1
  assert num_jsonl == 2

def 					_UpperCAmelCase      ( __lowerCamelCase   :       Tuple		)     ->					List[Any]:
  _snake_case					     =       DownloadManager()
  for num_file, file in enumerate(dl_manager.iter_files(__lowerCamelCase		) ,					start=1		):
    assert os.path.basename(__lowerCamelCase		) == ("test.txt" if num_file == 1 else "train.txt")
  assert num_file == 2





"""simple docstring"""



from __future__ import annotations

import inspect
import unittest

import numpy as np

from transformers import ResNetConfig
from transformers.testing_utils import require_tf, require_vision, slow
from transformers.utils import cached_property, is_tf_available, is_vision_available

from ...test_configuration_common import ConfigTester
from ...test_modeling_tf_common import TFModelTesterMixin, floats_tensor, ids_tensor
from ...test_pipeline_mixin import PipelineTesterMixin


if is_tf_available():
 import tensorflow as tf

 from transformers import TFResNetForImageClassification, TFResNetModel
 from transformers.models.resnet.modeling_tf_resnet import TF_RESNET_PRETRAINED_MODEL_ARCHIVE_LIST


if is_vision_available():
 from PIL import Image

 from transformers import AutoImageProcessor

class       lowerCAmelCase__				:







     def __init__(							self			:			Dict    ,      _lowerCamelCase			:			int    ,      _lowerCamelCase			:			Optional[int]=3    ,      _lowerCamelCase			:			List[str]=32    ,      _lowerCamelCase			:			Optional[int]=3    ,      _lowerCamelCase			:			Dict=10    ,      _lowerCamelCase			:			Tuple=[10, 20, 30, 40]    ,      _lowerCamelCase			:			int=[1, 1, 2, 1]    ,      _lowerCamelCase			:			int=True    ,      _lowerCamelCase			:			Optional[int]=True    ,      _lowerCamelCase			:			Optional[int]="relu"    ,      _lowerCamelCase			:			List[Any]=3    ,      _lowerCamelCase			:			Dict=None    ,      ):
       _snake_case					     =       parent
       _snake_case					     =       batch_size
       _snake_case					     =       image_size
       _snake_case					     =       num_channels
       _snake_case					     =       embeddings_size
       _snake_case					     =       hidden_sizes
       _snake_case					     =       depths
       _snake_case					     =       is_training
       _snake_case					     =       use_labels
       _snake_case					     =       hidden_act
       _snake_case					     =       num_labels
       _snake_case					     =       scope
       _snake_case					     =       len(_lowerCamelCase			)







     def      lowercase	(							self			:			Optional[int]			):
       _snake_case					     =       floats_tensor([self.batch_size, self.num_channels, self.image_size, self.image_size]			)

       _snake_case					     =       None
       if self.use_labels:
         _snake_case					     =       ids_tensor([self.batch_size]    ,      self.num_labels			)

       _snake_case					     =       self.get_config()

       return config, pixel_values, labels







     def      lowercase	(							self			:			Tuple			):
       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    ,      image_size=self.image_size    ,      )







     def      lowercase	(							self			:			List[Any]    ,      _lowerCamelCase			:			List[str]    ,      _lowerCamelCase			:			str    ,      _lowerCamelCase			:			List[Any]			):
       _snake_case					     =       TFResNetModel(config=_lowerCamelCase			)
       _snake_case					     =       model(_lowerCamelCase			)
       # 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 // 32, self.image_size // 32)    ,      )







     def      lowercase	(							self			:			Dict    ,      _lowerCamelCase			:			str    ,      _lowerCamelCase			:			Optional[Any]    ,      _lowerCamelCase			:			Tuple			):
       _snake_case					     =       self.num_labels
       _snake_case					     =       TFResNetForImageClassification(_lowerCamelCase			)
       _snake_case					     =       model(_lowerCamelCase    ,      labels=_lowerCamelCase			)
       self.parent.assertEqual(result.logits.shape    ,      (self.batch_size, self.num_labels)			)







     def      lowercase	(							self			:			Tuple			):
       _snake_case					     =       self.prepare_config_and_inputs()
       _snake_case     ,					_snake_case     ,					_snake_case					     =       config_and_inputs
       _snake_case					     =       {'''pixel_values''': pixel_values}
       return config, inputs_dict






@require_tf
class       lowerCAmelCase__				(						A_ ,	A_ ,	unittest.TestCase	):
     __a						=					(TFResNetModel, TFResNetForImageClassification) if is_tf_available() else ()
     __a						=					(
         {"""feature-extraction""": TFResNetModel, """image-classification""": TFResNetForImageClassification}
         if is_tf_available()
         else {}
     )

     __a						=					False
     __a						=					False
     __a						=					False
     __a						=					False
     __a						=					False







     def      lowercase	(							self			:			List[Any]			):
       _snake_case					     =       TFResNetModelTester(self			)
       _snake_case					     =       ConfigTester(self    ,      config_class=_lowerCamelCase    ,      has_text_modality=_lowerCamelCase			)







     def      lowercase	(							self			:			Tuple			):
       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      lowercase	(							self			:			List[Any]			):
       return







     @unittest.skip(reason='''ResNet does not use inputs_embeds'''			)
     def      lowercase	(							self			:			Any			):
       pass







     @unittest.skip(reason='''ResNet does not support input and output embeddings'''			)
     def      lowercase	(							self			:			List[str]			):
       pass







     def      lowercase	(							self			:			int			):
       _snake_case     ,					_snake_case					     =       self.model_tester.prepare_config_and_inputs_for_common()

       for model_class in self.all_model_classes:
         _snake_case					     =       model_class(_lowerCamelCase			)
         _snake_case					     =       inspect.signature(model.call			)
         # signature.parameters is an OrderedDict => so arg_names order is deterministic
         _snake_case					     =       [*signature.parameters.keys()]

         _snake_case					     =       ['''pixel_values''']
         self.assertListEqual(arg_names[:1]    ,      _lowerCamelCase			)







     def      lowercase	(							self			:			List[str]			):
       _snake_case					     =       self.model_tester.prepare_config_and_inputs()
       self.model_tester.create_and_check_model(*_lowerCamelCase			)







     def      lowercase	(							self			:			Union[str, Any]			):
       def check_hidden_states_output(_lowerCamelCase			:			int    ,      _lowerCamelCase			:			List[Any]    ,      _lowerCamelCase			:			str			):
         _snake_case					     =       model_class(_lowerCamelCase			)
         _snake_case					     =       model(**self._prepare_for_class(_lowerCamelCase    ,      _lowerCamelCase			)			)

         _snake_case					     =       outputs.encoder_hidden_states if config.is_encoder_decoder else outputs.hidden_states

         _snake_case					     =       self.model_tester.num_stages
         self.assertEqual(len(_lowerCamelCase			)    ,      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]    ,      )

       _snake_case     ,					_snake_case					     =       self.model_tester.prepare_config_and_inputs_for_common()
       _snake_case					     =       ['''basic''', '''bottleneck''']
       for model_class in self.all_model_classes:
         for layer_type in layers_type:
           _snake_case					     =       layer_type
           _snake_case					     =       True
           check_hidden_states_output(_lowerCamelCase    ,      _lowerCamelCase    ,      _lowerCamelCase			)

           # check that output_hidden_states also work using config
           del inputs_dict["output_hidden_states"]
           _snake_case					     =       True

           check_hidden_states_output(_lowerCamelCase    ,      _lowerCamelCase    ,      _lowerCamelCase			)







     def      lowercase	(							self			:			Union[str, Any]			):
       _snake_case					     =       self.model_tester.prepare_config_and_inputs()
       self.model_tester.create_and_check_for_image_classification(*_lowerCamelCase			)







     @slow
     def      lowercase	(							self			:			List[str]			):
       for model_name in TF_RESNET_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
         _snake_case					     =       TFResNetModel.from_pretrained(_lowerCamelCase			)
         self.assertIsNotNone(_lowerCamelCase			)






def 					_UpperCAmelCase      ( )     ->					Union[str, Any]:
  _snake_case					     =       Image.open('''./tests/fixtures/tests_samples/COCO/000000039769.png'''		)
  return image

@require_tf
@require_vision
class       lowerCAmelCase__				(						unittest.TestCase	):







     @cached_property
     def      lowercase	(							self			:			Dict			):
       return (
           AutoImageProcessor.from_pretrained(TF_RESNET_PRETRAINED_MODEL_ARCHIVE_LIST[0]			)
           if is_vision_available()
           else None
       )







     @slow
     def      lowercase	(							self			:			List[Any]			):
       _snake_case					     =       TFResNetForImageClassification.from_pretrained(TF_RESNET_PRETRAINED_MODEL_ARCHIVE_LIST[0]			)

       _snake_case					     =       self.default_image_processor
       _snake_case					     =       prepare_img()
       _snake_case					     =       image_processor(images=_lowerCamelCase    ,      return_tensors='''tf'''			)

       # forward pass
       _snake_case					     =       model(**_lowerCamelCase			)

       # verify the logits
       _snake_case					     =       tf.TensorShape((1, 1000)			)
       self.assertEqual(outputs.logits.shape    ,      _lowerCamelCase			)

       _snake_case					     =       tf.constant([-1_1.1_0_6_9, -9.7_8_7_7, -8.3_7_7_7]			)

       self.assertTrue(np.allclose(outputs.logits[0, :3].numpy()    ,      _lowerCamelCase    ,      atol=1e-4			)			)



