Fast imports part 3 (#9474)

* New intermediate inits

* Update template

* Avoid importing torch/tf/flax in tokenization unless necessary

* Styling

* Shutup flake8

* Better python version check

src/transformers/models/roberta/__init__.py

@@ -16,38 +16,103 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
-from ...file_utils import is_flax_available, is_tf_available, is_tokenizers_available, is_torch_available
-from .configuration_roberta import ROBERTA_PRETRAINED_CONFIG_ARCHIVE_MAP, RobertaConfig
-from .tokenization_roberta import RobertaTokenizer
+from typing import TYPE_CHECKING
 
+from ...file_utils import (
+    _BaseLazyModule,
+    is_flax_available,
+    is_tf_available,
+    is_tokenizers_available,
+    is_torch_available,
+)
+
+
+_import_structure = {
+    "configuration_roberta": ["ROBERTA_PRETRAINED_CONFIG_ARCHIVE_MAP", "RobertaConfig"],
+    "tokenization_roberta": ["RobertaTokenizer"],
+}
 
 if is_tokenizers_available():
-    from .tokenization_roberta_fast import RobertaTokenizerFast
+    _import_structure["tokenization_roberta_fast"] = ["RobertaTokenizerFast"]
 
 if is_torch_available():
-    from .modeling_roberta import (
-        ROBERTA_PRETRAINED_MODEL_ARCHIVE_LIST,
-        RobertaForCausalLM,
-        RobertaForMaskedLM,
-        RobertaForMultipleChoice,
-        RobertaForQuestionAnswering,
-        RobertaForSequenceClassification,
-        RobertaForTokenClassification,
-        RobertaModel,
-    )
+    _import_structure["modeling_roberta"] = [
+        "ROBERTA_PRETRAINED_MODEL_ARCHIVE_LIST",
+        "RobertaForCausalLM",
+        "RobertaForMaskedLM",
+        "RobertaForMultipleChoice",
+        "RobertaForQuestionAnswering",
+        "RobertaForSequenceClassification",
+        "RobertaForTokenClassification",
+        "RobertaModel",
+    ]
 
 if is_tf_available():
-    from .modeling_tf_roberta import (
-        TF_ROBERTA_PRETRAINED_MODEL_ARCHIVE_LIST,
-        TFRobertaForMaskedLM,
-        TFRobertaForMultipleChoice,
-        TFRobertaForQuestionAnswering,
-        TFRobertaForSequenceClassification,
-        TFRobertaForTokenClassification,
-        TFRobertaMainLayer,
-        TFRobertaModel,
-        TFRobertaPreTrainedModel,
-    )
+    _import_structure["modeling_tf_roberta"] = [
+        "TF_ROBERTA_PRETRAINED_MODEL_ARCHIVE_LIST",
+        "TFRobertaForMaskedLM",
+        "TFRobertaForMultipleChoice",
+        "TFRobertaForQuestionAnswering",
+        "TFRobertaForSequenceClassification",
+        "TFRobertaForTokenClassification",
+        "TFRobertaMainLayer",
+        "TFRobertaModel",
+        "TFRobertaPreTrainedModel",
+    ]
 
 if is_flax_available():
-    from .modeling_flax_roberta import FlaxRobertaModel
+    _import_structure["modeling_flax_roberta"] = ["FlaxRobertaModel"]
+
+
+if TYPE_CHECKING:
+    from .configuration_roberta import ROBERTA_PRETRAINED_CONFIG_ARCHIVE_MAP, RobertaConfig
+    from .tokenization_roberta import RobertaTokenizer
+
+    if is_tokenizers_available():
+        from .tokenization_roberta_fast import RobertaTokenizerFast
+
+    if is_torch_available():
+        from .modeling_roberta import (
+            ROBERTA_PRETRAINED_MODEL_ARCHIVE_LIST,
+            RobertaForCausalLM,
+            RobertaForMaskedLM,
+            RobertaForMultipleChoice,
+            RobertaForQuestionAnswering,
+            RobertaForSequenceClassification,
+            RobertaForTokenClassification,
+            RobertaModel,
+        )
+
+    if is_tf_available():
+        from .modeling_tf_roberta import (
+            TF_ROBERTA_PRETRAINED_MODEL_ARCHIVE_LIST,
+            TFRobertaForMaskedLM,
+            TFRobertaForMultipleChoice,
+            TFRobertaForQuestionAnswering,
+            TFRobertaForSequenceClassification,
+            TFRobertaForTokenClassification,
+            TFRobertaMainLayer,
+            TFRobertaModel,
+            TFRobertaPreTrainedModel,
+        )
+
+    if is_flax_available():
+        from .modeling_flax_roberta import FlaxRobertaModel
+
+else:
+    import importlib
+    import os
+    import sys
+
+    class _LazyModule(_BaseLazyModule):
+        """
+        Module class that surfaces all objects but only performs associated imports when the objects are requested.
+        """
+
+        __file__ = globals()["__file__"]
+        __path__ = [os.path.dirname(__file__)]
+
+        def _get_module(self, module_name: str):
+            return importlib.import_module("." + module_name, self.__name__)
+
+    sys.modules[__name__] = _LazyModule(__name__, _import_structure)

src/transformers/models/squeezebert/__init__.py

@@ -16,23 +16,67 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
-from ...file_utils import is_tokenizers_available, is_torch_available
-from .configuration_squeezebert import SQUEEZEBERT_PRETRAINED_CONFIG_ARCHIVE_MAP, SqueezeBertConfig
-from .tokenization_squeezebert import SqueezeBertTokenizer
+from typing import TYPE_CHECKING
 
+from ...file_utils import _BaseLazyModule, is_tokenizers_available, is_torch_available
+
+
+_import_structure = {
+    "configuration_squeezebert": ["SQUEEZEBERT_PRETRAINED_CONFIG_ARCHIVE_MAP", "SqueezeBertConfig"],
+    "tokenization_squeezebert": ["SqueezeBertTokenizer"],
+}
 
 if is_tokenizers_available():
-    from .tokenization_squeezebert_fast import SqueezeBertTokenizerFast
+    _import_structure["tokenization_squeezebert_fast"] = ["SqueezeBertTokenizerFast"]
 
 if is_torch_available():
-    from .modeling_squeezebert import (
-        SQUEEZEBERT_PRETRAINED_MODEL_ARCHIVE_LIST,
-        SqueezeBertForMaskedLM,
-        SqueezeBertForMultipleChoice,
-        SqueezeBertForQuestionAnswering,
-        SqueezeBertForSequenceClassification,
-        SqueezeBertForTokenClassification,
-        SqueezeBertModel,
-        SqueezeBertModule,
-        SqueezeBertPreTrainedModel,
-    )
+    _import_structure["modeling_squeezebert"] = [
+        "SQUEEZEBERT_PRETRAINED_MODEL_ARCHIVE_LIST",
+        "SqueezeBertForMaskedLM",
+        "SqueezeBertForMultipleChoice",
+        "SqueezeBertForQuestionAnswering",
+        "SqueezeBertForSequenceClassification",
+        "SqueezeBertForTokenClassification",
+        "SqueezeBertModel",
+        "SqueezeBertModule",
+        "SqueezeBertPreTrainedModel",
+    ]
+
+
+if TYPE_CHECKING:
+    from .configuration_squeezebert import SQUEEZEBERT_PRETRAINED_CONFIG_ARCHIVE_MAP, SqueezeBertConfig
+    from .tokenization_squeezebert import SqueezeBertTokenizer
+
+    if is_tokenizers_available():
+        from .tokenization_squeezebert_fast import SqueezeBertTokenizerFast
+
+    if is_torch_available():
+        from .modeling_squeezebert import (
+            SQUEEZEBERT_PRETRAINED_MODEL_ARCHIVE_LIST,
+            SqueezeBertForMaskedLM,
+            SqueezeBertForMultipleChoice,
+            SqueezeBertForQuestionAnswering,
+            SqueezeBertForSequenceClassification,
+            SqueezeBertForTokenClassification,
+            SqueezeBertModel,
+            SqueezeBertModule,
+            SqueezeBertPreTrainedModel,
+        )
+
+else:
+    import importlib
+    import os
+    import sys
+
+    class _LazyModule(_BaseLazyModule):
+        """
+        Module class that surfaces all objects but only performs associated imports when the objects are requested.
+        """
+
+        __file__ = globals()["__file__"]
+        __path__ = [os.path.dirname(__file__)]
+
+        def _get_module(self, module_name: str):
+            return importlib.import_module("." + module_name, self.__name__)
+
+    sys.modules[__name__] = _LazyModule(__name__, _import_structure)

src/transformers/models/t5/__init__.py

@@ -16,31 +16,89 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
-from ...file_utils import is_sentencepiece_available, is_tf_available, is_tokenizers_available, is_torch_available
-from .configuration_t5 import T5_PRETRAINED_CONFIG_ARCHIVE_MAP, T5Config
+from typing import TYPE_CHECKING
 
+from ...file_utils import (
+    _BaseLazyModule,
+    is_sentencepiece_available,
+    is_tf_available,
+    is_tokenizers_available,
+    is_torch_available,
+)
+
+
+_import_structure = {
+    "configuration_t5": ["T5_PRETRAINED_CONFIG_ARCHIVE_MAP", "T5Config"],
+}
 
 if is_sentencepiece_available():
-    from .tokenization_t5 import T5Tokenizer
+    _import_structure["tokenization_t5"] = ["T5Tokenizer"]
 
 if is_tokenizers_available():
-    from .tokenization_t5_fast import T5TokenizerFast
+    _import_structure["tokenization_t5_fast"] = ["T5TokenizerFast"]
 
 if is_torch_available():
-    from .modeling_t5 import (
-        T5_PRETRAINED_MODEL_ARCHIVE_LIST,
-        T5EncoderModel,
-        T5ForConditionalGeneration,
-        T5Model,
-        T5PreTrainedModel,
-        load_tf_weights_in_t5,
-    )
+    _import_structure["modeling_t5"] = [
+        "T5_PRETRAINED_MODEL_ARCHIVE_LIST",
+        "T5EncoderModel",
+        "T5ForConditionalGeneration",
+        "T5Model",
+        "T5PreTrainedModel",
+        "load_tf_weights_in_t5",
+    ]
 
 if is_tf_available():
-    from .modeling_tf_t5 import (
-        TF_T5_PRETRAINED_MODEL_ARCHIVE_LIST,
-        TFT5EncoderModel,
-        TFT5ForConditionalGeneration,
-        TFT5Model,
-        TFT5PreTrainedModel,
-    )
+    _import_structure["modeling_tf_t5"] = [
+        "TF_T5_PRETRAINED_MODEL_ARCHIVE_LIST",
+        "TFT5EncoderModel",
+        "TFT5ForConditionalGeneration",
+        "TFT5Model",
+        "TFT5PreTrainedModel",
+    ]
+
+
+if TYPE_CHECKING:
+    from .configuration_t5 import T5_PRETRAINED_CONFIG_ARCHIVE_MAP, T5Config
+
+    if is_sentencepiece_available():
+        from .tokenization_t5 import T5Tokenizer
+
+    if is_tokenizers_available():
+        from .tokenization_t5_fast import T5TokenizerFast
+
+    if is_torch_available():
+        from .modeling_t5 import (
+            T5_PRETRAINED_MODEL_ARCHIVE_LIST,
+            T5EncoderModel,
+            T5ForConditionalGeneration,
+            T5Model,
+            T5PreTrainedModel,
+            load_tf_weights_in_t5,
+        )
+
+    if is_tf_available():
+        from .modeling_tf_t5 import (
+            TF_T5_PRETRAINED_MODEL_ARCHIVE_LIST,
+            TFT5EncoderModel,
+            TFT5ForConditionalGeneration,
+            TFT5Model,
+            TFT5PreTrainedModel,
+        )
+
+else:
+    import importlib
+    import os
+    import sys
+
+    class _LazyModule(_BaseLazyModule):
+        """
+        Module class that surfaces all objects but only performs associated imports when the objects are requested.
+        """
+
+        __file__ = globals()["__file__"]
+        __path__ = [os.path.dirname(__file__)]
+
+        def _get_module(self, module_name: str):
+            return importlib.import_module("." + module_name, self.__name__)
+
+    sys.modules[__name__] = _LazyModule(__name__, _import_structure)

src/transformers/models/tapas/__init__.py

@@ -16,16 +16,53 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
-from ...file_utils import is_torch_available
-from .configuration_tapas import TAPAS_PRETRAINED_CONFIG_ARCHIVE_MAP, TapasConfig
-from .tokenization_tapas import TapasTokenizer
+from typing import TYPE_CHECKING
 
+from ...file_utils import _BaseLazyModule, is_torch_available
+
+
+_import_structure = {
+    "configuration_tapas": ["TAPAS_PRETRAINED_CONFIG_ARCHIVE_MAP", "TapasConfig"],
+    "tokenization_tapas": ["TapasTokenizer"],
+}
 
 if is_torch_available():
-    from .modeling_tapas import (
-        TAPAS_PRETRAINED_MODEL_ARCHIVE_LIST,
-        TapasForMaskedLM,
-        TapasForQuestionAnswering,
-        TapasForSequenceClassification,
-        TapasModel,
-    )
+    _import_structure["modeling_tapas"] = [
+        "TAPAS_PRETRAINED_MODEL_ARCHIVE_LIST",
+        "TapasForMaskedLM",
+        "TapasForQuestionAnswering",
+        "TapasForSequenceClassification",
+        "TapasModel",
+    ]
+
+
+if TYPE_CHECKING:
+    from .configuration_tapas import TAPAS_PRETRAINED_CONFIG_ARCHIVE_MAP, TapasConfig
+    from .tokenization_tapas import TapasTokenizer
+
+    if is_torch_available():
+        from .modeling_tapas import (
+            TAPAS_PRETRAINED_MODEL_ARCHIVE_LIST,
+            TapasForMaskedLM,
+            TapasForQuestionAnswering,
+            TapasForSequenceClassification,
+            TapasModel,
+        )
+
+else:
+    import importlib
+    import os
+    import sys
+
+    class _LazyModule(_BaseLazyModule):
+        """
+        Module class that surfaces all objects but only performs associated imports when the objects are requested.
+        """
+
+        __file__ = globals()["__file__"]
+        __path__ = [os.path.dirname(__file__)]
+
+        def _get_module(self, module_name: str):
+            return importlib.import_module("." + module_name, self.__name__)
+
+    sys.modules[__name__] = _LazyModule(__name__, _import_structure)

src/transformers/models/transfo_xl/__init__.py

@@ -16,29 +16,79 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
-from ...file_utils import is_tf_available, is_torch_available
-from .configuration_transfo_xl import TRANSFO_XL_PRETRAINED_CONFIG_ARCHIVE_MAP, TransfoXLConfig
-from .tokenization_transfo_xl import TransfoXLCorpus, TransfoXLTokenizer
+from typing import TYPE_CHECKING
 
+from ...file_utils import _BaseLazyModule, is_tf_available, is_torch_available
+
+
+_import_structure = {
+    "configuration_transfo_xl": ["TRANSFO_XL_PRETRAINED_CONFIG_ARCHIVE_MAP", "TransfoXLConfig"],
+    "tokenization_transfo_xl": ["TransfoXLCorpus", "TransfoXLTokenizer"],
+}
 
 if is_torch_available():
-    from .modeling_transfo_xl import (
-        TRANSFO_XL_PRETRAINED_MODEL_ARCHIVE_LIST,
-        AdaptiveEmbedding,
-        TransfoXLForSequenceClassification,
-        TransfoXLLMHeadModel,
-        TransfoXLModel,
-        TransfoXLPreTrainedModel,
-        load_tf_weights_in_transfo_xl,
-    )
+    _import_structure["modeling_transfo_xl"] = [
+        "TRANSFO_XL_PRETRAINED_MODEL_ARCHIVE_LIST",
+        "AdaptiveEmbedding",
+        "TransfoXLForSequenceClassification",
+        "TransfoXLLMHeadModel",
+        "TransfoXLModel",
+        "TransfoXLPreTrainedModel",
+        "load_tf_weights_in_transfo_xl",
+    ]
 
 if is_tf_available():
-    from .modeling_tf_transfo_xl import (
-        TF_TRANSFO_XL_PRETRAINED_MODEL_ARCHIVE_LIST,
-        TFAdaptiveEmbedding,
-        TFTransfoXLForSequenceClassification,
-        TFTransfoXLLMHeadModel,
-        TFTransfoXLMainLayer,
-        TFTransfoXLModel,
-        TFTransfoXLPreTrainedModel,
-    )
+    _import_structure["modeling_tf_transfo_xl"] = [
+        "TF_TRANSFO_XL_PRETRAINED_MODEL_ARCHIVE_LIST",
+        "TFAdaptiveEmbedding",
+        "TFTransfoXLForSequenceClassification",
+        "TFTransfoXLLMHeadModel",
+        "TFTransfoXLMainLayer",
+        "TFTransfoXLModel",
+        "TFTransfoXLPreTrainedModel",
+    ]
+
+
+if TYPE_CHECKING:
+    from .configuration_transfo_xl import TRANSFO_XL_PRETRAINED_CONFIG_ARCHIVE_MAP, TransfoXLConfig
+    from .tokenization_transfo_xl import TransfoXLCorpus, TransfoXLTokenizer
+
+    if is_torch_available():
+        from .modeling_transfo_xl import (
+            TRANSFO_XL_PRETRAINED_MODEL_ARCHIVE_LIST,
+            AdaptiveEmbedding,
+            TransfoXLForSequenceClassification,
+            TransfoXLLMHeadModel,
+            TransfoXLModel,
+            TransfoXLPreTrainedModel,
+            load_tf_weights_in_transfo_xl,
+        )
+
+    if is_tf_available():
+        from .modeling_tf_transfo_xl import (
+            TF_TRANSFO_XL_PRETRAINED_MODEL_ARCHIVE_LIST,
+            TFAdaptiveEmbedding,
+            TFTransfoXLForSequenceClassification,
+            TFTransfoXLLMHeadModel,
+            TFTransfoXLMainLayer,
+            TFTransfoXLModel,
+            TFTransfoXLPreTrainedModel,
+        )
+
+else:
+    import importlib
+    import os
+    import sys
+
+    class _LazyModule(_BaseLazyModule):
+        """
+        Module class that surfaces all objects but only performs associated imports when the objects are requested.
+        """
+
+        __file__ = globals()["__file__"]
+        __path__ = [os.path.dirname(__file__)]
+
+        def _get_module(self, module_name: str):
+            return importlib.import_module("." + module_name, self.__name__)
+
+    sys.modules[__name__] = _LazyModule(__name__, _import_structure)

src/transformers/models/xlm/__init__.py

@@ -16,33 +16,87 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
-from ...file_utils import is_tf_available, is_torch_available
-from .configuration_xlm import XLM_PRETRAINED_CONFIG_ARCHIVE_MAP, XLMConfig
-from .tokenization_xlm import XLMTokenizer
+from typing import TYPE_CHECKING
 
+from ...file_utils import _BaseLazyModule, is_tf_available, is_torch_available
+
+
+_import_structure = {
+    "configuration_xlm": ["XLM_PRETRAINED_CONFIG_ARCHIVE_MAP", "XLMConfig"],
+    "tokenization_xlm": ["XLMTokenizer"],
+}
 
 if is_torch_available():
-    from .modeling_xlm import (
-        XLM_PRETRAINED_MODEL_ARCHIVE_LIST,
-        XLMForMultipleChoice,
-        XLMForQuestionAnswering,
-        XLMForQuestionAnsweringSimple,
-        XLMForSequenceClassification,
-        XLMForTokenClassification,
-        XLMModel,
-        XLMPreTrainedModel,
-        XLMWithLMHeadModel,
-    )
+    _import_structure["modeling_xlm"] = [
+        "XLM_PRETRAINED_MODEL_ARCHIVE_LIST",
+        "XLMForMultipleChoice",
+        "XLMForQuestionAnswering",
+        "XLMForQuestionAnsweringSimple",
+        "XLMForSequenceClassification",
+        "XLMForTokenClassification",
+        "XLMModel",
+        "XLMPreTrainedModel",
+        "XLMWithLMHeadModel",
+    ]
 
 if is_tf_available():
-    from .modeling_tf_xlm import (
-        TF_XLM_PRETRAINED_MODEL_ARCHIVE_LIST,
-        TFXLMForMultipleChoice,
-        TFXLMForQuestionAnsweringSimple,
-        TFXLMForSequenceClassification,
-        TFXLMForTokenClassification,
-        TFXLMMainLayer,
-        TFXLMModel,
-        TFXLMPreTrainedModel,
-        TFXLMWithLMHeadModel,
-    )
+    _import_structure["modeling_tf_xlm"] = [
+        "TF_XLM_PRETRAINED_MODEL_ARCHIVE_LIST",
+        "TFXLMForMultipleChoice",
+        "TFXLMForQuestionAnsweringSimple",
+        "TFXLMForSequenceClassification",
+        "TFXLMForTokenClassification",
+        "TFXLMMainLayer",
+        "TFXLMModel",
+        "TFXLMPreTrainedModel",
+        "TFXLMWithLMHeadModel",
+    ]
+
+
+if TYPE_CHECKING:
+    from .configuration_xlm import XLM_PRETRAINED_CONFIG_ARCHIVE_MAP, XLMConfig
+    from .tokenization_xlm import XLMTokenizer
+
+    if is_torch_available():
+        from .modeling_xlm import (
+            XLM_PRETRAINED_MODEL_ARCHIVE_LIST,
+            XLMForMultipleChoice,
+            XLMForQuestionAnswering,
+            XLMForQuestionAnsweringSimple,
+            XLMForSequenceClassification,
+            XLMForTokenClassification,
+            XLMModel,
+            XLMPreTrainedModel,
+            XLMWithLMHeadModel,
+        )
+
+    if is_tf_available():
+        from .modeling_tf_xlm import (
+            TF_XLM_PRETRAINED_MODEL_ARCHIVE_LIST,
+            TFXLMForMultipleChoice,
+            TFXLMForQuestionAnsweringSimple,
+            TFXLMForSequenceClassification,
+            TFXLMForTokenClassification,
+            TFXLMMainLayer,
+            TFXLMModel,
+            TFXLMPreTrainedModel,
+            TFXLMWithLMHeadModel,
+        )
+
+else:
+    import importlib
+    import os
+    import sys
+
+    class _LazyModule(_BaseLazyModule):
+        """
+        Module class that surfaces all objects but only performs associated imports when the objects are requested.
+        """
+
+        __file__ = globals()["__file__"]
+        __path__ = [os.path.dirname(__file__)]
+
+        def _get_module(self, module_name: str):
+            return importlib.import_module("." + module_name, self.__name__)
+
+    sys.modules[__name__] = _LazyModule(__name__, _import_structure)

src/transformers/models/xlm_roberta/__init__.py

@@ -16,35 +16,97 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
-from ...file_utils import is_sentencepiece_available, is_tf_available, is_tokenizers_available, is_torch_available
-from .configuration_xlm_roberta import XLM_ROBERTA_PRETRAINED_CONFIG_ARCHIVE_MAP, XLMRobertaConfig
+from typing import TYPE_CHECKING
 
+from ...file_utils import (
+    _BaseLazyModule,
+    is_sentencepiece_available,
+    is_tf_available,
+    is_tokenizers_available,
+    is_torch_available,
+)
+
+
+_import_structure = {
+    "configuration_xlm_roberta": ["XLM_ROBERTA_PRETRAINED_CONFIG_ARCHIVE_MAP", "XLMRobertaConfig"],
+}
 
 if is_sentencepiece_available():
-    from .tokenization_xlm_roberta import XLMRobertaTokenizer
+    _import_structure["tokenization_xlm_roberta"] = ["XLMRobertaTokenizer"]
 
 if is_tokenizers_available():
-    from .tokenization_xlm_roberta_fast import XLMRobertaTokenizerFast
+    _import_structure["tokenization_xlm_roberta_fast"] = ["XLMRobertaTokenizerFast"]
 
 if is_torch_available():
-    from .modeling_xlm_roberta import (
-        XLM_ROBERTA_PRETRAINED_MODEL_ARCHIVE_LIST,
-        XLMRobertaForCausalLM,
-        XLMRobertaForMaskedLM,
-        XLMRobertaForMultipleChoice,
-        XLMRobertaForQuestionAnswering,
-        XLMRobertaForSequenceClassification,
-        XLMRobertaForTokenClassification,
-        XLMRobertaModel,
-    )
+    _import_structure["modeling_xlm_roberta"] = [
+        "XLM_ROBERTA_PRETRAINED_MODEL_ARCHIVE_LIST",
+        "XLMRobertaForCausalLM",
+        "XLMRobertaForMaskedLM",
+        "XLMRobertaForMultipleChoice",
+        "XLMRobertaForQuestionAnswering",
+        "XLMRobertaForSequenceClassification",
+        "XLMRobertaForTokenClassification",
+        "XLMRobertaModel",
+    ]
 
 if is_tf_available():
-    from .modeling_tf_xlm_roberta import (
-        TF_XLM_ROBERTA_PRETRAINED_MODEL_ARCHIVE_LIST,
-        TFXLMRobertaForMaskedLM,
-        TFXLMRobertaForMultipleChoice,
-        TFXLMRobertaForQuestionAnswering,
-        TFXLMRobertaForSequenceClassification,
-        TFXLMRobertaForTokenClassification,
-        TFXLMRobertaModel,
-    )
+    _import_structure["modeling_tf_xlm_roberta"] = [
+        "TF_XLM_ROBERTA_PRETRAINED_MODEL_ARCHIVE_LIST",
+        "TFXLMRobertaForMaskedLM",
+        "TFXLMRobertaForMultipleChoice",
+        "TFXLMRobertaForQuestionAnswering",
+        "TFXLMRobertaForSequenceClassification",
+        "TFXLMRobertaForTokenClassification",
+        "TFXLMRobertaModel",
+    ]
+
+
+if TYPE_CHECKING:
+    from .configuration_xlm_roberta import XLM_ROBERTA_PRETRAINED_CONFIG_ARCHIVE_MAP, XLMRobertaConfig
+
+    if is_sentencepiece_available():
+        from .tokenization_xlm_roberta import XLMRobertaTokenizer
+
+    if is_tokenizers_available():
+        from .tokenization_xlm_roberta_fast import XLMRobertaTokenizerFast
+
+    if is_torch_available():
+        from .modeling_xlm_roberta import (
+            XLM_ROBERTA_PRETRAINED_MODEL_ARCHIVE_LIST,
+            XLMRobertaForCausalLM,
+            XLMRobertaForMaskedLM,
+            XLMRobertaForMultipleChoice,
+            XLMRobertaForQuestionAnswering,
+            XLMRobertaForSequenceClassification,
+            XLMRobertaForTokenClassification,
+            XLMRobertaModel,
+        )
+
+    if is_tf_available():
+        from .modeling_tf_xlm_roberta import (
+            TF_XLM_ROBERTA_PRETRAINED_MODEL_ARCHIVE_LIST,
+            TFXLMRobertaForMaskedLM,
+            TFXLMRobertaForMultipleChoice,
+            TFXLMRobertaForQuestionAnswering,
+            TFXLMRobertaForSequenceClassification,
+            TFXLMRobertaForTokenClassification,
+            TFXLMRobertaModel,
+        )
+
+else:
+    import importlib
+    import os
+    import sys
+
+    class _LazyModule(_BaseLazyModule):
+        """
+        Module class that surfaces all objects but only performs associated imports when the objects are requested.
+        """
+
+        __file__ = globals()["__file__"]
+        __path__ = [os.path.dirname(__file__)]
+
+        def _get_module(self, module_name: str):
+            return importlib.import_module("." + module_name, self.__name__)
+
+    sys.modules[__name__] = _LazyModule(__name__, _import_structure)

src/transformers/models/xlnet/__init__.py

@@ -16,39 +16,105 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
-from ...file_utils import is_sentencepiece_available, is_tf_available, is_tokenizers_available, is_torch_available
-from .configuration_xlnet import XLNET_PRETRAINED_CONFIG_ARCHIVE_MAP, XLNetConfig
+from typing import TYPE_CHECKING
 
+from ...file_utils import (
+    _BaseLazyModule,
+    is_sentencepiece_available,
+    is_tf_available,
+    is_tokenizers_available,
+    is_torch_available,
+)
+
+
+_import_structure = {
+    "configuration_xlnet": ["XLNET_PRETRAINED_CONFIG_ARCHIVE_MAP", "XLNetConfig"],
+}
 
 if is_sentencepiece_available():
-    from .tokenization_xlnet import XLNetTokenizer
+    _import_structure["tokenization_xlnet"] = ["XLNetTokenizer"]
 
 if is_tokenizers_available():
-    from .tokenization_xlnet_fast import XLNetTokenizerFast
+    _import_structure["tokenization_xlnet_fast"] = ["XLNetTokenizerFast"]
 
 if is_torch_available():
-    from .modeling_xlnet import (
-        XLNET_PRETRAINED_MODEL_ARCHIVE_LIST,
-        XLNetForMultipleChoice,
-        XLNetForQuestionAnswering,
-        XLNetForQuestionAnsweringSimple,
-        XLNetForSequenceClassification,
-        XLNetForTokenClassification,
-        XLNetLMHeadModel,
-        XLNetModel,
-        XLNetPreTrainedModel,
-        load_tf_weights_in_xlnet,
-    )
+    _import_structure["modeling_xlnet"] = [
+        "XLNET_PRETRAINED_MODEL_ARCHIVE_LIST",
+        "XLNetForMultipleChoice",
+        "XLNetForQuestionAnswering",
+        "XLNetForQuestionAnsweringSimple",
+        "XLNetForSequenceClassification",
+        "XLNetForTokenClassification",
+        "XLNetLMHeadModel",
+        "XLNetModel",
+        "XLNetPreTrainedModel",
+        "load_tf_weights_in_xlnet",
+    ]
 
 if is_tf_available():
-    from .modeling_tf_xlnet import (
-        TF_XLNET_PRETRAINED_MODEL_ARCHIVE_LIST,
-        TFXLNetForMultipleChoice,
-        TFXLNetForQuestionAnsweringSimple,
-        TFXLNetForSequenceClassification,
-        TFXLNetForTokenClassification,
-        TFXLNetLMHeadModel,
-        TFXLNetMainLayer,
-        TFXLNetModel,
-        TFXLNetPreTrainedModel,
-    )
+    _import_structure["modeling_tf_xlnet"] = [
+        "TF_XLNET_PRETRAINED_MODEL_ARCHIVE_LIST",
+        "TFXLNetForMultipleChoice",
+        "TFXLNetForQuestionAnsweringSimple",
+        "TFXLNetForSequenceClassification",
+        "TFXLNetForTokenClassification",
+        "TFXLNetLMHeadModel",
+        "TFXLNetMainLayer",
+        "TFXLNetModel",
+        "TFXLNetPreTrainedModel",
+    ]
+
+
+if TYPE_CHECKING:
+    from .configuration_xlnet import XLNET_PRETRAINED_CONFIG_ARCHIVE_MAP, XLNetConfig
+
+    if is_sentencepiece_available():
+        from .tokenization_xlnet import XLNetTokenizer
+
+    if is_tokenizers_available():
+        from .tokenization_xlnet_fast import XLNetTokenizerFast
+
+    if is_torch_available():
+        from .modeling_xlnet import (
+            XLNET_PRETRAINED_MODEL_ARCHIVE_LIST,
+            XLNetForMultipleChoice,
+            XLNetForQuestionAnswering,
+            XLNetForQuestionAnsweringSimple,
+            XLNetForSequenceClassification,
+            XLNetForTokenClassification,
+            XLNetLMHeadModel,
+            XLNetModel,
+            XLNetPreTrainedModel,
+            load_tf_weights_in_xlnet,
+        )
+
+    if is_tf_available():
+        from .modeling_tf_xlnet import (
+            TF_XLNET_PRETRAINED_MODEL_ARCHIVE_LIST,
+            TFXLNetForMultipleChoice,
+            TFXLNetForQuestionAnsweringSimple,
+            TFXLNetForSequenceClassification,
+            TFXLNetForTokenClassification,
+            TFXLNetLMHeadModel,
+            TFXLNetMainLayer,
+            TFXLNetModel,
+            TFXLNetPreTrainedModel,
+        )
+
+else:
+    import importlib
+    import os
+    import sys
+
+    class _LazyModule(_BaseLazyModule):
+        """
+        Module class that surfaces all objects but only performs associated imports when the objects are requested.
+        """
+
+        __file__ = globals()["__file__"]
+        __path__ = [os.path.dirname(__file__)]
+
+        def _get_module(self, module_name: str):
+            return importlib.import_module("." + module_name, self.__name__)
+
+    sys.modules[__name__] = _LazyModule(__name__, _import_structure)

src/transformers/tokenization_utils_base.py

@@ -25,7 +25,7 @@ import warnings
 from collections import OrderedDict, UserDict
 from dataclasses import dataclass, field
 from enum import Enum
-from typing import Any, Dict, List, NamedTuple, Optional, Sequence, Tuple, Union
+from typing import TYPE_CHECKING, Any, Dict, List, NamedTuple, Optional, Sequence, Tuple, Union
 
 import numpy as np
 
@@ -45,21 +45,34 @@ from .file_utils import (
 from .utils import logging
 
 
-if is_tf_available():
-    import tensorflow as tf
+if TYPE_CHECKING:
+    if is_torch_available():
+        import torch
+    if is_tf_available():
+        import tensorflow as tf
+    if is_flax_available():
+        import jax.numpy as jnp  # noqa: F401
+
 
-if is_torch_available():
+def _is_numpy(x):
+    return isinstance(x, np.ndarray)
+
+
+def _is_torch(x):
     import torch
 
-if is_flax_available():
-    import jax.numpy as jnp
+    return isinstance(x, torch.Tensor)
 
 
-def _is_numpy(x):
-    return isinstance(x, np.ndarray)
+def _is_tensorflow(x):
+    import tensorflow as tf
+
+    return isinstance(x, tf.Tensor)
 
 
 def _is_jax(x):
+    import jax.numpy as jnp  # noqa: F811
+
     return isinstance(x, jnp.ndarray)
 
 
@@ -196,9 +209,9 @@ def to_py_obj(obj):
         return {k: to_py_obj(v) for k, v in obj.items()}
     elif isinstance(obj, (list, tuple)):
         return [to_py_obj(o) for o in obj]
-    elif is_tf_available() and isinstance(obj, tf.Tensor):
+    elif is_tf_available() and _is_tensorflow(obj):
         return obj.numpy().tolist()
-    elif is_torch_available() and isinstance(obj, torch.Tensor):
+    elif is_torch_available() and _is_torch(obj):
         return obj.detach().cpu().tolist()
     elif isinstance(obj, np.ndarray):
         return obj.tolist()
@@ -714,16 +727,22 @@ class BatchEncoding(UserDict):
                 raise ImportError(
                     "Unable to convert output to TensorFlow tensors format, TensorFlow is not installed."
                 )
+            import tensorflow as tf
+
             as_tensor = tf.constant
             is_tensor = tf.is_tensor
         elif tensor_type == TensorType.PYTORCH:
             if not is_torch_available():
                 raise ImportError("Unable to convert output to PyTorch tensors format, PyTorch is not installed.")
+            import torch
+
             as_tensor = torch.tensor
             is_tensor = torch.is_tensor
         elif tensor_type == TensorType.JAX:
             if not is_flax_available():
                 raise ImportError("Unable to convert output to JAX tensors format, JAX is not installed.")
+            import jax.numpy as jnp  # noqa: F811
+
             as_tensor = jnp.array
             is_tensor = _is_jax
         else:
@@ -2684,9 +2703,9 @@ class PreTrainedTokenizerBase(SpecialTokensMixin):
                 first_element = encoded_inputs["input_ids"][index][0]
         # At this state, if `first_element` is still a list/tuple, it's an empty one so there is nothing to do.
         if not isinstance(first_element, (int, list, tuple)):
-            if is_tf_available() and isinstance(first_element, tf.Tensor):
+            if is_tf_available() and _is_tensorflow(first_element):
                 return_tensors = "tf" if return_tensors is None else return_tensors
-            elif is_torch_available() and isinstance(first_element, torch.Tensor):
+            elif is_torch_available() and _is_torch(first_element):
                 return_tensors = "pt" if return_tensors is None else return_tensors
             elif isinstance(first_element, np.ndarray):
                 return_tensors = "np" if return_tensors is None else return_tensors

templates/adding_a_new_model/cookiecutter-template-{{cookiecutter.modelname}}/__init__.py

@@ -15,69 +15,150 @@
 # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 # See the License for the specific language governing permissions and
 # limitations under the License.
+from typing import TYPE_CHECKING
 
 {%- if cookiecutter.generate_tensorflow_and_pytorch == "PyTorch & TensorFlow" %}
-from ...file_utils import is_tf_available, is_torch_available, is_tokenizers_available
+from ...file_utils import _BaseLazyModule, is_tf_available, is_torch_available, is_tokenizers_available
 {%- elif cookiecutter.generate_tensorflow_and_pytorch == "PyTorch" %}
-from ...file_utils import is_torch_available, is_tokenizers_available
+from ...file_utils import _BaseLazyModule, is_torch_available, is_tokenizers_available
 {%- elif cookiecutter.generate_tensorflow_and_pytorch == "TensorFlow" %}
-from ...file_utils import is_tf_available, is_tokenizers_available
+from ...file_utils import _BaseLazyModule, is_tf_available, is_tokenizers_available
 {% endif %}
-from .configuration_{{cookiecutter.lowercase_modelname}} import {{cookiecutter.uppercase_modelname}}_PRETRAINED_CONFIG_ARCHIVE_MAP, {{cookiecutter.camelcase_modelname}}Config
-from .tokenization_{{cookiecutter.lowercase_modelname}} import {{cookiecutter.camelcase_modelname}}Tokenizer
+_import_structure = {
+    "configuration_{{cookiecutter.lowercase_modelname}}": ["{{cookiecutter.uppercase_modelname}}_PRETRAINED_CONFIG_ARCHIVE_MAP", "{{cookiecutter.camelcase_modelname}}Config"],
+    "tokenization_{{cookiecutter.lowercase_modelname}}": ["{{cookiecutter.camelcase_modelname}}Tokenizer"],
+}
 
 if is_tokenizers_available():
-    from .tokenization_{{cookiecutter.lowercase_modelname}}_fast import {{cookiecutter.camelcase_modelname}}TokenizerFast
+    _import_structure["tokenization_{{cookiecutter.lowercase_modelname}}_fast"] = ["{{cookiecutter.camelcase_modelname}}TokenizerFast"]
 
 {%- if (cookiecutter.generate_tensorflow_and_pytorch == "PyTorch & TensorFlow" or cookiecutter.generate_tensorflow_and_pytorch == "PyTorch") %}
 {% if cookiecutter.is_encoder_decoder_model == "False" %}
 if is_torch_available():
-    from .modeling_{{cookiecutter.lowercase_modelname}} import (
-        {{cookiecutter.uppercase_modelname}}_PRETRAINED_MODEL_ARCHIVE_LIST,
-        {{cookiecutter.camelcase_modelname}}ForMaskedLM,
-        {{cookiecutter.camelcase_modelname}}ForCausalLM,
-        {{cookiecutter.camelcase_modelname}}ForMultipleChoice,
-        {{cookiecutter.camelcase_modelname}}ForQuestionAnswering,
-        {{cookiecutter.camelcase_modelname}}ForSequenceClassification,
-        {{cookiecutter.camelcase_modelname}}ForTokenClassification,
-        {{cookiecutter.camelcase_modelname}}Layer,
-        {{cookiecutter.camelcase_modelname}}Model,
-        {{cookiecutter.camelcase_modelname}}PreTrainedModel,
-        load_tf_weights_in_{{cookiecutter.lowercase_modelname}},
-    )
+    _import_structure["modeling_{{cookiecutter.lowercase_modelname}}"] = [
+        "{{cookiecutter.uppercase_modelname}}_PRETRAINED_MODEL_ARCHIVE_LIST",
+        "{{cookiecutter.camelcase_modelname}}ForMaskedLM",
+        "{{cookiecutter.camelcase_modelname}}ForCausalLM",
+        "{{cookiecutter.camelcase_modelname}}ForMultipleChoice",
+        "{{cookiecutter.camelcase_modelname}}ForQuestionAnswering",
+        "{{cookiecutter.camelcase_modelname}}ForSequenceClassification",
+        "{{cookiecutter.camelcase_modelname}}ForTokenClassification",
+        "{{cookiecutter.camelcase_modelname}}Layer",
+        "{{cookiecutter.camelcase_modelname}}Model",
+        "{{cookiecutter.camelcase_modelname}}PreTrainedModel",
+        "load_tf_weights_in_{{cookiecutter.lowercase_modelname}}",
+    ]
 {% else %}
 if is_torch_available():
-    from .modeling_{{cookiecutter.lowercase_modelname}} import (
-        {{cookiecutter.uppercase_modelname}}_PRETRAINED_MODEL_ARCHIVE_LIST,
-        {{cookiecutter.camelcase_modelname}}ForConditionalGeneration,
-        {{cookiecutter.camelcase_modelname}}ForQuestionAnswering,
-        {{cookiecutter.camelcase_modelname}}ForSequenceClassification,
-        {{cookiecutter.camelcase_modelname}}Model,
-        {{cookiecutter.camelcase_modelname}}PreTrainedModel,
-    )
+    _import_structure["modeling_{{cookiecutter.lowercase_modelname}}"] = [
+        "{{cookiecutter.uppercase_modelname}}_PRETRAINED_MODEL_ARCHIVE_LIST",
+        "{{cookiecutter.camelcase_modelname}}ForConditionalGeneration",
+        "{{cookiecutter.camelcase_modelname}}ForQuestionAnswering",
+        "{{cookiecutter.camelcase_modelname}}ForSequenceClassification",
+        "{{cookiecutter.camelcase_modelname}}Model",
+        "{{cookiecutter.camelcase_modelname}}PreTrainedModel",
+    ]
 {% endif %}
 {% endif %}
 {%- if (cookiecutter.generate_tensorflow_and_pytorch == "PyTorch & TensorFlow" or cookiecutter.generate_tensorflow_and_pytorch == "TensorFlow") %}
 {% if cookiecutter.is_encoder_decoder_model == "False" %}
 if is_tf_available():
-    from .modeling_tf_{{cookiecutter.lowercase_modelname}} import (
-        TF_{{cookiecutter.uppercase_modelname}}_PRETRAINED_MODEL_ARCHIVE_LIST,
-        TF{{cookiecutter.camelcase_modelname}}ForMaskedLM,
-        TF{{cookiecutter.camelcase_modelname}}ForCausalLM,
-        TF{{cookiecutter.camelcase_modelname}}ForMultipleChoice,
-        TF{{cookiecutter.camelcase_modelname}}ForQuestionAnswering,
-        TF{{cookiecutter.camelcase_modelname}}ForSequenceClassification,
-        TF{{cookiecutter.camelcase_modelname}}ForTokenClassification,
-        TF{{cookiecutter.camelcase_modelname}}Layer,
-        TF{{cookiecutter.camelcase_modelname}}Model,
-        TF{{cookiecutter.camelcase_modelname}}PreTrainedModel,
-    )
+    _import_structure["modeling_tf_{{cookiecutter.lowercase_modelname}}"] = [
+        "TF_{{cookiecutter.uppercase_modelname}}_PRETRAINED_MODEL_ARCHIVE_LIST",
+        "TF{{cookiecutter.camelcase_modelname}}ForMaskedLM",
+        "TF{{cookiecutter.camelcase_modelname}}ForCausalLM",
+        "TF{{cookiecutter.camelcase_modelname}}ForMultipleChoice",
+        "TF{{cookiecutter.camelcase_modelname}}ForQuestionAnswering",
+        "TF{{cookiecutter.camelcase_modelname}}ForSequenceClassification",
+        "TF{{cookiecutter.camelcase_modelname}}ForTokenClassification",
+        "TF{{cookiecutter.camelcase_modelname}}Layer",
+        "TF{{cookiecutter.camelcase_modelname}}Model",
+        "TF{{cookiecutter.camelcase_modelname}}PreTrainedModel",
+    ]
 {% else %}
 if is_tf_available():
-    from .modeling_tf_{{cookiecutter.lowercase_modelname}} import (
-        TF{{cookiecutter.camelcase_modelname}}ForConditionalGeneration,
-        TF{{cookiecutter.camelcase_modelname}}Model,
-        TF{{cookiecutter.camelcase_modelname}}PreTrainedModel,
-    )
+    _import_structure["modeling_tf_{{cookiecutter.lowercase_modelname}}"] = [
+        "TF{{cookiecutter.camelcase_modelname}}ForConditionalGeneration",
+        "TF{{cookiecutter.camelcase_modelname}}Model",
+        "TF{{cookiecutter.camelcase_modelname}}PreTrainedModel",
+    ]
 {% endif %}
 {% endif %}
+
+
+if TYPE_CHECKING:
+    from .configuration_{{cookiecutter.lowercase_modelname}} import {{cookiecutter.uppercase_modelname}}_PRETRAINED_CONFIG_ARCHIVE_MAP, {{cookiecutter.camelcase_modelname}}Config
+    from .tokenization_{{cookiecutter.lowercase_modelname}} import {{cookiecutter.camelcase_modelname}}Tokenizer
+
+    if is_tokenizers_available():
+        from .tokenization_{{cookiecutter.lowercase_modelname}}_fast import {{cookiecutter.camelcase_modelname}}TokenizerFast
+
+{%- if (cookiecutter.generate_tensorflow_and_pytorch == "PyTorch & TensorFlow" or cookiecutter.generate_tensorflow_and_pytorch == "PyTorch") %}
+{% if cookiecutter.is_encoder_decoder_model == "False" %}
+    if is_torch_available():
+        from .modeling_{{cookiecutter.lowercase_modelname}} import (
+            {{cookiecutter.uppercase_modelname}}_PRETRAINED_MODEL_ARCHIVE_LIST,
+            {{cookiecutter.camelcase_modelname}}ForMaskedLM,
+            {{cookiecutter.camelcase_modelname}}ForCausalLM,
+            {{cookiecutter.camelcase_modelname}}ForMultipleChoice,
+            {{cookiecutter.camelcase_modelname}}ForQuestionAnswering,
+            {{cookiecutter.camelcase_modelname}}ForSequenceClassification,
+            {{cookiecutter.camelcase_modelname}}ForTokenClassification,
+            {{cookiecutter.camelcase_modelname}}Layer,
+            {{cookiecutter.camelcase_modelname}}Model,
+            {{cookiecutter.camelcase_modelname}}PreTrainedModel,
+            load_tf_weights_in_{{cookiecutter.lowercase_modelname}},
+        )
+{% else %}
+    if is_torch_available():
+        from .modeling_{{cookiecutter.lowercase_modelname}} import (
+            {{cookiecutter.uppercase_modelname}}_PRETRAINED_MODEL_ARCHIVE_LIST,
+            {{cookiecutter.camelcase_modelname}}ForConditionalGeneration,
+            {{cookiecutter.camelcase_modelname}}ForQuestionAnswering,
+            {{cookiecutter.camelcase_modelname}}ForSequenceClassification,
+            {{cookiecutter.camelcase_modelname}}Model,
+            {{cookiecutter.camelcase_modelname}}PreTrainedModel,
+        )
+{% endif %}
+{% endif %}
+{%- if (cookiecutter.generate_tensorflow_and_pytorch == "PyTorch & TensorFlow" or cookiecutter.generate_tensorflow_and_pytorch == "TensorFlow") %}
+{% if cookiecutter.is_encoder_decoder_model == "False" %}
+    if is_tf_available():
+        from .modeling_tf_{{cookiecutter.lowercase_modelname}} import (
+            TF_{{cookiecutter.uppercase_modelname}}_PRETRAINED_MODEL_ARCHIVE_LIST,
+            TF{{cookiecutter.camelcase_modelname}}ForMaskedLM,
+            TF{{cookiecutter.camelcase_modelname}}ForCausalLM,
+            TF{{cookiecutter.camelcase_modelname}}ForMultipleChoice,
+            TF{{cookiecutter.camelcase_modelname}}ForQuestionAnswering,
+            TF{{cookiecutter.camelcase_modelname}}ForSequenceClassification,
+            TF{{cookiecutter.camelcase_modelname}}ForTokenClassification,
+            TF{{cookiecutter.camelcase_modelname}}Layer,
+            TF{{cookiecutter.camelcase_modelname}}Model,
+            TF{{cookiecutter.camelcase_modelname}}PreTrainedModel,
+        )
+{% else %}
+    if is_tf_available():
+        from .modeling_tf_{{cookiecutter.lowercase_modelname}} import (
+            TF{{cookiecutter.camelcase_modelname}}ForConditionalGeneration,
+            TF{{cookiecutter.camelcase_modelname}}Model,
+            TF{{cookiecutter.camelcase_modelname}}PreTrainedModel,
+        )
+{% endif %}
+{% endif %}
+else:
+    import importlib
+    import os
+    import sys
+
+    class _LazyModule(_BaseLazyModule):
+        """
+        Module class that surfaces all objects but only performs associated imports when the objects are requested.
+        """
+
+        __file__ = globals()["__file__"]
+        __path__ = [os.path.dirname(__file__)]
+
+        def _get_module(self, module_name: str):
+            return importlib.import_module("." + module_name, self.__name__)
+
+    sys.modules[__name__] = _LazyModule(__name__, _import_structure)