





'''simple docstring'''

import unicodedata
from dataclasses import dataclass
from typing import Optional, Union

import numpy as np

from transformers.data.data_collator import DataCollatorMixin
from transformers.file_utils import PaddingStrategy
from transformers.tokenization_utils_base import PreTrainedTokenizerBase





def 						UpperCamelCase				(							_lowerCamelCase					:					List[Any]						,       _lowerCamelCase					:					List[Any]						,       _lowerCamelCase					:					Optional[int]						,       _lowerCamelCase					:					Dict       ):
    if isinstance(_lowerCamelCase						,       _lowerCamelCase       ):
        A__				=			np.full((len(_lowerCamelCase       ), sequence_length, 2)						,       _lowerCamelCase       )
    else:
        A__				=			np.full((len(_lowerCamelCase       ), sequence_length)						,       _lowerCamelCase       )

    for i, tensor in enumerate(_lowerCamelCase       ):
        if padding_side == "right":
            if isinstance(_lowerCamelCase						,       _lowerCamelCase       ):
                A__				=			tensor[:sequence_length]
            else:
                A__				=			tensor[:sequence_length]
        else:
            if isinstance(_lowerCamelCase						,       _lowerCamelCase       ):
                A__				=			tensor[:sequence_length]
            else:
                A__				=			tensor[:sequence_length]

    return out_tensor.tolist()





def 						UpperCamelCase				(							_lowerCamelCase					:					List[Any]       ):
    A__				=			ord(_lowerCamelCase       )
    if (cp >= 33 and cp <= 47) or (cp >= 58 and cp <= 64) or (cp >= 91 and cp <= 96) or (cp >= 1_23 and cp <= 1_26):
        return True
    A__				=			unicodedata.category(_lowerCamelCase       )
    if cat.startswith("P"       ):
        return True
    return False






@dataclass
class    UpperCAmelCase	(       UpperCamelCase__				):
 __lowercase   		=				42
 __lowercase   		=				True
 __lowercase   		=				None
 __lowercase   		=				None
 __lowercase   		=				-100
 __lowercase   		=				"pt"
 def      UpperCAmelCase_							(				self      :str						,       lowercase_      :Any							)->							Dict:
     import torch

     A__				=			"label" if "label" in features[0].keys() else "labels"
     A__				=			[feature[label_name] for feature in features] if label_name in features[0].keys() else None
     A__				=			self.tokenizer.pad(
         lowercase_						,       padding=self.padding						,       max_length=self.max_length						,       pad_to_multiple_of=self.pad_to_multiple_of						,       return_tensors="pt" if labels is None else None						,       )

     if labels is None:
         return batch

     A__				=			torch.tensor(batch["entity_ids"]							).shape[1]
     A__				=			self.tokenizer.padding_side
     if padding_side == "right":
         A__				=			[
             list(lowercase_							) + [self.label_pad_token_id] * (sequence_length - len(lowercase_							)) for label in labels
         ]
     else:
         A__				=			[
             [self.label_pad_token_id] * (sequence_length - len(lowercase_							)) + list(lowercase_							) for label in labels
         ]

     A__				=			[feature["ner_tags"] for feature in features]
     A__				=			padding_tensor(lowercase_						,       -1						,       lowercase_						,       lowercase_							)
     A__				=			[feature["original_entity_spans"] for feature in features]
     A__				=			padding_tensor(lowercase_						,       (-1, -1)						,       lowercase_						,       lowercase_							)
     A__				=			{k: torch.tensor(lowercase_						,       dtype=torch.intaa							) for k, v in batch.items()}

     return batch










'''simple docstring'''

import contextlib
import importlib
import io
import unittest

import transformers

# Try to import everything from transformers to ensure every object can be loaded.
from transformers import *  # noqa F406
from transformers.testing_utils import DUMMY_UNKNOWN_IDENTIFIER, require_flax, require_tf, require_torch
from transformers.utils import ContextManagers, find_labels, is_flax_available, is_tf_available, is_torch_available


if is_torch_available():
  from transformers import BertForPreTraining, BertForQuestionAnswering, BertForSequenceClassification

if is_tf_available():
  from transformers import TFBertForPreTraining, TFBertForQuestionAnswering, TFBertForSequenceClassification

if is_flax_available():
  from transformers import FlaxBertForPreTraining, FlaxBertForQuestionAnswering, FlaxBertForSequenceClassification


__lowerCAmelCase							:	Dict			=DUMMY_UNKNOWN_IDENTIFIER
# An actual model hosted on huggingface.co

__lowerCAmelCase							:	List[Any]			="main"
# Default branch name
__lowerCAmelCase							:	int			="f2c752cfc5c0ab6f4bdec59acea69eefbee381c2"
# One particular commit (not the top of `main`)
__lowerCAmelCase							:	List[Any]			="aaaaaaa"
# This commit does not exist, so we should 404.

__lowerCAmelCase							:	Optional[int]			="d9e9f15bc825e4b2c9249e9578f884bbcb5e3684"
# Sha-1 of config.json on the top of `main`, for checking purposes
__lowerCAmelCase							:	Dict			="4b243c475af8d0a7754e87d7d096c92e5199ec2fe168a2ee7998e3b8e9bcb1d3"





@contextlib.contextmanager
def 						UpperCamelCase				(							):
    print("Welcome!"       )
    yield
    print("Bye!"       )





@contextlib.contextmanager
def 						UpperCamelCase				(							):
    print("Bonjour!"       )
    yield
    print("Au revoir!"       )






class    UpperCAmelCase	(       unittest.TestCase				):
 def      UpperCAmelCase_							(				self      :str							)->							List[str]:
     # If the spec is missing, importlib would not be able to import the module dynamically.
     assert transformers.__spec__ is not None
     assert importlib.util.find_spec("transformers"							) is not None






class    UpperCAmelCase	(       unittest.TestCase				):
 @unittest.mock.patch("sys.stdout"						,       new_callable=io.StringIO							)
 def      UpperCAmelCase_							(				self      :Union[str, Any]						,       lowercase_      :Union[str, Any]							)->							Any:
     with ContextManagers([]							):
         print("Transformers are awesome!"							)
     # The print statement adds a new line at the end of the output
     self.assertEqual(mock_stdout.getvalue()						,       "Transformers are awesome!\n"							)
 @unittest.mock.patch("sys.stdout"						,       new_callable=io.StringIO							)
 def      UpperCAmelCase_							(				self      :Dict						,       lowercase_      :Optional[Any]							)->							Tuple:
     with ContextManagers([context_en()]							):
         print("Transformers are awesome!"							)
     # The output should be wrapped with an English welcome and goodbye
     self.assertEqual(mock_stdout.getvalue()						,       "Welcome!\nTransformers are awesome!\nBye!\n"							)
 @unittest.mock.patch("sys.stdout"						,       new_callable=io.StringIO							)
 def      UpperCAmelCase_							(				self      :Union[str, Any]						,       lowercase_      :int							)->							Union[str, Any]:
     with ContextManagers([context_fr(), context_en()]							):
         print("Transformers are awesome!"							)
     # The output should be wrapped with an English and French welcome and goodbye
     self.assertEqual(mock_stdout.getvalue()						,       "Bonjour!\nWelcome!\nTransformers are awesome!\nBye!\nAu revoir!\n"							)
 @require_torch
 def      UpperCAmelCase_							(				self      :int							)->							Dict:
     self.assertEqual(find_labels(lowercase_							)						,       ["labels"]							)
     self.assertEqual(find_labels(lowercase_							)						,       ["labels", "next_sentence_label"]							)
     self.assertEqual(find_labels(lowercase_							)						,       ["start_positions", "end_positions"]							)






     class    UpperCAmelCase	(       UpperCamelCase__				):
      pass

     self.assertEqual(find_labels(lowercase_							)						,       ["labels"]							)
 @require_tf
 def      UpperCAmelCase_							(				self      :Union[str, Any]							)->							Union[str, Any]:
     self.assertEqual(find_labels(lowercase_							)						,       ["labels"]							)
     self.assertEqual(find_labels(lowercase_							)						,       ["labels", "next_sentence_label"]							)
     self.assertEqual(find_labels(lowercase_							)						,       ["start_positions", "end_positions"]							)






     class    UpperCAmelCase	(       UpperCamelCase__				):
      pass

     self.assertEqual(find_labels(lowercase_							)						,       ["labels"]							)



 @require_flax
 def      UpperCAmelCase_							(				self      :Dict							)->							str:
     # Flax models don't have labels
     self.assertEqual(find_labels(lowercase_							)						,       []							)
     self.assertEqual(find_labels(lowercase_							)						,       []							)
     self.assertEqual(find_labels(lowercase_							)						,       []							)






     class    UpperCAmelCase	(       UpperCamelCase__				):
      pass

     self.assertEqual(find_labels(lowercase_							)						,       []							)



