'''simple docstring'''




from typing import TYPE_CHECKING

from ...utils import OptionalDependencyNotAvailable, _LazyModule, is_tf_available, is_torch_available


__SCREAMING_SNAKE_CASE :  List[str]  =						{
    """configuration_flaubert""": ["""FLAUBERT_PRETRAINED_CONFIG_ARCHIVE_MAP""", """FlaubertConfig""", """FlaubertOnnxConfig"""],
    """tokenization_flaubert""": ["""FlaubertTokenizer"""],
}

try:
  if not is_torch_available():
    raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
  pass
else:
  __SCREAMING_SNAKE_CASE :  Dict  =						[
      """FLAUBERT_PRETRAINED_MODEL_ARCHIVE_LIST""",
      """FlaubertForMultipleChoice""",
      """FlaubertForQuestionAnswering""",
      """FlaubertForQuestionAnsweringSimple""",
      """FlaubertForSequenceClassification""",
      """FlaubertForTokenClassification""",
      """FlaubertModel""",
      """FlaubertWithLMHeadModel""",
      """FlaubertPreTrainedModel""",
  ]

try:
  if not is_tf_available():
    raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
  pass
else:
  __SCREAMING_SNAKE_CASE :  Optional[int]  =						[
      """TF_FLAUBERT_PRETRAINED_MODEL_ARCHIVE_LIST""",
      """TFFlaubertForMultipleChoice""",
      """TFFlaubertForQuestionAnsweringSimple""",
      """TFFlaubertForSequenceClassification""",
      """TFFlaubertForTokenClassification""",
      """TFFlaubertModel""",
      """TFFlaubertPreTrainedModel""",
      """TFFlaubertWithLMHeadModel""",
  ]


if TYPE_CHECKING:
  from .configuration_flaubert import FLAUBERT_PRETRAINED_CONFIG_ARCHIVE_MAP, FlaubertConfig, FlaubertOnnxConfig
  from .tokenization_flaubert import FlaubertTokenizer

  try:
    if not is_torch_available():
      raise OptionalDependencyNotAvailable()
  except OptionalDependencyNotAvailable:
    pass
  else:
    from .modeling_flaubert import (
        FLAUBERT_PRETRAINED_MODEL_ARCHIVE_LIST,
        FlaubertForMultipleChoice,
        FlaubertForQuestionAnswering,
        FlaubertForQuestionAnsweringSimple,
        FlaubertForSequenceClassification,
        FlaubertForTokenClassification,
        FlaubertModel,
        FlaubertPreTrainedModel,
        FlaubertWithLMHeadModel,
    )

  try:
    if not is_tf_available():
      raise OptionalDependencyNotAvailable()
  except OptionalDependencyNotAvailable:
    pass
  else:
    from .modeling_tf_flaubert import (
        TF_FLAUBERT_PRETRAINED_MODEL_ARCHIVE_LIST,
        TFFlaubertForMultipleChoice,
        TFFlaubertForQuestionAnsweringSimple,
        TFFlaubertForSequenceClassification,
        TFFlaubertForTokenClassification,
        TFFlaubertModel,
        TFFlaubertPreTrainedModel,
        TFFlaubertWithLMHeadModel,
    )

else:
  import sys

  __SCREAMING_SNAKE_CASE :  Tuple  =						_LazyModule(__name__, globals()["""__file__"""], _import_structure, module_spec=__spec__)


'''simple docstring'''




import abc
import copy
import dataclasses
from dataclasses import dataclass
from typing import ClassVar, Dict, Type, TypeVar

from ..features import Features


__SCREAMING_SNAKE_CASE :  Any  =						TypeVar("""T""", bound="""TaskTemplate""")

@dataclass(frozen=snake_case__					)
class 			lowerCamelCase_			(abc.ABC					):
      '''simple docstring'''

      __UpperCamelCase:						str
      __UpperCamelCase:						ClassVar[Features]
      __UpperCamelCase:						ClassVar[Features]




      def   _A			( self		:       T		,      A		:       Features ):
             return copy.deepcopy(self )




      @property
      def   _A			( self		:       List[str] ):
             return Features(**self.input_schema		,      **self.label_schema )




      @property
      @abc.abstractmethod
      def   _A			( self		:       Optional[int] ):
             raise NotImplementedError





      @classmethod
      def   _A			( cls		:       Type[T]		,      A		:       dict ):
             _UpperCAmelCase  :						Optional[Any]							   =					{f.name for f in dataclasses.fields(cls )}
             return cls(**{k: v for k, v in template_dict.items() if k in field_names} )

