
import os
import shutil
import unittest
from unittest.mock import patch

from transformers.testing_utils import CaptureStd, is_pt_tf_cross_test, require_torch





class 							A__		(     unittest.TestCase):
      @patch("""sys.argv"""   ,  ["""fakeprogrampath""", """env"""]				)
      def 						UpperCamelCase__							(				self				):
       # test transformers-cli env
       import transformers.commands.transformers_cli

       with CaptureStd() as cs:
        transformers.commands.transformers_cli.main()
       self.assertIn("""Python version"""   ,  cs.out				)
       self.assertIn("""Platform"""   ,  cs.out				)
       self.assertIn("""Using distributed or parallel set-up in script?"""   ,  cs.out				)
      @is_pt_tf_cross_test
      @patch(
          """sys.argv"""   ,  ["""fakeprogrampath""", """pt-to-tf""", """--model-name""", """hf-internal-testing/tiny-random-gptj""", """--no-pr"""]				)
      def 						UpperCamelCase__							(				self				):
       import transformers.commands.transformers_cli

       shutil.rmtree("""/tmp/hf-internal-testing/tiny-random-gptj"""   ,  ignore_errors=__magic_name__				)  # cleans potential past runs
       transformers.commands.transformers_cli.main()

       # The original repo has no TF weights -- if they exist, they were created by the CLI
       self.assertTrue(os.path.exists("""/tmp/hf-internal-testing/tiny-random-gptj/tf_model.h5"""				)				)
      @require_torch
      @patch("""sys.argv"""   ,  ["""fakeprogrampath""", """download""", """hf-internal-testing/tiny-random-gptj""", """--cache-dir""", """/tmp"""]				)
      def 						UpperCamelCase__							(				self				):
       import transformers.commands.transformers_cli

       # # remove any previously downloaded model to start clean
       shutil.rmtree("""/tmp/models--hf-internal-testing--tiny-random-gptj"""   ,  ignore_errors=__magic_name__				)

       # run the command
       transformers.commands.transformers_cli.main()

       # check if the model files are downloaded correctly on /tmp/models--hf-internal-testing--tiny-random-gptj
       self.assertTrue(os.path.exists("""/tmp/models--hf-internal-testing--tiny-random-gptj/blobs"""				)				)
       self.assertTrue(os.path.exists("""/tmp/models--hf-internal-testing--tiny-random-gptj/refs"""				)				)
       self.assertTrue(os.path.exists("""/tmp/models--hf-internal-testing--tiny-random-gptj/snapshots"""				)				)






      @require_torch
      @patch(
          """sys.argv"""   ,  [
              """fakeprogrampath""",
              """download""",
              """hf-internal-testing/test_dynamic_model_with_tokenizer""",
              """--trust-remote-code""",
              """--cache-dir""",
              """/tmp""",
          ]   ,  )
      def 						UpperCamelCase__							(				self				):
       import transformers.commands.transformers_cli

       # # remove any previously downloaded model to start clean
       shutil.rmtree("""/tmp/models--hf-internal-testing--test_dynamic_model_with_tokenizer"""   ,  ignore_errors=__magic_name__				)

       # run the command
       transformers.commands.transformers_cli.main()

       # check if the model files are downloaded correctly on /tmp/models--hf-internal-testing--test_dynamic_model_with_tokenizer
       self.assertTrue(os.path.exists("""/tmp/models--hf-internal-testing--test_dynamic_model_with_tokenizer/blobs"""				)				)
       self.assertTrue(os.path.exists("""/tmp/models--hf-internal-testing--test_dynamic_model_with_tokenizer/refs"""				)				)
       self.assertTrue(
           os.path.exists("""/tmp/models--hf-internal-testing--test_dynamic_model_with_tokenizer/snapshots"""				)				)






# 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,
    is_vision_available,
)


_lowerCamelCase        ={
    """configuration_tvlt""": ["""TVLT_PRETRAINED_CONFIG_ARCHIVE_MAP""", """TvltConfig"""],
    """feature_extraction_tvlt""": ["""TvltFeatureExtractor"""],
    """processing_tvlt""": ["""TvltProcessor"""],
}

try:
      if not is_torch_available():
            raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
      pass
else:
      _lowerCamelCase        =[
          """TVLT_PRETRAINED_MODEL_ARCHIVE_LIST""",
          """TvltModel""",
          """TvltForPreTraining""",
          """TvltForAudioVisualClassification""",
          """TvltPreTrainedModel""",
      ]

try:
      if not is_vision_available():
            raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
      pass
else:
      _lowerCamelCase        =["""TvltImageProcessor"""]


if TYPE_CHECKING:
      from .configuration_tvlt import TVLT_PRETRAINED_CONFIG_ARCHIVE_MAP, TvltConfig
      from .processing_tvlt import TvltProcessor
      from .feature_extraction_tvlt import TvltFeatureExtractor

      try:
            if not is_torch_available():
                  raise OptionalDependencyNotAvailable()
      except OptionalDependencyNotAvailable:
            pass
      else:
            from .modeling_tvlt import (
                TVLT_PRETRAINED_MODEL_ARCHIVE_LIST,
                TvltForAudioVisualClassification,
                TvltForPreTraining,
                TvltModel,
                TvltPreTrainedModel,
            )

      try:
            if not is_vision_available():
                  raise OptionalDependencyNotAvailable()
      except OptionalDependencyNotAvailable:
            pass
      else:
            from .image_processing_tvlt import TvltImageProcessor


else:
      import sys

      _lowerCamelCase        =_LazyModule(__name__, globals()["""__file__"""], _import_structure, module_spec=__spec__)




