


import subprocess
import sys

from transformers import BertConfig, BertModel, BertTokenizer, pipeline
from transformers.testing_utils import TestCasePlus, require_torch






class    UpperCAmelCase__	( A_		):






    @require_torch
    def _a (      self   )  ->	str:
         # this test is a bit tricky since TRANSFORMERS_OFFLINE can only be changed before
         # `transformers` is loaded, and it's too late for inside pytest - so we are changing it
         # while running an external program

         # python one-liner segments

         # this must be loaded before socket.socket is monkey-patched
         __UpperCamelCase   							='\nfrom transformers import BertConfig, BertModel, BertTokenizer, pipeline\n        '

         __UpperCamelCase   							='\nmname = "hf-internal-testing/tiny-random-bert"\nBertConfig.from_pretrained(mname)\nBertModel.from_pretrained(mname)\nBertTokenizer.from_pretrained(mname)\npipe = pipeline(task="fill-mask", model=mname)\nprint("success")\n        '

         __UpperCamelCase   							='\nimport socket\ndef offline_socket(*args, **kwargs): raise RuntimeError("Offline mode is enabled, we shouldn\'t access internet")\nsocket.socket = offline_socket\n        '

         # Force fetching the files so that we can use the cache
         __UpperCamelCase   							='hf-internal-testing/tiny-random-bert'
         BertConfig.from_pretrained(A_   )
         BertModel.from_pretrained(A_   )
         BertTokenizer.from_pretrained(A_   )
         pipeline(task='fill-mask' ,       model=A_   )

         # baseline - just load from_pretrained with normal network
         __UpperCamelCase   							=[sys.executable, '-c', '\n'.join([load, run, mock]   )]

         # should succeed
         __UpperCamelCase   							=self.get_env()
         # should succeed as TRANSFORMERS_OFFLINE=1 tells it to use local files
         __UpperCamelCase   							='1'
         __UpperCamelCase   							=subprocess.run(A_ ,       env=A_ ,       check=A_ ,       capture_output=A_   )
         self.assertEqual(result.returncode ,       0 ,       result.stderr   )
         self.assertIn('success' ,       result.stdout.decode()   )






    @require_torch
    def _a (      self   )  ->	List[str]:
         # python one-liner segments
         # this must be loaded before socket.socket is monkey-patched
         __UpperCamelCase   							='\nfrom transformers import BertConfig, BertModel, BertTokenizer, pipeline\n        '

         __UpperCamelCase   							='\nmname = "hf-internal-testing/tiny-random-bert"\nBertConfig.from_pretrained(mname)\nBertModel.from_pretrained(mname)\nBertTokenizer.from_pretrained(mname)\npipe = pipeline(task="fill-mask", model=mname)\nprint("success")\n        '

         __UpperCamelCase   							='\nimport socket\ndef offline_socket(*args, **kwargs): raise socket.error("Faking flaky internet")\nsocket.socket = offline_socket\n        '

         # Force fetching the files so that we can use the cache
         __UpperCamelCase   							='hf-internal-testing/tiny-random-bert'
         BertConfig.from_pretrained(A_   )
         BertModel.from_pretrained(A_   )
         BertTokenizer.from_pretrained(A_   )
         pipeline(task='fill-mask' ,       model=A_   )

         # baseline - just load from_pretrained with normal network
         __UpperCamelCase   							=[sys.executable, '-c', '\n'.join([load, run, mock]   )]

         # should succeed
         __UpperCamelCase   							=self.get_env()
         __UpperCamelCase   							=subprocess.run(A_ ,       env=A_ ,       check=A_ ,       capture_output=A_   )
         self.assertEqual(result.returncode ,       0 ,       result.stderr   )
         self.assertIn('success' ,       result.stdout.decode()   )






    @require_torch
    def _a (      self   )  ->	int:
         # this test is a bit tricky since TRANSFORMERS_OFFLINE can only be changed before
         # `transformers` is loaded, and it's too late for inside pytest - so we are changing it
         # while running an external program

         # python one-liner segments

         # this must be loaded before socket.socket is monkey-patched
         __UpperCamelCase   							='\nfrom transformers import BertConfig, BertModel, BertTokenizer\n        '

         __UpperCamelCase   							='\nmname = "hf-internal-testing/tiny-random-bert-sharded"\nBertConfig.from_pretrained(mname)\nBertModel.from_pretrained(mname)\nprint("success")\n        '

         __UpperCamelCase   							='\nimport socket\ndef offline_socket(*args, **kwargs): raise ValueError("Offline mode is enabled")\nsocket.socket = offline_socket\n        '

         # baseline - just load from_pretrained with normal network
         __UpperCamelCase   							=[sys.executable, '-c', '\n'.join([load, run]   )]

         # should succeed
         __UpperCamelCase   							=self.get_env()
         __UpperCamelCase   							=subprocess.run(A_ ,       env=A_ ,       check=A_ ,       capture_output=A_   )
         self.assertEqual(result.returncode ,       0 ,       result.stderr   )
         self.assertIn('success' ,       result.stdout.decode()   )

         # next emulate no network
         __UpperCamelCase   							=[sys.executable, '-c', '\n'.join([load, mock, run]   )]

         # Doesn't fail anymore since the model is in the cache due to other tests, so commenting this.
         # env["TRANSFORMERS_OFFLINE"] = "0"
         # result = subprocess.run(cmd, env=env, check=False, capture_output=True)
         # self.assertEqual(result.returncode, 1, result.stderr)

         # should succeed as TRANSFORMERS_OFFLINE=1 tells it to use local files
         __UpperCamelCase   							='1'
         __UpperCamelCase   							=subprocess.run(A_ ,       env=A_ ,       check=A_ ,       capture_output=A_   )
         self.assertEqual(result.returncode ,       0 ,       result.stderr   )
         self.assertIn('success' ,       result.stdout.decode()   )






    @require_torch
    def _a (      self   )  ->	Union[str, Any]:
         __UpperCamelCase   							='\nfrom transformers import pipeline\n        '
         __UpperCamelCase   							='\nmname = "hf-internal-testing/tiny-random-bert"\npipe = pipeline(model=mname)\n        '

         __UpperCamelCase   							='\nimport socket\ndef offline_socket(*args, **kwargs): raise socket.error("Offline mode is enabled")\nsocket.socket = offline_socket\n        '
         __UpperCamelCase   							=self.get_env()
         __UpperCamelCase   							='1'
         __UpperCamelCase   							=[sys.executable, '-c', '\n'.join([load, mock, run]   )]
         __UpperCamelCase   							=subprocess.run(A_ ,       env=A_ ,       check=A_ ,       capture_output=A_   )
         self.assertEqual(result.returncode ,       1 ,       result.stderr   )
         self.assertIn(
             'You cannot infer task automatically within `pipeline` when using offline mode' ,       result.stderr.decode().replace('\n' ,       ''   ) ,       )






    @require_torch
    def _a (      self   )  ->	Any:
         __UpperCamelCase   							='\nfrom transformers import AutoModel\n        '
         __UpperCamelCase   							='\nmname = "hf-internal-testing/test_dynamic_model"\nAutoModel.from_pretrained(mname, trust_remote_code=True)\nprint("success")\n        '

         # baseline - just load from_pretrained with normal network
         __UpperCamelCase   							=[sys.executable, '-c', '\n'.join([load, run]   )]

         # should succeed
         __UpperCamelCase   							=self.get_env()
         __UpperCamelCase   							=subprocess.run(A_ ,       env=A_ ,       check=A_ ,       capture_output=A_   )
         self.assertEqual(result.returncode ,       0 ,       result.stderr   )
         self.assertIn('success' ,       result.stdout.decode()   )

         # should succeed as TRANSFORMERS_OFFLINE=1 tells it to use local files
         __UpperCamelCase   							='1'
         __UpperCamelCase   							=subprocess.run(A_ ,       env=A_ ,       check=A_ ,       capture_output=A_   )
         self.assertEqual(result.returncode ,       0 ,       result.stderr   )
         self.assertIn('success' ,       result.stdout.decode()   )









from typing import TYPE_CHECKING

from ...utils import (
    OptionalDependencyNotAvailable,
    _LazyModule,
    is_flax_available,
    is_tf_available,
    is_torch_available,
    is_vision_available,
)


_A			=						{'configuration_vit': ['VIT_PRETRAINED_CONFIG_ARCHIVE_MAP', 'ViTConfig', 'ViTOnnxConfig']}

try:
   if not is_vision_available():
      raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
   pass
else:
   _A			=						['ViTFeatureExtractor']
   _A			=						['ViTImageProcessor']

try:
   if not is_torch_available():
      raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
   pass
else:
   _A			=						[
       'VIT_PRETRAINED_MODEL_ARCHIVE_LIST',
       'ViTForImageClassification',
       'ViTForMaskedImageModeling',
       'ViTModel',
       'ViTPreTrainedModel',
   ]

try:
   if not is_tf_available():
      raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
   pass
else:
   _A			=						[
       'TFViTForImageClassification',
       'TFViTModel',
       'TFViTPreTrainedModel',
   ]

try:
   if not is_flax_available():
      raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
   pass
else:
   _A			=						[
       'FlaxViTForImageClassification',
       'FlaxViTModel',
       'FlaxViTPreTrainedModel',
   ]

if TYPE_CHECKING:
   from .configuration_vit import VIT_PRETRAINED_CONFIG_ARCHIVE_MAP, ViTConfig, ViTOnnxConfig

   try:
      if not is_vision_available():
         raise OptionalDependencyNotAvailable()
   except OptionalDependencyNotAvailable:
      pass
   else:
      from .feature_extraction_vit import ViTFeatureExtractor
      from .image_processing_vit import ViTImageProcessor

   try:
      if not is_torch_available():
         raise OptionalDependencyNotAvailable()
   except OptionalDependencyNotAvailable:
      pass
   else:
      from .modeling_vit import (
          VIT_PRETRAINED_MODEL_ARCHIVE_LIST,
          ViTForImageClassification,
          ViTForMaskedImageModeling,
          ViTModel,
          ViTPreTrainedModel,
      )

   try:
      if not is_tf_available():
         raise OptionalDependencyNotAvailable()
   except OptionalDependencyNotAvailable:
      pass
   else:
      from .modeling_tf_vit import TFViTForImageClassification, TFViTModel, TFViTPreTrainedModel

   try:
      if not is_flax_available():
         raise OptionalDependencyNotAvailable()
   except OptionalDependencyNotAvailable:
      pass
   else:
      from .modeling_flax_vit import FlaxViTForImageClassification, FlaxViTModel, FlaxViTPreTrainedModel


else:
   import sys

   _A			=						_LazyModule(__name__, globals()['__file__'], _import_structure, module_spec=__spec__)





