"""simple docstring"""


import subprocess
import sys

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


class 				a (						_SCREAMING_SNAKE_CASE      ):


    @require_torch
    def    lowerCAmelCase_     (    self		:     List[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         =					"""
from transformers import BertConfig, BertModel, BertTokenizer, pipeline
        """

      _UpperCAmelCase         =					"""
mname = \"hf-internal-testing/tiny-random-bert\"
BertConfig.from_pretrained(mname)
BertModel.from_pretrained(mname)
BertTokenizer.from_pretrained(mname)
pipe = pipeline(task=\"fill-mask\", model=mname)
print(\"success\")
        """

      _UpperCAmelCase         =					"""
import socket
def offline_socket(*args, **kwargs): raise RuntimeError(\"Offline mode is enabled, we shouldn't access internet\")
socket.socket = offline_socket
        """

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

      # 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(__lowerCAmelCase      , env=__lowerCAmelCase      , check=__lowerCAmelCase      , capture_output=__lowerCAmelCase    )
      self.assertEqual(result.returncode      , 0      , result.stderr    )
      self.assertIn("""success"""      , result.stdout.decode()    )


    @require_torch
    def    lowerCAmelCase_     (    self		:     Dict    ):
      # python one-liner segments
      # this must be loaded before socket.socket is monkey-patched
      _UpperCAmelCase         =					"""
from transformers import BertConfig, BertModel, BertTokenizer, pipeline
        """

      _UpperCAmelCase         =					"""
mname = \"hf-internal-testing/tiny-random-bert\"
BertConfig.from_pretrained(mname)
BertModel.from_pretrained(mname)
BertTokenizer.from_pretrained(mname)
pipe = pipeline(task=\"fill-mask\", model=mname)
print(\"success\")
        """

      _UpperCAmelCase         =					"""
import socket
def offline_socket(*args, **kwargs): raise socket.error(\"Faking flaky internet\")
socket.socket = offline_socket
        """

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

      # 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(__lowerCAmelCase      , env=__lowerCAmelCase      , check=__lowerCAmelCase      , capture_output=__lowerCAmelCase    )
      self.assertEqual(result.returncode      , 0      , result.stderr    )
      self.assertIn("""success"""      , result.stdout.decode()    )


    @require_torch
    def    lowerCAmelCase_     (    self		:     Dict    ):
      # 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         =					"""
from transformers import BertConfig, BertModel, BertTokenizer
        """

      _UpperCAmelCase         =					"""
mname = \"hf-internal-testing/tiny-random-bert-sharded\"
BertConfig.from_pretrained(mname)
BertModel.from_pretrained(mname)
print(\"success\")
        """

      _UpperCAmelCase         =					"""
import socket
def offline_socket(*args, **kwargs): raise ValueError(\"Offline mode is enabled\")
socket.socket = offline_socket
        """

      # 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(__lowerCAmelCase      , env=__lowerCAmelCase      , check=__lowerCAmelCase      , capture_output=__lowerCAmelCase    )
      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(__lowerCAmelCase      , env=__lowerCAmelCase      , check=__lowerCAmelCase      , capture_output=__lowerCAmelCase    )
      self.assertEqual(result.returncode      , 0      , result.stderr    )
      self.assertIn("""success"""      , result.stdout.decode()    )


    @require_torch
    def    lowerCAmelCase_     (    self		:     Any    ):
      _UpperCAmelCase         =					"""
from transformers import pipeline
        """
      _UpperCAmelCase         =					"""
mname = \"hf-internal-testing/tiny-random-bert\"
pipe = pipeline(model=mname)
        """

      _UpperCAmelCase         =					"""
import socket
def offline_socket(*args, **kwargs): raise socket.error(\"Offline mode is enabled\")
socket.socket = offline_socket
        """
      _UpperCAmelCase         =					self.get_env()
      _UpperCAmelCase         =					"""1"""
      _UpperCAmelCase         =					[sys.executable, """-c""", """\n""".join([load, mock, run]    )]
      _UpperCAmelCase         =					subprocess.run(__lowerCAmelCase      , env=__lowerCAmelCase      , check=__lowerCAmelCase      , capture_output=__lowerCAmelCase    )
      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    lowerCAmelCase_     (    self		:     List[str]    ):
      _UpperCAmelCase         =					"""
from transformers import AutoModel
        """
      _UpperCAmelCase         =					"""
mname = \"hf-internal-testing/test_dynamic_model\"
AutoModel.from_pretrained(mname, trust_remote_code=True)
print(\"success\")
        """

      # 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(__lowerCAmelCase      , env=__lowerCAmelCase      , check=__lowerCAmelCase      , capture_output=__lowerCAmelCase    )
      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(__lowerCAmelCase      , env=__lowerCAmelCase      , check=__lowerCAmelCase      , capture_output=__lowerCAmelCase    )
      self.assertEqual(result.returncode      , 0      , result.stderr    )
      self.assertIn("""success"""      , result.stdout.decode()    )




'''simple docstring'''






# Copyright 2023 The HuggingFace Team. All rights reserved.
#
# 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.
from typing import TYPE_CHECKING

from ...utils import OptionalDependencyNotAvailable, _LazyModule, is_torch_available


__A					:  Dict											=      {"configuration_timm_backbone": ["TimmBackboneConfig"]}


try:
  if not is_torch_available():
    raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
  pass
else:
  __A					:  str											=      ["TimmBackbone"]


if TYPE_CHECKING:
  from .configuration_timm_backbone import TimmBackboneConfig

  try:
    if not is_torch_available():
      raise OptionalDependencyNotAvailable()
  except OptionalDependencyNotAvailable:
    pass
  else:
    from .modeling_timm_backbone import TimmBackbone

else:
  import sys

  __A					:  Dict											=      _LazyModule(__name__, globals()["__file__"], _import_structure, module_spec=__spec__)



