






"""simple docstring"""





import os
import re
import sys
import traceback
import warnings
from pathlib import Path
from typing import Dict, Optional, Union
from uuid import uuida

from huggingface_hub import HfFolder, ModelCard, ModelCardData, hf_hub_download, whoami
from huggingface_hub.file_download import REGEX_COMMIT_HASH
from huggingface_hub.utils import (
    EntryNotFoundError,
    RepositoryNotFoundError,
    RevisionNotFoundError,
    is_jinja_available,
)
from packaging import version
from requests import HTTPError

from .. import __version__
from .constants import (
    DEPRECATED_REVISION_ARGS,
    DIFFUSERS_CACHE,
    HUGGINGFACE_CO_RESOLVE_ENDPOINT,
    SAFETENSORS_WEIGHTS_NAME,
    WEIGHTS_NAME,
)
from .import_utils import (
    ENV_VARS_TRUE_VALUES,
    _flax_version,
    _jax_version,
    _onnxruntime_version,
    _torch_version,
    is_flax_available,
    is_onnx_available,
    is_torch_available,
)
from .logging import get_logger


A__					: Dict=	get_logger(__name__)


A__					: Any=	Path(__file__).parent / """model_card_template.md"""
A__					: int=	uuida().hex
A__					: List[str]=	os.getenv("""HF_HUB_OFFLINE""", """""").upper() in ENV_VARS_TRUE_VALUES
A__					: List[Any]=	os.getenv("""DISABLE_TELEMETRY""", """""").upper() in ENV_VARS_TRUE_VALUES
A__					: Tuple=	HUGGINGFACE_CO_RESOLVE_ENDPOINT + """/api/telemetry/"""







def   lowerCAmelCase_( SCREAMING_SNAKE_CASE = None					)					->	str:
    """simple docstring"""

    UpperCamelCase__         =    F'diffusers/{__version__}; python/{sys.version.split()[0]}; session_id/{SESSION_ID}'
    if DISABLE_TELEMETRY or HF_HUB_OFFLINE:
        return ua + "; telemetry/off"
    if is_torch_available():
        ua += F'; torch/{_torch_version}'
    if is_flax_available():
        ua += F'; jax/{_jax_version}'
        ua += F'; flax/{_flax_version}'
    if is_onnx_available():
        ua += F'; onnxruntime/{_onnxruntime_version}'
    # CI will set this value to True
    if os.environ.get('DIFFUSERS_IS_CI' ,	''					).upper() in ENV_VARS_TRUE_VALUES:
        ua += "; is_ci/true"
    if isinstance(SCREAMING_SNAKE_CASE ,	SCREAMING_SNAKE_CASE					):
        ua += "; " + "; ".join(F'{k}/{v}' for k, v in user_agent.items()					)
    elif isinstance(SCREAMING_SNAKE_CASE ,	SCREAMING_SNAKE_CASE					):
        ua += "; " + user_agent
    return ua







def   lowerCAmelCase_( SCREAMING_SNAKE_CASE ,	SCREAMING_SNAKE_CASE = None ,	SCREAMING_SNAKE_CASE = None					)					->	Union[str, Any]:
    """simple docstring"""

    if token is None:
        UpperCamelCase__         =    HfFolder.get_token()
    if organization is None:
        UpperCamelCase__         =    whoami(SCREAMING_SNAKE_CASE					)['name']
        return F'{username}/{model_id}'
    else:
        return F'{organization}/{model_id}'







def   lowerCAmelCase_( SCREAMING_SNAKE_CASE ,	SCREAMING_SNAKE_CASE					)					->	Any:
    """simple docstring"""

    if not is_jinja_available():
        raise ValueError(
            'Modelcard rendering is based on Jinja templates.'
            ' Please make sure to have `jinja` installed before using `create_model_card`.'
            ' To install it, please run `pip install Jinja2`.'					)

    if hasattr(SCREAMING_SNAKE_CASE ,	'local_rank'					) and args.local_rank not in [-1, 0]:
        return

    UpperCamelCase__         =    args.hub_token if hasattr(SCREAMING_SNAKE_CASE ,	'hub_token'					) else None
    UpperCamelCase__         =    get_full_repo_name(SCREAMING_SNAKE_CASE ,	token=SCREAMING_SNAKE_CASE					)

    UpperCamelCase__         =    ModelCard.from_template(
        card_data=ModelCardData(  # Card metadata object that will be converted to YAML block
            language='en' ,	license='apache-2.0' ,	library_name='diffusers' ,	tags=[] ,	datasets=args.dataset_name ,	metrics=[] ,	) ,	template_path=SCREAMING_SNAKE_CASE ,	model_name=SCREAMING_SNAKE_CASE ,	repo_name=SCREAMING_SNAKE_CASE ,	dataset_name=args.dataset_name if hasattr(SCREAMING_SNAKE_CASE ,	'dataset_name'					) else None ,	learning_rate=args.learning_rate ,	train_batch_size=args.train_batch_size ,	eval_batch_size=args.eval_batch_size ,	gradient_accumulation_steps=(
            args.gradient_accumulation_steps if hasattr(SCREAMING_SNAKE_CASE ,	'gradient_accumulation_steps'					) else None
        ) ,	adam_betaa=args.adam_betaa if hasattr(SCREAMING_SNAKE_CASE ,	'adam_beta1'					) else None ,	adam_betaa=args.adam_betaa if hasattr(SCREAMING_SNAKE_CASE ,	'adam_beta2'					) else None ,	adam_weight_decay=args.adam_weight_decay if hasattr(SCREAMING_SNAKE_CASE ,	'adam_weight_decay'					) else None ,	adam_epsilon=args.adam_epsilon if hasattr(SCREAMING_SNAKE_CASE ,	'adam_epsilon'					) else None ,	lr_scheduler=args.lr_scheduler if hasattr(SCREAMING_SNAKE_CASE ,	'lr_scheduler'					) else None ,	lr_warmup_steps=args.lr_warmup_steps if hasattr(SCREAMING_SNAKE_CASE ,	'lr_warmup_steps'					) else None ,	ema_inv_gamma=args.ema_inv_gamma if hasattr(SCREAMING_SNAKE_CASE ,	'ema_inv_gamma'					) else None ,	ema_power=args.ema_power if hasattr(SCREAMING_SNAKE_CASE ,	'ema_power'					) else None ,	ema_max_decay=args.ema_max_decay if hasattr(SCREAMING_SNAKE_CASE ,	'ema_max_decay'					) else None ,	mixed_precision=args.mixed_precision ,	)

    UpperCamelCase__         =    os.path.join(args.output_dir ,	'README.md'					)
    model_card.save(SCREAMING_SNAKE_CASE					)







def   lowerCAmelCase_( SCREAMING_SNAKE_CASE ,	SCREAMING_SNAKE_CASE = None					)					->	str:
    """simple docstring"""

    if resolved_file is None or commit_hash is not None:
        return commit_hash
    UpperCamelCase__         =    str(Path(SCREAMING_SNAKE_CASE					).as_posix()					)
    UpperCamelCase__         =    re.search(r'snapshots/([^/]+)/' ,	SCREAMING_SNAKE_CASE					)
    if search is None:
        return None
    UpperCamelCase__         =    search.groups()[0]
    return commit_hash if REGEX_COMMIT_HASH.match(SCREAMING_SNAKE_CASE					) else None


# Old default cache path, potentially to be migrated.
# This logic was more or less taken from `transformers`, with the following differences:
# - Diffusers doesn't use custom environment variables to specify the cache path.
# - There is no need to migrate the cache format, just move the files to the new location.
A__					: List[str]=	os.path.expanduser(
    os.getenv("""HF_HOME""", os.path.join(os.getenv("""XDG_CACHE_HOME""", """~/.cache"""), """huggingface"""))
)
A__					: Optional[Any]=	os.path.join(hf_cache_home, """diffusers""")







def   lowerCAmelCase_( SCREAMING_SNAKE_CASE = None ,	SCREAMING_SNAKE_CASE = None					)					->	None:
    """simple docstring"""

    if new_cache_dir is None:
        UpperCamelCase__         =    DIFFUSERS_CACHE
    if old_cache_dir is None:
        UpperCamelCase__         =    old_diffusers_cache

    UpperCamelCase__         =    Path(SCREAMING_SNAKE_CASE					).expanduser()
    UpperCamelCase__         =    Path(SCREAMING_SNAKE_CASE					).expanduser()
    for old_blob_path in old_cache_dir.glob('**/blobs/*'					):
        if old_blob_path.is_file() and not old_blob_path.is_symlink():
            UpperCamelCase__         =    new_cache_dir / old_blob_path.relative_to(SCREAMING_SNAKE_CASE					)
            new_blob_path.parent.mkdir(parents=SCREAMING_SNAKE_CASE ,	exist_ok=SCREAMING_SNAKE_CASE					)
            os.replace(SCREAMING_SNAKE_CASE ,	SCREAMING_SNAKE_CASE					)
            try:
                os.symlink(SCREAMING_SNAKE_CASE ,	SCREAMING_SNAKE_CASE					)
            except OSError:
                logger.warning(
                    'Could not create symlink between old cache and new cache. If you use an older version of diffusers again, files will be re-downloaded.'					)
    # At this point, old_cache_dir contains symlinks to the new cache (it can still be used).


A__					: str=	os.path.join(DIFFUSERS_CACHE, """version_diffusers_cache.txt""")
if not os.path.isfile(cache_version_file):
  A__					: Any=	0
else:
  with open(cache_version_file) as f:
    try:
      A__					: Optional[int]=	int(f.read())
    except ValueError:
      A__					: Optional[Any]=	0

if cache_version < 1:
  A__					: Union[str, Any]=	os.path.isdir(old_diffusers_cache) and len(os.listdir(old_diffusers_cache)) > 0
  if old_cache_is_not_empty:
    logger.warning(
        """The cache for model files in Diffusers v0.14.0 has moved to a new location. Moving your """
        """existing cached models. This is a one-time operation, you can interrupt it or run it """
        """later by calling `diffusers.utils.hub_utils.move_cache()`."""
    )
    try:
      move_cache()
    except Exception as e:
      A__					: Optional[Any]=	"""\n""".join(traceback.format_tb(e.__traceback__))
      logger.error(
          F"""There was a problem when trying to move your cache:\n\n{trace}\n{e.__class__.__name__}: {e}\n\nPlease """
          """file an issue at https://github.com/huggingface/diffusers/issues/new/choose, copy paste this whole """
          """message and we will do our best to help."""
      )

if cache_version < 1:
  try:
    os.makedirs(DIFFUSERS_CACHE, exist_ok=True)
    with open(cache_version_file, """w""") as f:
      f.write("""1""")
  except Exception:
    logger.warning(
        F"""There was a problem when trying to write in your cache folder ({DIFFUSERS_CACHE}). Please, ensure """
        """the directory exists and can be written to."""
    )







def   lowerCAmelCase_( SCREAMING_SNAKE_CASE ,	SCREAMING_SNAKE_CASE = None					)					->	str:
    """simple docstring"""

    if variant is not None:
        UpperCamelCase__         =    weights_name.split('.'					)
        UpperCamelCase__         =    splits[:-1] + [variant] + splits[-1:]
        UpperCamelCase__         =    '.'.join(SCREAMING_SNAKE_CASE					)

    return weights_name







def   lowerCAmelCase_( SCREAMING_SNAKE_CASE ,	*,
    SCREAMING_SNAKE_CASE ,	SCREAMING_SNAKE_CASE ,	SCREAMING_SNAKE_CASE ,	SCREAMING_SNAKE_CASE ,	SCREAMING_SNAKE_CASE ,	SCREAMING_SNAKE_CASE ,	SCREAMING_SNAKE_CASE ,	SCREAMING_SNAKE_CASE ,	SCREAMING_SNAKE_CASE ,	SCREAMING_SNAKE_CASE ,	SCREAMING_SNAKE_CASE=None ,	)					->	Optional[Any]:
    """simple docstring"""

    UpperCamelCase__         =    str(SCREAMING_SNAKE_CASE					)
    if os.path.isfile(SCREAMING_SNAKE_CASE					):
        return pretrained_model_name_or_path
    elif os.path.isdir(SCREAMING_SNAKE_CASE					):
        if os.path.isfile(os.path.join(SCREAMING_SNAKE_CASE ,	SCREAMING_SNAKE_CASE					)					):
            # Load from a PyTorch checkpoint
            UpperCamelCase__         =    os.path.join(SCREAMING_SNAKE_CASE ,	SCREAMING_SNAKE_CASE					)
            return model_file
        elif subfolder is not None and os.path.isfile(
            os.path.join(SCREAMING_SNAKE_CASE ,	SCREAMING_SNAKE_CASE ,	SCREAMING_SNAKE_CASE					)					):
            UpperCamelCase__         =    os.path.join(SCREAMING_SNAKE_CASE ,	SCREAMING_SNAKE_CASE ,	SCREAMING_SNAKE_CASE					)
            return model_file
        else:
            raise EnvironmentError(
                F'Error no file named {weights_name} found in directory {pretrained_model_name_or_path}.'					)
    else:
        # 1. First check if deprecated way of loading from branches is used
        if (
            revision in DEPRECATED_REVISION_ARGS
            and (weights_name == WEIGHTS_NAME or weights_name == SAFETENSORS_WEIGHTS_NAME)
            and version.parse(version.parse(SCREAMING_SNAKE_CASE					).base_version					) >= version.parse('0.20.0'					)
        ):
            try:
                UpperCamelCase__         =    hf_hub_download(
                    SCREAMING_SNAKE_CASE ,	filename=_add_variant(SCREAMING_SNAKE_CASE ,	SCREAMING_SNAKE_CASE					) ,	cache_dir=SCREAMING_SNAKE_CASE ,	force_download=SCREAMING_SNAKE_CASE ,	proxies=SCREAMING_SNAKE_CASE ,	resume_download=SCREAMING_SNAKE_CASE ,	local_files_only=SCREAMING_SNAKE_CASE ,	use_auth_token=SCREAMING_SNAKE_CASE ,	user_agent=SCREAMING_SNAKE_CASE ,	subfolder=SCREAMING_SNAKE_CASE ,	revision=revision or commit_hash ,	)
                warnings.warn(
                    F'Loading the variant {revision} from {pretrained_model_name_or_path} via `revision=\'{revision}\'` is deprecated. Loading instead from `revision=\'main\'` with `variant={revision}`. Loading model variants via `revision=\'{revision}\'` will be removed in diffusers v1. Please use `variant=\'{revision}\'` instead.' ,	SCREAMING_SNAKE_CASE ,	)
                return model_file
            except:  # noqa: E722
                warnings.warn(
                    F'You are loading the variant {revision} from {pretrained_model_name_or_path} via `revision=\'{revision}\'`. This behavior is deprecated and will be removed in diffusers v1. One should use `variant=\'{revision}\'` instead. However, it appears that {pretrained_model_name_or_path} currently does not have a {_add_variant(SCREAMING_SNAKE_CASE ,	SCREAMING_SNAKE_CASE					)} file in the \'main\' branch of {pretrained_model_name_or_path}. \n The Diffusers team and community would be very grateful if you could open an issue: https://github.com/huggingface/diffusers/issues/new with the title \'{pretrained_model_name_or_path} is missing {_add_variant(SCREAMING_SNAKE_CASE ,	SCREAMING_SNAKE_CASE					)}\' so that the correct variant file can be added.' ,	SCREAMING_SNAKE_CASE ,	)
        try:
            # 2. Load model file as usual
            UpperCamelCase__         =    hf_hub_download(
                SCREAMING_SNAKE_CASE ,	filename=SCREAMING_SNAKE_CASE ,	cache_dir=SCREAMING_SNAKE_CASE ,	force_download=SCREAMING_SNAKE_CASE ,	proxies=SCREAMING_SNAKE_CASE ,	resume_download=SCREAMING_SNAKE_CASE ,	local_files_only=SCREAMING_SNAKE_CASE ,	use_auth_token=SCREAMING_SNAKE_CASE ,	user_agent=SCREAMING_SNAKE_CASE ,	subfolder=SCREAMING_SNAKE_CASE ,	revision=revision or commit_hash ,	)
            return model_file

        except RepositoryNotFoundError:
            raise EnvironmentError(
                F'{pretrained_model_name_or_path} is not a local folder and is not a valid model identifier '
                'listed on \'https://huggingface.co/models\'\nIf this is a private repository, make sure to pass a '
                'token having permission to this repo with `use_auth_token` or log in with `huggingface-cli '
                'login`.'					)
        except RevisionNotFoundError:
            raise EnvironmentError(
                F'{revision} is not a valid git identifier (branch name, tag name or commit id) that exists for '
                'this model name. Check the model page at '
                F'\'https://huggingface.co/{pretrained_model_name_or_path}\' for available revisions.'					)
        except EntryNotFoundError:
            raise EnvironmentError(
                F'{pretrained_model_name_or_path} does not appear to have a file named {weights_name}.'					)
        except HTTPError as err:
            raise EnvironmentError(
                F'There was a specific connection error when trying to load {pretrained_model_name_or_path}:\n{err}'					)
        except ValueError:
            raise EnvironmentError(
                F'We couldn\'t connect to \'{HUGGINGFACE_CO_RESOLVE_ENDPOINT}\' to load this model, couldn\'t find it'
                F' in the cached files and it looks like {pretrained_model_name_or_path} is not the path to a'
                F' directory containing a file named {weights_name} or'
                ' \nCheckout your internet connection or see how to run the library in'
                ' offline mode at \'https://huggingface.co/docs/diffusers/installation#offline-mode\'.'					)
        except EnvironmentError:
            raise EnvironmentError(
                F'Can\'t load the model for \'{pretrained_model_name_or_path}\'. If you were trying to load it from '
                '\'https://huggingface.co/models\', make sure you don\'t have a local directory with the same name. '
                F'Otherwise, make sure \'{pretrained_model_name_or_path}\' is the correct path to a directory '
                F'containing a file named {weights_name}'					)












"""simple docstring"""





from __future__ import annotations

import os
import tempfile
import unittest

from transformers import ConvBertConfig, is_tf_available
from transformers.testing_utils import require_tf, slow

from ...test_configuration_common import ConfigTester
from ...test_modeling_tf_common import TFModelTesterMixin, ids_tensor, random_attention_mask
from ...test_pipeline_mixin import PipelineTesterMixin


if is_tf_available():
  import tensorflow as tf

  from transformers import (
      TFConvBertForMaskedLM,
      TFConvBertForMultipleChoice,
      TFConvBertForQuestionAnswering,
      TFConvBertForSequenceClassification,
      TFConvBertForTokenClassification,
      TFConvBertModel,
  )
class    __lowerCamelCase    :

   def __init__(					self ,				snake_case_ ,				snake_case_=13 ,				snake_case_=7 ,				snake_case_=True ,				snake_case_=True ,				snake_case_=True ,				snake_case_=True ,				snake_case_=99 ,				snake_case_=32 ,				snake_case_=2 ,				snake_case_=4 ,				snake_case_=37 ,				snake_case_="gelu" ,				snake_case_=0.1 ,				snake_case_=0.1 ,				snake_case_=512 ,				snake_case_=16 ,				snake_case_=2 ,				snake_case_=0.02 ,				snake_case_=3 ,				snake_case_=4 ,				snake_case_=None ,				)		->       Tuple:
       UpperCamelCase__         =    parent
       UpperCamelCase__         =    13
       UpperCamelCase__         =    7
       UpperCamelCase__         =    True
       UpperCamelCase__         =    True
       UpperCamelCase__         =    True
       UpperCamelCase__         =    True
       UpperCamelCase__         =    99
       UpperCamelCase__         =    384
       UpperCamelCase__         =    2
       UpperCamelCase__         =    4
       UpperCamelCase__         =    37
       UpperCamelCase__         =    'gelu'
       UpperCamelCase__         =    0.1
       UpperCamelCase__         =    0.1
       UpperCamelCase__         =    512
       UpperCamelCase__         =    16
       UpperCamelCase__         =    2
       UpperCamelCase__         =    0.02
       UpperCamelCase__         =    3
       UpperCamelCase__         =    4
       UpperCamelCase__         =    128
       UpperCamelCase__         =    2
       UpperCamelCase__         =    9
       UpperCamelCase__         =    1
       UpperCamelCase__         =    None

   def 						SCREAMING_SNAKE_CASE__ (					self      )		->       int:
       UpperCamelCase__         =    ids_tensor([self.batch_size, self.seq_length] ,				self.vocab_size      )

       UpperCamelCase__         =    None
       if self.use_input_mask:
           UpperCamelCase__         =    random_attention_mask([self.batch_size, self.seq_length]      )

       UpperCamelCase__         =    None
       if self.use_token_type_ids:
           UpperCamelCase__         =    ids_tensor([self.batch_size, self.seq_length] ,				self.type_vocab_size      )

       UpperCamelCase__         =    None
       UpperCamelCase__         =    None
       UpperCamelCase__         =    None
       if self.use_labels:
           UpperCamelCase__         =    ids_tensor([self.batch_size] ,				self.type_sequence_label_size      )
           UpperCamelCase__         =    ids_tensor([self.batch_size, self.seq_length] ,				self.num_labels      )
           UpperCamelCase__         =    ids_tensor([self.batch_size] ,				self.num_choices      )

       UpperCamelCase__         =    ConvBertConfig(
           vocab_size=self.vocab_size ,				hidden_size=self.hidden_size ,				num_hidden_layers=self.num_hidden_layers ,				num_attention_heads=self.num_attention_heads ,				intermediate_size=self.intermediate_size ,				hidden_act=self.hidden_act ,				hidden_dropout_prob=self.hidden_dropout_prob ,				attention_probs_dropout_prob=self.attention_probs_dropout_prob ,				max_position_embeddings=self.max_position_embeddings ,				type_vocab_size=self.type_vocab_size ,				initializer_range=self.initializer_range ,				return_dict=snake_case_ ,				)

       return config, input_ids, token_type_ids, input_mask, sequence_labels, token_labels, choice_labels

   def 						SCREAMING_SNAKE_CASE__ (					self ,				snake_case_ ,				snake_case_ ,				snake_case_ ,				snake_case_ ,				snake_case_ ,				snake_case_ ,				snake_case_      )		->       int:
       UpperCamelCase__         =    TFConvBertModel(config=snake_case_      )
       UpperCamelCase__         =    {'input_ids': input_ids, 'attention_mask': input_mask, 'token_type_ids': token_type_ids}

       UpperCamelCase__         =    [input_ids, input_mask]
       UpperCamelCase__         =    model(snake_case_      )

       UpperCamelCase__         =    model(snake_case_      )

       self.parent.assertEqual(result.last_hidden_state.shape ,				(self.batch_size, self.seq_length, self.hidden_size)      )

   def 						SCREAMING_SNAKE_CASE__ (					self ,				snake_case_ ,				snake_case_ ,				snake_case_ ,				snake_case_ ,				snake_case_ ,				snake_case_ ,				snake_case_      )		->       int:
       UpperCamelCase__         =    TFConvBertForMaskedLM(config=snake_case_      )
       UpperCamelCase__         =    {
           'input_ids': input_ids,
           'attention_mask': input_mask,
           'token_type_ids': token_type_ids,
       }
       UpperCamelCase__         =    model(snake_case_      )
       self.parent.assertEqual(result.logits.shape ,				(self.batch_size, self.seq_length, self.vocab_size)      )

   def 						SCREAMING_SNAKE_CASE__ (					self ,				snake_case_ ,				snake_case_ ,				snake_case_ ,				snake_case_ ,				snake_case_ ,				snake_case_ ,				snake_case_      )		->       List[str]:
       UpperCamelCase__         =    self.num_labels
       UpperCamelCase__         =    TFConvBertForSequenceClassification(config=snake_case_      )
       UpperCamelCase__         =    {
           'input_ids': input_ids,
           'attention_mask': input_mask,
           'token_type_ids': token_type_ids,
       }

       UpperCamelCase__         =    model(snake_case_      )
       self.parent.assertEqual(result.logits.shape ,				(self.batch_size, self.num_labels)      )

   def 						SCREAMING_SNAKE_CASE__ (					self ,				snake_case_ ,				snake_case_ ,				snake_case_ ,				snake_case_ ,				snake_case_ ,				snake_case_ ,				snake_case_      )		->       Tuple:
       UpperCamelCase__         =    self.num_choices
       UpperCamelCase__         =    TFConvBertForMultipleChoice(config=snake_case_      )
       UpperCamelCase__         =    tf.tile(tf.expand_dims(snake_case_ ,				1      ) ,				(1, self.num_choices, 1)      )
       UpperCamelCase__         =    tf.tile(tf.expand_dims(snake_case_ ,				1      ) ,				(1, self.num_choices, 1)      )
       UpperCamelCase__         =    tf.tile(tf.expand_dims(snake_case_ ,				1      ) ,				(1, self.num_choices, 1)      )
       UpperCamelCase__         =    {
           'input_ids': multiple_choice_inputs_ids,
           'attention_mask': multiple_choice_input_mask,
           'token_type_ids': multiple_choice_token_type_ids,
       }
       UpperCamelCase__         =    model(snake_case_      )
       self.parent.assertEqual(result.logits.shape ,				(self.batch_size, self.num_choices)      )

   def 						SCREAMING_SNAKE_CASE__ (					self ,				snake_case_ ,				snake_case_ ,				snake_case_ ,				snake_case_ ,				snake_case_ ,				snake_case_ ,				snake_case_      )		->       List[str]:
       UpperCamelCase__         =    self.num_labels
       UpperCamelCase__         =    TFConvBertForTokenClassification(config=snake_case_      )
       UpperCamelCase__         =    {
           'input_ids': input_ids,
           'attention_mask': input_mask,
           'token_type_ids': token_type_ids,
       }
       UpperCamelCase__         =    model(snake_case_      )
       self.parent.assertEqual(result.logits.shape ,				(self.batch_size, self.seq_length, self.num_labels)      )

   def 						SCREAMING_SNAKE_CASE__ (					self ,				snake_case_ ,				snake_case_ ,				snake_case_ ,				snake_case_ ,				snake_case_ ,				snake_case_ ,				snake_case_      )		->       List[Any]:
       UpperCamelCase__         =    TFConvBertForQuestionAnswering(config=snake_case_      )
       UpperCamelCase__         =    {
           'input_ids': input_ids,
           'attention_mask': input_mask,
           'token_type_ids': token_type_ids,
       }

       UpperCamelCase__         =    model(snake_case_      )
       self.parent.assertEqual(result.start_logits.shape ,				(self.batch_size, self.seq_length)      )
       self.parent.assertEqual(result.end_logits.shape ,				(self.batch_size, self.seq_length)      )







   def 						SCREAMING_SNAKE_CASE__ (					self      )		->       Tuple:
       UpperCamelCase__         =    self.prepare_config_and_inputs()
       (
           (
           UpperCamelCase__
       )       ,						(
           UpperCamelCase__
       )       ,						(
           UpperCamelCase__
       )       ,						(
           UpperCamelCase__
       )       ,						(
           UpperCamelCase__
       )       ,						(
           UpperCamelCase__
       )       ,						(
           UpperCamelCase__
       )       ,						
       )         =    config_and_inputs
       UpperCamelCase__         =    {'input_ids': input_ids, 'token_type_ids': token_type_ids, 'attention_mask': input_mask}
       return config, inputs_dict







@require_tf
class    __lowerCamelCase    (  _a							,	_a							,	unittest.TestCase  ):
   a      :				Any 						=(
       (
           TFConvBertModel,
           TFConvBertForMaskedLM,
           TFConvBertForQuestionAnswering,
           TFConvBertForSequenceClassification,
           TFConvBertForTokenClassification,
           TFConvBertForMultipleChoice,
       )
       if is_tf_available()
       else ()
   )
   a      :				str 						=(
       {
           """feature-extraction""": TFConvBertModel,
           """fill-mask""": TFConvBertForMaskedLM,
           """question-answering""": TFConvBertForQuestionAnswering,
           """text-classification""": TFConvBertForSequenceClassification,
           """token-classification""": TFConvBertForTokenClassification,
           """zero-shot""": TFConvBertForSequenceClassification,
       }
       if is_tf_available()
       else {}
   )
   a      :				Any 						=False
   a      :				Dict 						=False
   a      :				str 						=False

   def 						SCREAMING_SNAKE_CASE__ (					self      )		->       Dict:
       UpperCamelCase__         =    TFConvBertModelTester(self      )
       UpperCamelCase__         =    ConfigTester(self ,				config_class=snake_case_ ,				hidden_size=37      )

   def 						SCREAMING_SNAKE_CASE__ (					self      )		->       int:
       self.config_tester.run_common_tests()

   def 						SCREAMING_SNAKE_CASE__ (					self      )		->       int:
       UpperCamelCase__         =    self.model_tester.prepare_config_and_inputs()
       self.model_tester.create_and_check_model(*snake_case_      )

   def 						SCREAMING_SNAKE_CASE__ (					self      )		->       Dict:
       UpperCamelCase__         =    self.model_tester.prepare_config_and_inputs()
       self.model_tester.create_and_check_for_masked_lm(*snake_case_      )

   def 						SCREAMING_SNAKE_CASE__ (					self      )		->       Optional[int]:
       UpperCamelCase__         =    self.model_tester.prepare_config_and_inputs()
       self.model_tester.create_and_check_for_multiple_choice(*snake_case_      )

   def 						SCREAMING_SNAKE_CASE__ (					self      )		->       Dict:
       UpperCamelCase__         =    self.model_tester.prepare_config_and_inputs()
       self.model_tester.create_and_check_for_question_answering(*snake_case_      )

   def 						SCREAMING_SNAKE_CASE__ (					self      )		->       int:
       UpperCamelCase__         =    self.model_tester.prepare_config_and_inputs()
       self.model_tester.create_and_check_for_sequence_classification(*snake_case_      )

   def 						SCREAMING_SNAKE_CASE__ (					self      )		->       List[str]:
       UpperCamelCase__         =    self.model_tester.prepare_config_and_inputs()
       self.model_tester.create_and_check_for_token_classification(*snake_case_      )

   @slow
   def 						SCREAMING_SNAKE_CASE__ (					self      )		->       List[Any]:
       UpperCamelCase__       ,						UpperCamelCase__         =    self.model_tester.prepare_config_and_inputs_for_common()
       UpperCamelCase__         =    True
       UpperCamelCase__         =    True

       if hasattr(snake_case_ ,				'use_cache'      ):
           UpperCamelCase__         =    True

       UpperCamelCase__         =    getattr(self.model_tester ,				'encoder_seq_length' ,				self.model_tester.seq_length      )
       UpperCamelCase__         =    getattr(self.model_tester ,				'key_length' ,				snake_case_      )

       for model_class in self.all_model_classes:
           UpperCamelCase__         =    self._prepare_for_class(snake_case_ ,				snake_case_      )
           UpperCamelCase__         =    model_class(snake_case_      )
           UpperCamelCase__         =    len(model(snake_case_      )      )

           with tempfile.TemporaryDirectory() as tmpdirname:
               model.save_pretrained(snake_case_ ,				saved_model=snake_case_      )
               UpperCamelCase__         =    os.path.join(snake_case_ ,				'saved_model' ,				'1'      )
               UpperCamelCase__         =    tf.keras.models.load_model(snake_case_      )
               UpperCamelCase__         =    model(snake_case_      )

               if self.is_encoder_decoder:
                   UpperCamelCase__         =    outputs['encoder_hidden_states']
                   UpperCamelCase__         =    outputs['encoder_attentions']
               else:
                   UpperCamelCase__         =    outputs['hidden_states']
                   UpperCamelCase__         =    outputs['attentions']

               self.assertEqual(len(snake_case_      ) ,				snake_case_      )

               UpperCamelCase__         =    getattr(
                   self.model_tester ,				'expected_num_hidden_layers' ,				self.model_tester.num_hidden_layers + 1      )

               self.assertEqual(len(snake_case_      ) ,				snake_case_      )
               self.assertListEqual(
                   list(output_hidden_states[0].shape[-2:]      ) ,				[self.model_tester.seq_length, self.model_tester.hidden_size] ,				)

               self.assertEqual(len(snake_case_      ) ,				self.model_tester.num_hidden_layers      )
               self.assertListEqual(
                   list(output_attentions[0].shape[-3:]      ) ,				[self.model_tester.num_attention_heads / 2, encoder_seq_length, encoder_key_length] ,				)

   @slow
   def 						SCREAMING_SNAKE_CASE__ (					self      )		->       Union[str, Any]:
       UpperCamelCase__         =    TFConvBertModel.from_pretrained('YituTech/conv-bert-base'      )
       self.assertIsNotNone(snake_case_      )







   def 						SCREAMING_SNAKE_CASE__ (					self      )		->       Dict:
       UpperCamelCase__       ,						UpperCamelCase__         =    self.model_tester.prepare_config_and_inputs_for_common()
       UpperCamelCase__         =    True
       UpperCamelCase__         =    getattr(self.model_tester ,				'decoder_seq_length' ,				self.model_tester.seq_length      )
       UpperCamelCase__         =    getattr(self.model_tester ,				'encoder_seq_length' ,				self.model_tester.seq_length      )
       UpperCamelCase__         =    getattr(self.model_tester ,				'key_length' ,				snake_case_      )
       UpperCamelCase__         =    getattr(self.model_tester ,				'key_length' ,				snake_case_      )

       def check_decoder_attentions_output(snake_case_      ):
           UpperCamelCase__         =    len(snake_case_      )
           self.assertEqual(out_len % 2 ,				0      )
           UpperCamelCase__         =    outputs.decoder_attentions
           self.assertEqual(len(snake_case_      ) ,				self.model_tester.num_hidden_layers      )
           self.assertListEqual(
               list(decoder_attentions[0].shape[-3:]      ) ,				[self.model_tester.num_attention_heads / 2, decoder_seq_length, decoder_key_length] ,				)

       def check_encoder_attentions_output(snake_case_      ):
           UpperCamelCase__         =    [
               t.numpy() for t in (outputs.encoder_attentions if config.is_encoder_decoder else outputs.attentions)
           ]
           self.assertEqual(len(snake_case_      ) ,				self.model_tester.num_hidden_layers      )
           self.assertListEqual(
               list(attentions[0].shape[-3:]      ) ,				[self.model_tester.num_attention_heads / 2, encoder_seq_length, encoder_key_length] ,				)

       for model_class in self.all_model_classes:
           UpperCamelCase__         =    True
           UpperCamelCase__         =    False
           UpperCamelCase__         =    model_class(snake_case_      )
           UpperCamelCase__         =    model(self._prepare_for_class(snake_case_ ,				snake_case_      )      )
           UpperCamelCase__         =    len(snake_case_      )
           self.assertEqual(config.output_hidden_states ,				snake_case_      )
           check_encoder_attentions_output(snake_case_      )

           if self.is_encoder_decoder:
               UpperCamelCase__         =    model_class(snake_case_      )
               UpperCamelCase__         =    model(self._prepare_for_class(snake_case_ ,				snake_case_      )      )
               self.assertEqual(config.output_hidden_states ,				snake_case_      )
               check_decoder_attentions_output(snake_case_      )

           # Check that output attentions can also be changed via the config
           del inputs_dict["output_attentions"]
           UpperCamelCase__         =    True
           UpperCamelCase__         =    model_class(snake_case_      )
           UpperCamelCase__         =    model(self._prepare_for_class(snake_case_ ,				snake_case_      )      )
           self.assertEqual(config.output_hidden_states ,				snake_case_      )
           check_encoder_attentions_output(snake_case_      )

           # Check attention is always last and order is fine
           UpperCamelCase__         =    True
           UpperCamelCase__         =    True
           UpperCamelCase__         =    model_class(snake_case_      )
           UpperCamelCase__         =    model(self._prepare_for_class(snake_case_ ,				snake_case_      )      )

           self.assertEqual(out_len + (2 if self.is_encoder_decoder else 1) ,				len(snake_case_      )      )
           self.assertEqual(model.config.output_hidden_states ,				snake_case_      )
           check_encoder_attentions_output(snake_case_      )







@require_tf
class    __lowerCamelCase    (  unittest.TestCase  ):

   @slow
   def 						SCREAMING_SNAKE_CASE__ (					self      )		->       List[Any]:
       UpperCamelCase__         =    TFConvBertModel.from_pretrained('YituTech/conv-bert-base'      )
       UpperCamelCase__         =    tf.constant([[0, 1, 2, 3, 4, 5]]      )
       UpperCamelCase__         =    model(snake_case_      )[0]

       UpperCamelCase__         =    [1, 6, 768]
       self.assertEqual(output.shape ,				snake_case_      )

       UpperCamelCase__         =    tf.constant(
           [
               [
                   [-0.03_475_493, -0.4_686_034, -0.30_638_832],
                   [0.22_637_248, -0.26_988_646, -0.7_423_424],
                   [0.10_324_868, -0.45_013_508, -0.58_280_784],
               ]
           ]      )
       tf.debugging.assert_near(output[:, :3, :3] ,				snake_case_ ,				atol=1E-4      )




