
from typing import TYPE_CHECKING

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


A__       :   Optional[Any]   						=					{
    """configuration_realm""": ["""REALM_PRETRAINED_CONFIG_ARCHIVE_MAP""", """RealmConfig"""],
    """tokenization_realm""": ["""RealmTokenizer"""],
}

try:
							if not is_tokenizers_available():
														raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
							pass
else:
							A__       :   List[Any]   						=					["""RealmTokenizerFast"""]

try:
							if not is_torch_available():
														raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
							pass
else:
							A__       :   List[Any]   						=					[
							    """REALM_PRETRAINED_MODEL_ARCHIVE_LIST""",
							    """RealmEmbedder""",
							    """RealmForOpenQA""",
							    """RealmKnowledgeAugEncoder""",
							    """RealmPreTrainedModel""",
							    """RealmReader""",
							    """RealmScorer""",
							    """load_tf_weights_in_realm""",
							]
							A__       :   int   						=					["""RealmRetriever"""]


if TYPE_CHECKING:
							from .configuration_realm import REALM_PRETRAINED_CONFIG_ARCHIVE_MAP, RealmConfig
							from .tokenization_realm import RealmTokenizer

							try:
														if not is_tokenizers_available():
																					raise OptionalDependencyNotAvailable()
							except OptionalDependencyNotAvailable:
														pass
							else:
														from .tokenization_realm import RealmTokenizerFast

							try:
														if not is_torch_available():
																					raise OptionalDependencyNotAvailable()
							except OptionalDependencyNotAvailable:
														pass
							else:
														from .modeling_realm import (
														    REALM_PRETRAINED_MODEL_ARCHIVE_LIST,
														    RealmEmbedder,
														    RealmForOpenQA,
														    RealmKnowledgeAugEncoder,
														    RealmPreTrainedModel,
														    RealmReader,
														    RealmScorer,
														    load_tf_weights_in_realm,
														)
														from .retrieval_realm import RealmRetriever


else:
							import sys

							A__       :   Dict   						=					_LazyModule(__name__, globals()["""__file__"""], _import_structure, module_spec=__spec__)





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

from ..features import Features


A__       :   Tuple   						=					TypeVar("""T""", bound="""TaskTemplate""")





@dataclass(frozen=__UpperCamelCase					)
class 						lowercase       (  abc.ABC					):
					# `task` is not a ClassVar since we want it to be part of the `asdict` output for JSON serialization
					__a					=    42
					__a					=    42
					__a					=    42
					def lowercase_			(		self ,	SCREAMING_SNAKE_CASE__    ):
								"""simple docstring"""







								return copy.deepcopy(self    )
					@property
					def lowercase_			(		self    ):
								"""simple docstring"""







								return Features(**self.input_schema ,	**self.label_schema    )
					@property
					@abc.abstractmethod
					def lowercase_			(		self    ):
								"""simple docstring"""







								raise NotImplementedError
					@classmethod
					def lowercase_			(		cls ,	SCREAMING_SNAKE_CASE__    ):
								"""simple docstring"""







								lowerCAmelCase__ :    List[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}    )



