





from collections import OrderedDict
from typing import TYPE_CHECKING, Any, List, Mapping, Optional, Union

from ...configuration_utils import PretrainedConfig
from ...onnx import OnnxConfig
from ...utils import TensorType, logging


if TYPE_CHECKING:
				from ...onnx.config import PatchingSpec
				from ...tokenization_utils_base import PreTrainedTokenizerBase


__lowercase       :List[Any]       =  logging.get_logger(__name__)

__lowercase       :Optional[int]       =  {
    "allenai/longformer-base-4096": "https://huggingface.co/allenai/longformer-base-4096/resolve/main/config.json",
    "allenai/longformer-large-4096": "https://huggingface.co/allenai/longformer-large-4096/resolve/main/config.json",
    "allenai/longformer-large-4096-finetuned-triviaqa": (
        "https://huggingface.co/allenai/longformer-large-4096-finetuned-triviaqa/resolve/main/config.json"
    ),
    "allenai/longformer-base-4096-extra.pos.embd.only": (
        "https://huggingface.co/allenai/longformer-base-4096-extra.pos.embd.only/resolve/main/config.json"
    ),
    "allenai/longformer-large-4096-extra.pos.embd.only": (
        "https://huggingface.co/allenai/longformer-large-4096-extra.pos.embd.only/resolve/main/config.json"
    ),
}



class    _a     (				lowercase__							):






							"""simple docstring"""

							snake_case_							 =						"longformer"

							def __init__(      self				:     List[str]							,	a				:     Union[List[int], int] = 5_12							,	a				:     int = 2							,	a				:     int = 1							,	a				:     int = 0							,	a				:     int = 2							,	a				:     int = 3_05_22							,	a				:     int = 7_68							,	a				:     int = 12							,	a				:     int = 12							,	a				:     int = 30_72							,	a				:     str = "gelu"							,	a				:     float = 0.1							,	a				:     float = 0.1							,	a				:     int = 5_12							,	a				:     int = 2							,	a				:     float = 0.02							,	a				:     float = 1E-12							,	a				:     bool = False							,	**a				:     Dict							,	)	->Tuple:
													super().__init__(pad_token_id=a							,	**a    )

													SCREAMING_SNAKE_CASE__     :				int   =					attention_window
													SCREAMING_SNAKE_CASE__     :				Any   =					sep_token_id
													SCREAMING_SNAKE_CASE__     :				str   =					bos_token_id
													SCREAMING_SNAKE_CASE__     :				List[str]   =					eos_token_id
													SCREAMING_SNAKE_CASE__     :				List[str]   =					vocab_size
													SCREAMING_SNAKE_CASE__     :				Optional[Any]   =					hidden_size
													SCREAMING_SNAKE_CASE__     :				List[str]   =					num_hidden_layers
													SCREAMING_SNAKE_CASE__     :				Optional[int]   =					num_attention_heads
													SCREAMING_SNAKE_CASE__     :				List[Any]   =					hidden_act
													SCREAMING_SNAKE_CASE__     :				Optional[int]   =					intermediate_size
													SCREAMING_SNAKE_CASE__     :				List[str]   =					hidden_dropout_prob
													SCREAMING_SNAKE_CASE__     :				Dict   =					attention_probs_dropout_prob
													SCREAMING_SNAKE_CASE__     :				Optional[Any]   =					max_position_embeddings
													SCREAMING_SNAKE_CASE__     :				str   =					type_vocab_size
													SCREAMING_SNAKE_CASE__     :				Any   =					initializer_range
													SCREAMING_SNAKE_CASE__     :				List[Any]   =					layer_norm_eps
													SCREAMING_SNAKE_CASE__     :				Any   =					onnx_export







class    _a     (				lowercase__							):






							"""simple docstring"""

							def __init__(      self				:     int							,	a				:     "PretrainedConfig"							,	a				:     str = "default"							,	a				:     "List[PatchingSpec]" = None    )	->str:
													super().__init__(a							,	a							,	a    )
													SCREAMING_SNAKE_CASE__     :				Any   =					True

							@property
							def      A_  (      self				:     int    )	->Mapping[str, Mapping[int, str]]:
													if self.task == "multiple-choice":
																			SCREAMING_SNAKE_CASE__     :				int   =					{0: "batch", 1: "choice", 2: "sequence"}
													else:
																			SCREAMING_SNAKE_CASE__     :				str   =					{0: "batch", 1: "sequence"}
													return OrderedDict(
													    [
													        ("input_ids", dynamic_axis),
													        ("attention_mask", dynamic_axis),
													        ("global_attention_mask", dynamic_axis),
													    ]    )

							@property
							def      A_  (      self				:     Optional[Any]    )	->Mapping[str, Mapping[int, str]]:
													SCREAMING_SNAKE_CASE__     :				Optional[Any]   =					super().outputs
													if self.task == "default":
																			SCREAMING_SNAKE_CASE__     :				List[str]   =					{0: "batch"}
													return outputs

							@property
							def      A_  (      self				:     str    )	->float:
													return 1E-4

							@property
							def      A_  (      self				:     Any    )	->int:
													# needs to be >= 14 to support tril operator
													return max(super().default_onnx_opset							,	14    )






							def      A_  (      self				:     str							,	a				:     "PreTrainedTokenizerBase"							,	a				:     int = -1							,	a				:     int = -1							,	a				:     bool = False							,	a				:     Optional[TensorType] = None							,	)	->Mapping[str, Any]:
													SCREAMING_SNAKE_CASE__     :				Tuple   =					super().generate_dummy_inputs(
													    preprocessor=a							,	batch_size=a							,	seq_length=a							,	is_pair=a							,	framework=a    )
													import torch

													# for some reason, replacing this code by inputs["global_attention_mask"] = torch.randint(2, inputs["input_ids"].shape, dtype=torch.int64)
													# makes the export fail randomly
													SCREAMING_SNAKE_CASE__     :				Any   =					torch.zeros_like(inputs["input_ids"]    )
													# make every second token global
													SCREAMING_SNAKE_CASE__     :				str   =					1

													return inputs






# tests directory-specific settings - this file is run automatically
# by pytest before any tests are run

import doctest
import sys
import warnings
from os.path import abspath, dirname, join

import _pytest

from transformers.testing_utils import HfDoctestModule, HfDocTestParser


# allow having multiple repository checkouts and not needing to remember to rerun
# 'pip install -e .[dev]' when switching between checkouts and running tests.
__lowercase       :List[Any]       =  abspath(join(dirname(__file__), "src"))
sys.path.insert(1, git_repo_path)

# silence FutureWarning warnings in tests since often we can't act on them until
# they become normal warnings - i.e. the tests still need to test the current functionality
warnings.simplefilter(action="ignore", category=FutureWarning)







def       UpperCAmelCase							(     _lowerCamelCase      :  int     ):





						'''simple docstring'''


						config.addinivalue_line(
						    "markers"			,   "is_pt_tf_cross_test: mark test to run only when PT and TF interactions are tested"     )
						config.addinivalue_line(
						    "markers"			,   "is_pt_flax_cross_test: mark test to run only when PT and FLAX interactions are tested"     )
						config.addinivalue_line("markers"			,   "is_pipeline_test: mark test to run only when pipelines are tested"     )
						config.addinivalue_line("markers"			,   "is_staging_test: mark test to run only in the staging environment"     )
						config.addinivalue_line("markers"			,   "accelerate_tests: mark test that require accelerate"     )
						config.addinivalue_line("markers"			,   "tool_tests: mark the tool tests that are run on their specific schedule"     )







def       UpperCAmelCase							(     _lowerCamelCase      :  str     ):





						'''simple docstring'''


						from transformers.testing_utils import pytest_addoption_shared

						pytest_addoption_shared(_lowerCamelCase     )







def       UpperCAmelCase							(     _lowerCamelCase      :  Tuple     ):





						'''simple docstring'''


						from transformers.testing_utils import pytest_terminal_summary_main

						SCREAMING_SNAKE_CASE__     :				List[str]   =					terminalreporter.config.getoption("--make-reports"     )
						if make_reports:
												pytest_terminal_summary_main(_lowerCamelCase			,   id=_lowerCamelCase     )







def       UpperCAmelCase							(     _lowerCamelCase      :  List[Any]			,   _lowerCamelCase      :  Dict     ):





						'''simple docstring'''


						if exitstatus == 5:
												SCREAMING_SNAKE_CASE__     :				List[str]   =					0


# Doctest custom flag to ignore output.
__lowercase       :Optional[Any]       =  doctest.register_optionflag("IGNORE_RESULT")

__lowercase       :Dict       =  doctest.OutputChecker



class    _a     (				lowercase__							):






							"""simple docstring"""

							def      A_  (      self				:     Dict							,	a				:     List[str]							,	a				:     Dict							,	a				:     int    )	->Optional[Any]:
													if IGNORE_RESULT & optionflags:
																			return True
													return OutputChecker.check_output(self							,	a							,	a							,	a    )







__lowercase       :Any       =  CustomOutputChecker
__lowercase       :Any       =  HfDoctestModule



__lowercase       :int       =  HfDocTestParser