






"""simple docstring"""



import inspect
import unittest

import requests

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

from ...test_configuration_common import ConfigTester
from ...test_modeling_common import ModelTesterMixin, _config_zero_init, floats_tensor
from ...test_pipeline_mixin import PipelineTesterMixin


if is_torch_available():
    import torch
    from torch import nn

    from transformers import MgpstrForSceneTextRecognition


if is_vision_available():
    from PIL import Image

    from transformers import MgpstrProcessor

class 			a	:







    def __init__(     self				,						_lowerCamelCase				,						_lowerCamelCase=False				,						_lowerCamelCase=1_3				,						_lowerCamelCase=(3_2, 1_2_8)				,						_lowerCamelCase=4				,						_lowerCamelCase=3				,						_lowerCamelCase=2_7				,						_lowerCamelCase=3_8				,						_lowerCamelCase=9_9				,						_lowerCamelCase=9_9				,						_lowerCamelCase=3_2				,						_lowerCamelCase=5				,						_lowerCamelCase=4				,						_lowerCamelCase=4.0				,						_lowerCamelCase=2_5_7				,						_lowerCamelCase=None				,						):
      lowercase				       =			parent
      lowercase				       =			is_training
      lowercase				       =			batch_size
      lowercase				       =			image_size
      lowercase				       =			patch_size
      lowercase				       =			num_channels
      lowercase				       =			max_token_length
      lowercase				       =			num_character_labels
      lowercase				       =			num_bpe_labels
      lowercase				       =			num_wordpiece_labels
      lowercase				       =			hidden_size
      lowercase				       =			num_hidden_layers
      lowercase				       =			num_attention_heads
      lowercase				       =			mlp_ratio
      lowercase				       =			patch_embeds_hidden_size
      lowercase				       =			output_hidden_states







    def      UpperCamelCase_ (     self			):
      lowercase				       =			floats_tensor([self.batch_size, self.num_channels, self.image_size[0], self.image_size[1]]			)
      lowercase				       =			self.get_config()
      return config, pixel_values







    def      UpperCamelCase_ (     self			):
      return MgpstrConfig(
          image_size=self.image_size				,						patch_size=self.patch_size				,						num_channels=self.num_channels				,						max_token_length=self.max_token_length				,						num_character_labels=self.num_character_labels				,						num_bpe_labels=self.num_bpe_labels				,						num_wordpiece_labels=self.num_wordpiece_labels				,						hidden_size=self.hidden_size				,						num_hidden_layers=self.num_hidden_layers				,						num_attention_heads=self.num_attention_heads				,						mlp_ratio=self.mlp_ratio				,						output_hidden_states=self.output_hidden_states				,						)







    def      UpperCamelCase_ (     self				,						_lowerCamelCase				,						_lowerCamelCase			):
      lowercase				       =			MgpstrForSceneTextRecognition(_lowerCamelCase			)
      model.to(_lowerCamelCase			)
      model.eval()
      with torch.no_grad():
        lowercase				       =			model(_lowerCamelCase			)
      self.parent.assertEqual(
          generated_ids[0][0].shape				,						(self.batch_size, self.max_token_length, self.num_character_labels)			)







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


@require_torch
class 			a	(  a_,							a_,							unittest.TestCase      ):
    UpperCAmelCase_					:	Optional[int]      	=(MgpstrForSceneTextRecognition,) if is_torch_available() else ()
    UpperCAmelCase_					:	Optional[Any]      	={"feature-extraction": MgpstrForSceneTextRecognition} if is_torch_available() else {}
    UpperCAmelCase_					:	Union[str, Any]      	=False

    UpperCAmelCase_					:	Optional[Any]      	=False
    UpperCAmelCase_					:	Dict      	=False
    UpperCAmelCase_					:	str      	=False
    UpperCAmelCase_					:	str      	=False







    def      UpperCamelCase_ (     self			):
      lowercase				       =			MgpstrModelTester(self			)
      lowercase				       =			ConfigTester(self				,						config_class=_lowerCamelCase				,						has_text_modality=_lowerCamelCase			)







    def      UpperCamelCase_ (     self			):
      self.config_tester.run_common_tests()







    def      UpperCamelCase_ (     self			):
      lowercase				       =			self.model_tester.prepare_config_and_inputs()
      self.model_tester.create_and_check_model(*_lowerCamelCase			)







    @unittest.skip(reason='MgpstrModel does not use inputs_embeds'			)
    def      UpperCamelCase_ (     self			):
      pass







    def      UpperCamelCase_ (     self			):
      lowercase       ,	lowercase				       =			self.model_tester.prepare_config_and_inputs_for_common()

      for model_class in self.all_model_classes:
        lowercase				       =			model_class(_lowerCamelCase			)
        self.assertIsInstance(model.get_input_embeddings()				,						(nn.Module)			)
        lowercase				       =			model.get_output_embeddings()
        self.assertTrue(x is None or isinstance(_lowerCamelCase				,						nn.Linear			)			)







    def      UpperCamelCase_ (     self			):
      lowercase       ,	lowercase				       =			self.model_tester.prepare_config_and_inputs_for_common()

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

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







    @unittest.skip(reason='MgpstrModel does not support feedforward chunking'			)
    def      UpperCamelCase_ (     self			):
      pass







    def      UpperCamelCase_ (     self			):
      lowercase       ,	lowercase				       =			self.model_tester.prepare_config_and_inputs_for_common()

      for model_class in self.all_model_classes:
        if not model_class.supports_gradient_checkpointing:
          continue

        lowercase				       =			True
        lowercase				       =			model_class(_lowerCamelCase			)
        self.assertTrue(model.is_gradient_checkpointing			)







    def      UpperCamelCase_ (     self			):
      def check_hidden_states_output(_lowerCamelCase				,						_lowerCamelCase				,						_lowerCamelCase			):
        lowercase				       =			model_class(_lowerCamelCase			)
        model.to(_lowerCamelCase			)
        model.eval()

        with torch.no_grad():
          lowercase				       =			model(**self._prepare_for_class(_lowerCamelCase				,						_lowerCamelCase			)			)

        lowercase				       =			outputs.hidden_states

        lowercase				       =			getattr(
            self.model_tester				,						'expected_num_hidden_layers'				,						self.model_tester.num_hidden_layers + 1			)
        self.assertEqual(len(_lowerCamelCase			)				,						_lowerCamelCase			)

        self.assertListEqual(
            list(hidden_states[0].shape[-2:]			)				,						[self.model_tester.patch_embeds_hidden_size, self.model_tester.hidden_size]				,						)

      lowercase       ,	lowercase				       =			self.model_tester.prepare_config_and_inputs_for_common()

      for model_class in self.all_model_classes:
        lowercase				       =			True
        check_hidden_states_output(_lowerCamelCase				,						_lowerCamelCase				,						_lowerCamelCase			)

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

        check_hidden_states_output(_lowerCamelCase				,						_lowerCamelCase				,						_lowerCamelCase			)







    def      UpperCamelCase_ (     self			):
      lowercase       ,	lowercase				       =			self.model_tester.prepare_config_and_inputs_for_common()

      lowercase				       =			_config_zero_init(_lowerCamelCase			)
      for model_class in self.all_model_classes:
        lowercase				       =			model_class(config=_lowerCamelCase			)
        for name, param in model.named_parameters():
          if isinstance(_lowerCamelCase				,						(nn.Linear, nn.Convad, nn.LayerNorm)			):
            if param.requires_grad:
              self.assertIn(
                  ((param.data.mean() * 1e9).round() / 1e9).item()				,						[0.0, 1.0]				,						msg=F'Parameter {name} of model {model_class} seems not properly initialized'				,						)







    @unittest.skip(reason='Retain_grad is tested in individual model tests'			)
    def      UpperCamelCase_ (     self			):
      pass


def 		_SCREAMING_SNAKE_CASE					(       ):





  '''simple docstring'''





  lowercase				       =			'https://i.postimg.cc/ZKwLg2Gw/367-14.png'
  lowercase				       =			Image.open(requests.get(__snake_case						,   stream=__snake_case       ).raw       ).convert('RGB'       )
  return im



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







    @slow
    def      UpperCamelCase_ (     self			):
      lowercase				       =			'alibaba-damo/mgp-str-base'
      lowercase				       =			MgpstrForSceneTextRecognition.from_pretrained(_lowerCamelCase			).to(_lowerCamelCase			)
      lowercase				       =			MgpstrProcessor.from_pretrained(_lowerCamelCase			)

      lowercase				       =			prepare_img()
      lowercase				       =			processor(images=_lowerCamelCase				,						return_tensors='pt'			).pixel_values.to(_lowerCamelCase			)

      # forward pass
      with torch.no_grad():
        lowercase				       =			model(_lowerCamelCase			)

      # verify the logits
      self.assertEqual(outputs.logits[0].shape				,						torch.Size((1, 2_7, 3_8)			)			)

      lowercase				       =			processor.batch_decode(outputs.logits			)
      lowercase				       =			'ticket'

      self.assertEqual(out_strs['generated_text'][0]				,						_lowerCamelCase			)

      lowercase				       =			torch.tensor(
          [[[-3_9.5_3_9_7, -4_4.4_0_2_4, -3_6.1_8_4_4], [-6_1.4_7_0_9, -6_3.8_6_3_9, -5_8.3_4_5_4], [-7_4.0_2_2_5, -6_8.5_4_9_4, -7_1.2_1_6_4]]]				,						device=_lowerCamelCase				,						)

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










"""simple docstring"""



import subprocess
from argparse import ArgumentParser
from typing import List, Union

from huggingface_hub.hf_api import HfFolder, create_repo, whoami
from requests.exceptions import HTTPError

from . import BaseTransformersCLICommand

class 			a	(  a_      ):







    @staticmethod
    def      UpperCamelCase_ (     _lowerCamelCase			):
      lowercase				       =			parser.add_parser('login'				,						help='Log in using the same credentials as on huggingface.co'			)
      login_parser.set_defaults(func=lambda _lowerCamelCase			: LoginCommand(_lowerCamelCase			)			)
      lowercase				       =			parser.add_parser('whoami'				,						help='Find out which huggingface.co account you are logged in as.'			)
      whoami_parser.set_defaults(func=lambda _lowerCamelCase			: WhoamiCommand(_lowerCamelCase			)			)
      lowercase				       =			parser.add_parser('logout'				,						help='Log out'			)
      logout_parser.set_defaults(func=lambda _lowerCamelCase			: LogoutCommand(_lowerCamelCase			)			)

      # new system: git-based repo system
      lowercase				       =			parser.add_parser(
          'repo'				,						help='Deprecated: use `huggingface-cli` instead. Commands to interact with your huggingface.co repos.'				,						)
      lowercase				       =			repo_parser.add_subparsers(
          help='Deprecated: use `huggingface-cli` instead. huggingface.co repos related commands'			)
      lowercase				       =			repo_subparsers.add_parser(
          'create'				,						help='Deprecated: use `huggingface-cli` instead. Create a new repo on huggingface.co'			)
      repo_create_parser.add_argument(
          'name'				,						type=_lowerCamelCase				,						help='Name for your model\'s repo. Will be namespaced under your username to build the model id.'				,						)
      repo_create_parser.add_argument('--organization'				,						type=_lowerCamelCase				,						help='Optional: organization namespace.'			)
      repo_create_parser.add_argument('-y'				,						'--yes'				,						action='store_true'				,						help='Optional: answer Yes to the prompt'			)
      repo_create_parser.set_defaults(func=lambda _lowerCamelCase			: RepoCreateCommand(_lowerCamelCase			)			)


class 			a	:
    UpperCAmelCase_					:	Union[str, Any]      	="\u001b[1m"
    UpperCAmelCase_					:	Optional[Any]      	="\u001b[31m"
    UpperCAmelCase_					:	List[str]      	="\u001b[90m"
    UpperCAmelCase_					:	str      	="\u001b[0m"







    @classmethod
    def      UpperCamelCase_ (     cls				,						_lowerCamelCase			):
      return F'{cls._bold}{s}{cls._reset}'







    @classmethod
    def      UpperCamelCase_ (     cls				,						_lowerCamelCase			):
      return F'{cls._bold}{cls._red}{s}{cls._reset}'







    @classmethod
    def      UpperCamelCase_ (     cls				,						_lowerCamelCase			):
      return F'{cls._gray}{s}{cls._reset}'


def 		_SCREAMING_SNAKE_CASE					(       __snake_case     :    List[List[Union[str, int]]]						,   __snake_case     :    List[str]       ):





  '''simple docstring'''





  lowercase				       =			[max(len(str(__snake_case       )       ) for x in col       ) for col in zip(*__snake_case						,   __snake_case       )]
  lowercase				       =			('{{:{}}} ' * len(__snake_case       )).format(*__snake_case       )
  lowercase				       =			[]
  lines.append(row_format.format(*__snake_case       )       )
  lines.append(row_format.format(*['-' * w for w in col_widths]       )       )
  for row in rows:
    lines.append(row_format.format(*__snake_case       )       )
  return "\n".join(__snake_case       )

class 			a	:







    def __init__(     self				,						_lowerCamelCase			):
      lowercase				       =			args


class 			a	(  a_      ):







    def      UpperCamelCase_ (     self			):
      print(
          ANSI.red(
              'ERROR! `huggingface-cli login` uses an outdated login mechanism '
              'that is not compatible with the Hugging Face Hub backend anymore. '
              'Please use `huggingface-cli login instead.'			)			)


class 			a	(  a_      ):







    def      UpperCamelCase_ (     self			):
      print(
          ANSI.red(
              'WARNING! `transformers-cli whoami` is deprecated and will be removed in v5. Please use '
              '`huggingface-cli whoami` instead.'			)			)
      lowercase				       =			HfFolder.get_token()
      if token is None:
        print('Not logged in'			)
        exit()
      try:
        lowercase       ,	lowercase				       =			whoami(_lowerCamelCase			)
        print(_lowerCamelCase			)
        if orgs:
          print(ANSI.bold('orgs: '			)				,						','.join(_lowerCamelCase			)			)
      except HTTPError as e:
        print(_lowerCamelCase			)
        print(ANSI.red(e.response.text			)			)
        exit(1			)


class 			a	(  a_      ):







    def      UpperCamelCase_ (     self			):
      print(
          ANSI.red(
              'ERROR! `transformers-cli logout` uses an outdated logout mechanism '
              'that is not compatible with the Hugging Face Hub backend anymore. '
              'Please use `huggingface-cli logout instead.'			)			)


class 			a	(  a_      ):







    def      UpperCamelCase_ (     self			):
      print(
          ANSI.red(
              'WARNING! Managing repositories through transformers-cli is deprecated. '
              'Please use `huggingface-cli` instead.'			)			)
      lowercase				       =			HfFolder.get_token()
      if token is None:
        print('Not logged in'			)
        exit(1			)
      try:
        lowercase				       =			subprocess.check_output(['git', '--version']			).decode('utf-8'			)
        print(ANSI.gray(stdout.strip()			)			)
      except FileNotFoundError:
        print('Looks like you do not have git installed, please install.'			)

      try:
        lowercase				       =			subprocess.check_output(['git-lfs', '--version']			).decode('utf-8'			)
        print(ANSI.gray(stdout.strip()			)			)
      except FileNotFoundError:
        print(
            ANSI.red(
                'Looks like you do not have git-lfs installed, please install.'
                ' You can install from https://git-lfs.github.com/.'
                ' Then run `git lfs install` (you only have to do this once).'			)			)
      print(''			)

      lowercase       ,	lowercase				       =			whoami(_lowerCamelCase			)
      lowercase				       =			self.args.organization if self.args.organization is not None else user
      lowercase				       =			F'{namespace}/{self.args.name}'
      print(F'You are about to create {ANSI.bold(_lowerCamelCase			)}'			)

      if not self.args.yes:
        lowercase				       =			input('Proceed? [Y/n] '			).lower()
        if not (choice == "" or choice == "y" or choice == "yes"):
          print('Abort'			)
          exit()
      try:
        lowercase				       =			create_repo(_lowerCamelCase				,						name=self.args.name				,						organization=self.args.organization			)
      except HTTPError as e:
        print(_lowerCamelCase			)
        print(ANSI.red(e.response.text			)			)
        exit(1			)
      print('\nYour repo now lives at:'			)
      print(F'  {ANSI.bold(_lowerCamelCase			)}'			)
      print('\nYou can clone it locally with the command below, and commit/push as usual.'			)
      print(F'\n  git clone {url}'			)
      print(''			)


