






import argparse
import os

import torch

from transformers import (
    XLNetConfig,
    XLNetForQuestionAnswering,
    XLNetForSequenceClassification,
    XLNetLMHeadModel,
    load_tf_weights_in_xlnet,
)
from transformers.utils import CONFIG_NAME, WEIGHTS_NAME, logging


__a:     List[str]   					=					{
    '''cola''': 2,
    '''mnli''': 3,
    '''mrpc''': 2,
    '''sst-2''': 2,
    '''sts-b''': 1,
    '''qqp''': 2,
    '''qnli''': 2,
    '''rte''': 2,
    '''wnli''': 2,
}


logging.set_verbosity_info()




def       _SCREAMING_SNAKE_CASE (							__snake_case   ,      __snake_case   ,      __snake_case   ,      __snake_case=None )				->						Any:
       # Initialise PyTorch model
       _UpperCAmelCase							=    XLNetConfig.from_json_file(__snake_case )

       _UpperCAmelCase							=    finetuning_task.lower() if finetuning_task is not None else """"""
       if finetuning_task in GLUE_TASKS_NUM_LABELS:
              print(f"""Building PyTorch XLNetForSequenceClassification model from configuration: {config}""" )
              _UpperCAmelCase							=    finetuning_task
              _UpperCAmelCase							=    GLUE_TASKS_NUM_LABELS[finetuning_task]
              _UpperCAmelCase							=    XLNetForSequenceClassification(__snake_case )
       elif "squad" in finetuning_task:
              _UpperCAmelCase							=    finetuning_task
              _UpperCAmelCase							=    XLNetForQuestionAnswering(__snake_case )
       else:
              _UpperCAmelCase							=    XLNetLMHeadModel(__snake_case )

       # Load weights from tf checkpoint
       load_tf_weights_in_xlnet(__snake_case   ,      __snake_case   ,      __snake_case )

       # Save pytorch-model
       _UpperCAmelCase							=    os.path.join(__snake_case   ,      __snake_case )
       _UpperCAmelCase							=    os.path.join(__snake_case   ,      __snake_case )
       print(f"""Save PyTorch model to {os.path.abspath(__snake_case )}""" )
       torch.save(model.state_dict()   ,      __snake_case )
       print(f"""Save configuration file to {os.path.abspath(__snake_case )}""" )
       with open(__snake_case   ,      """w"""   ,      encoding="""utf-8""" ) as f:
              f.write(config.to_json_string() )


if __name__ == "__main__":
  __a:     str   					=					argparse.ArgumentParser()
  # Required parameters
  parser.add_argument(
      '''--tf_checkpoint_path''', default=None, type=str, required=True, help='''Path to the TensorFlow checkpoint path.'''
  )
  parser.add_argument(
      '''--xlnet_config_file''',
      default=None,
      type=str,
      required=True,
      help=(
          '''The config json file corresponding to the pre-trained XLNet model. \n'''
          '''This specifies the model architecture.'''
      ),
  )
  parser.add_argument(
      '''--pytorch_dump_folder_path''',
      default=None,
      type=str,
      required=True,
      help='''Path to the folder to store the PyTorch model or dataset/vocab.''',
  )
  parser.add_argument(
      '''--finetuning_task''',
      default=None,
      type=str,
      help='''Name of a task on which the XLNet TensorFlow model was fine-tuned''',
  )
  __a:     Optional[int]   					=					parser.parse_args()
  print(args)

  convert_xlnet_checkpoint_to_pytorch(
      args.tf_checkpoint_path, args.xlnet_config_file, args.pytorch_dump_folder_path, args.finetuning_task
  )




'''simple docstring'''





import unittest

from transformers import (
    MODEL_FOR_OBJECT_DETECTION_MAPPING,
    AutoFeatureExtractor,
    AutoModelForObjectDetection,
    ObjectDetectionPipeline,
    is_vision_available,
    pipeline,
)
from transformers.testing_utils import (
    is_pipeline_test,
    nested_simplify,
    require_pytesseract,
    require_tf,
    require_timm,
    require_torch,
    require_vision,
    slow,
)

from .test_pipelines_common import ANY


if is_vision_available():
   from PIL import Image
else:






   class    lowerCamelCase_       :
     """simple docstring"""




     @staticmethod
     def 		_lowercase	(					*_a :      Optional[Any]     ,      **_a :      Optional[Any]  )   ->   Tuple:
       pass






@is_pipeline_test
@require_vision
@require_timm
@require_torch
class    lowerCamelCase_       (							unittest.TestCase	):
  """simple docstring"""




  a_				   =MODEL_FOR_OBJECT_DETECTION_MAPPING




  def 		_lowercase	(					self :      List[Any]     ,      _a :      int     ,      _a :      str     ,      _a :      Tuple  )   ->   List[Any]:
    __lowerCamelCase			:			List[str]       			=					ObjectDetectionPipeline(model=_a     ,      image_processor=_a  )
    return object_detector, ["./tests/fixtures/tests_samples/COCO/000000039769.png"]




  def 		_lowercase	(					self :      Optional[int]     ,      _a :      int     ,      _a :      Optional[Any]  )   ->   Any:
    __lowerCamelCase			:			int       			=					object_detector('./tests/fixtures/tests_samples/COCO/000000039769.png'     ,      threshold=0.0  )

    self.assertGreater(len(_a  )     ,      0  )
    for detected_object in outputs:
      self.assertEqual(
          _a     ,      {
              'score': ANY(_a  ),
              'label': ANY(_a  ),
              'box': {'xmin': ANY(_a  ), 'ymin': ANY(_a  ), 'xmax': ANY(_a  ), 'ymax': ANY(_a  )},
          }     ,      )

    import datasets

    __lowerCamelCase			:			Optional[int]       			=					datasets.load_dataset('hf-internal-testing/fixtures_image_utils'     ,      'image'     ,      split='test'  )

    __lowerCamelCase			:			List[str]       			=					[
        Image.open('./tests/fixtures/tests_samples/COCO/000000039769.png'  ),
        'http://images.cocodataset.org/val2017/000000039769.jpg',
        # RGBA
        dataset[0]['file'],
        # LA
        dataset[1]['file'],
        # L
        dataset[2]['file'],
    ]
    __lowerCamelCase			:			Dict       			=					object_detector(_a     ,      threshold=0.0  )

    self.assertEqual(len(_a  )     ,      len(_a  )  )
    for outputs in batch_outputs:
      self.assertGreater(len(_a  )     ,      0  )
      for detected_object in outputs:
        self.assertEqual(
            _a     ,      {
                'score': ANY(_a  ),
                'label': ANY(_a  ),
                'box': {'xmin': ANY(_a  ), 'ymin': ANY(_a  ), 'xmax': ANY(_a  ), 'ymax': ANY(_a  )},
            }     ,      )




  @require_tf
  @unittest.skip('Object detection not implemented in TF'  )
  def 		_lowercase	(					self :      Optional[Any]  )   ->   Dict:
    pass




  @require_torch
  def 		_lowercase	(					self :      int  )   ->   Optional[int]:
    __lowerCamelCase			:			Dict       			=					'hf-internal-testing/tiny-detr-mobilenetsv3'

    __lowerCamelCase			:			str       			=					AutoModelForObjectDetection.from_pretrained(_a  )
    __lowerCamelCase			:			Optional[Any]       			=					AutoFeatureExtractor.from_pretrained(_a  )
    __lowerCamelCase			:			str       			=					ObjectDetectionPipeline(model=_a     ,      feature_extractor=_a  )

    __lowerCamelCase			:			Tuple       			=					object_detector('http://images.cocodataset.org/val2017/000000039769.jpg'     ,      threshold=0.0  )

    self.assertEqual(
        nested_simplify(_a     ,      decimals=4  )     ,      [
            {'score': 0.3376, 'label': 'LABEL_0', 'box': {'xmin': 159, 'ymin': 120, 'xmax': 480, 'ymax': 359}},
            {'score': 0.3376, 'label': 'LABEL_0', 'box': {'xmin': 159, 'ymin': 120, 'xmax': 480, 'ymax': 359}},
        ]     ,      )

    __lowerCamelCase			:			Optional[int]       			=					object_detector(
        [
            'http://images.cocodataset.org/val2017/000000039769.jpg',
            'http://images.cocodataset.org/val2017/000000039769.jpg',
        ]     ,      threshold=0.0     ,      )

    self.assertEqual(
        nested_simplify(_a     ,      decimals=4  )     ,      [
            [
                {'score': 0.3376, 'label': 'LABEL_0', 'box': {'xmin': 159, 'ymin': 120, 'xmax': 480, 'ymax': 359}},
                {'score': 0.3376, 'label': 'LABEL_0', 'box': {'xmin': 159, 'ymin': 120, 'xmax': 480, 'ymax': 359}},
            ],
            [
                {'score': 0.3376, 'label': 'LABEL_0', 'box': {'xmin': 159, 'ymin': 120, 'xmax': 480, 'ymax': 359}},
                {'score': 0.3376, 'label': 'LABEL_0', 'box': {'xmin': 159, 'ymin': 120, 'xmax': 480, 'ymax': 359}},
            ],
        ]     ,      )




  @require_torch
  @slow
  def 		_lowercase	(					self :      Union[str, Any]  )   ->   Dict:
    __lowerCamelCase			:			Tuple       			=					'facebook/detr-resnet-50'

    __lowerCamelCase			:			Optional[int]       			=					AutoModelForObjectDetection.from_pretrained(_a  )
    __lowerCamelCase			:			List[str]       			=					AutoFeatureExtractor.from_pretrained(_a  )
    __lowerCamelCase			:			str       			=					ObjectDetectionPipeline(model=_a     ,      feature_extractor=_a  )

    __lowerCamelCase			:			int       			=					object_detector('http://images.cocodataset.org/val2017/000000039769.jpg'  )
    self.assertEqual(
        nested_simplify(_a     ,      decimals=4  )     ,      [
            {'score': 0.9982, 'label': 'remote', 'box': {'xmin': 40, 'ymin': 70, 'xmax': 175, 'ymax': 117}},
            {'score': 0.9960, 'label': 'remote', 'box': {'xmin': 333, 'ymin': 72, 'xmax': 368, 'ymax': 187}},
            {'score': 0.9955, 'label': 'couch', 'box': {'xmin': 0, 'ymin': 1, 'xmax': 639, 'ymax': 473}},
            {'score': 0.9988, 'label': 'cat', 'box': {'xmin': 13, 'ymin': 52, 'xmax': 314, 'ymax': 470}},
            {'score': 0.9987, 'label': 'cat', 'box': {'xmin': 345, 'ymin': 23, 'xmax': 640, 'ymax': 368}},
        ]     ,      )

    __lowerCamelCase			:			List[Any]       			=					object_detector(
        [
            'http://images.cocodataset.org/val2017/000000039769.jpg',
            'http://images.cocodataset.org/val2017/000000039769.jpg',
        ]  )
    self.assertEqual(
        nested_simplify(_a     ,      decimals=4  )     ,      [
            [
                {'score': 0.9982, 'label': 'remote', 'box': {'xmin': 40, 'ymin': 70, 'xmax': 175, 'ymax': 117}},
                {'score': 0.9960, 'label': 'remote', 'box': {'xmin': 333, 'ymin': 72, 'xmax': 368, 'ymax': 187}},
                {'score': 0.9955, 'label': 'couch', 'box': {'xmin': 0, 'ymin': 1, 'xmax': 639, 'ymax': 473}},
                {'score': 0.9988, 'label': 'cat', 'box': {'xmin': 13, 'ymin': 52, 'xmax': 314, 'ymax': 470}},
                {'score': 0.9987, 'label': 'cat', 'box': {'xmin': 345, 'ymin': 23, 'xmax': 640, 'ymax': 368}},
            ],
            [
                {'score': 0.9982, 'label': 'remote', 'box': {'xmin': 40, 'ymin': 70, 'xmax': 175, 'ymax': 117}},
                {'score': 0.9960, 'label': 'remote', 'box': {'xmin': 333, 'ymin': 72, 'xmax': 368, 'ymax': 187}},
                {'score': 0.9955, 'label': 'couch', 'box': {'xmin': 0, 'ymin': 1, 'xmax': 639, 'ymax': 473}},
                {'score': 0.9988, 'label': 'cat', 'box': {'xmin': 13, 'ymin': 52, 'xmax': 314, 'ymax': 470}},
                {'score': 0.9987, 'label': 'cat', 'box': {'xmin': 345, 'ymin': 23, 'xmax': 640, 'ymax': 368}},
            ],
        ]     ,      )




  @require_torch
  @slow
  def 		_lowercase	(					self :      Tuple  )   ->   Optional[Any]:
    __lowerCamelCase			:			Any       			=					'facebook/detr-resnet-50'

    __lowerCamelCase			:			List[str]       			=					pipeline('object-detection'     ,      model=_a  )

    __lowerCamelCase			:			int       			=					object_detector('http://images.cocodataset.org/val2017/000000039769.jpg'  )
    self.assertEqual(
        nested_simplify(_a     ,      decimals=4  )     ,      [
            {'score': 0.9982, 'label': 'remote', 'box': {'xmin': 40, 'ymin': 70, 'xmax': 175, 'ymax': 117}},
            {'score': 0.9960, 'label': 'remote', 'box': {'xmin': 333, 'ymin': 72, 'xmax': 368, 'ymax': 187}},
            {'score': 0.9955, 'label': 'couch', 'box': {'xmin': 0, 'ymin': 1, 'xmax': 639, 'ymax': 473}},
            {'score': 0.9988, 'label': 'cat', 'box': {'xmin': 13, 'ymin': 52, 'xmax': 314, 'ymax': 470}},
            {'score': 0.9987, 'label': 'cat', 'box': {'xmin': 345, 'ymin': 23, 'xmax': 640, 'ymax': 368}},
        ]     ,      )

    __lowerCamelCase			:			List[Any]       			=					object_detector(
        [
            'http://images.cocodataset.org/val2017/000000039769.jpg',
            'http://images.cocodataset.org/val2017/000000039769.jpg',
        ]  )
    self.assertEqual(
        nested_simplify(_a     ,      decimals=4  )     ,      [
            [
                {'score': 0.9982, 'label': 'remote', 'box': {'xmin': 40, 'ymin': 70, 'xmax': 175, 'ymax': 117}},
                {'score': 0.9960, 'label': 'remote', 'box': {'xmin': 333, 'ymin': 72, 'xmax': 368, 'ymax': 187}},
                {'score': 0.9955, 'label': 'couch', 'box': {'xmin': 0, 'ymin': 1, 'xmax': 639, 'ymax': 473}},
                {'score': 0.9988, 'label': 'cat', 'box': {'xmin': 13, 'ymin': 52, 'xmax': 314, 'ymax': 470}},
                {'score': 0.9987, 'label': 'cat', 'box': {'xmin': 345, 'ymin': 23, 'xmax': 640, 'ymax': 368}},
            ],
            [
                {'score': 0.9982, 'label': 'remote', 'box': {'xmin': 40, 'ymin': 70, 'xmax': 175, 'ymax': 117}},
                {'score': 0.9960, 'label': 'remote', 'box': {'xmin': 333, 'ymin': 72, 'xmax': 368, 'ymax': 187}},
                {'score': 0.9955, 'label': 'couch', 'box': {'xmin': 0, 'ymin': 1, 'xmax': 639, 'ymax': 473}},
                {'score': 0.9988, 'label': 'cat', 'box': {'xmin': 13, 'ymin': 52, 'xmax': 314, 'ymax': 470}},
                {'score': 0.9987, 'label': 'cat', 'box': {'xmin': 345, 'ymin': 23, 'xmax': 640, 'ymax': 368}},
            ],
        ]     ,      )




  @require_torch
  @slow
  def 		_lowercase	(					self :      int  )   ->   Tuple:
    __lowerCamelCase			:			Optional[Any]       			=					0.9985
    __lowerCamelCase			:			Optional[Any]       			=					'facebook/detr-resnet-50'

    __lowerCamelCase			:			Optional[int]       			=					pipeline('object-detection'     ,      model=_a  )

    __lowerCamelCase			:			Dict       			=					object_detector('http://images.cocodataset.org/val2017/000000039769.jpg'     ,      threshold=_a  )
    self.assertEqual(
        nested_simplify(_a     ,      decimals=4  )     ,      [
            {'score': 0.9988, 'label': 'cat', 'box': {'xmin': 13, 'ymin': 52, 'xmax': 314, 'ymax': 470}},
            {'score': 0.9987, 'label': 'cat', 'box': {'xmin': 345, 'ymin': 23, 'xmax': 640, 'ymax': 368}},
        ]     ,      )




  @require_torch
  @require_pytesseract
  @slow
  def 		_lowercase	(					self :      int  )   ->   Any:
    __lowerCamelCase			:			Optional[int]       			=					'Narsil/layoutlmv3-finetuned-funsd'
    __lowerCamelCase			:			Tuple       			=					0.9993

    __lowerCamelCase			:			List[str]       			=					pipeline('object-detection'     ,      model=_a     ,      threshold=_a  )

    __lowerCamelCase			:			Tuple       			=					object_detector(
        'https://huggingface.co/spaces/impira/docquery/resolve/2359223c1837a7587402bda0f2643382a6eefeab/invoice.png'  )
    self.assertEqual(
        nested_simplify(_a     ,      decimals=4  )     ,      [
            {'score': 0.9993, 'label': 'I-ANSWER', 'box': {'xmin': 294, 'ymin': 254, 'xmax': 343, 'ymax': 264}},
            {'score': 0.9993, 'label': 'I-ANSWER', 'box': {'xmin': 294, 'ymin': 254, 'xmax': 343, 'ymax': 264}},
        ]     ,      )






