'''simple docstring'''

import argparse
import json
import pickle
from pathlib import Path

import requests
import torch
from huggingface_hub import hf_hub_download
from PIL import Image

from transformers import MaskFormerConfig, MaskFormerForInstanceSegmentation, MaskFormerImageProcessor, SwinConfig
from transformers.utils import logging


logging.set_verbosity_info()
__a: Union[str, Any]          =   logging.get_logger(__name__)
def 			__UpperCamelCase       (   UpperCAmelCase     ):
 lowercase__				:    List[Any]  =					SwinConfig.from_pretrained(
     '''microsoft/swin-tiny-patch4-window7-224'''		,     out_features=['''stage1''', '''stage2''', '''stage3''', '''stage4''']     )
 lowercase__				:    Union[str, Any]  =					MaskFormerConfig(backbone_config=UpperCAmelCase     )

 lowercase__				:    List[Any]  =					'''huggingface/label-files'''
 if "ade20k-full" in model_name:
  # this should be ok
  lowercase__				:    List[str]  =					847
  lowercase__				:    Optional[int]  =					'''maskformer-ade20k-full-id2label.json'''
 elif "ade" in model_name:
  # this should be ok
  lowercase__				:    Dict  =					150
  lowercase__				:    List[str]  =					'''ade20k-id2label.json'''
 elif "coco-stuff" in model_name:
  # this should be ok
  lowercase__				:    Optional[int]  =					171
  lowercase__				:    Optional[Any]  =					'''maskformer-coco-stuff-id2label.json'''
 elif "coco" in model_name:
  # TODO
  lowercase__				:    List[Any]  =					133
  lowercase__				:    Dict  =					'''coco-panoptic-id2label.json'''
 elif "cityscapes" in model_name:
  # this should be ok
  lowercase__				:    Tuple  =					19
  lowercase__				:    List[Any]  =					'''cityscapes-id2label.json'''
 elif "vistas" in model_name:
  # this should be ok
  lowercase__				:    Dict  =					65
  lowercase__				:    Any  =					'''mapillary-vistas-id2label.json'''

 lowercase__				:    List[str]  =					json.load(open(hf_hub_download(UpperCAmelCase		,     UpperCAmelCase		,     repo_type='''dataset'''     )		,     '''r'''     )     )
 lowercase__				:    Optional[Any]  =					{int(UpperCAmelCase     ): v for k, v in idalabel.items()}

 return config
def 			__UpperCamelCase       (   UpperCAmelCase     ):
 lowercase__				:    List[str]  =					[]
 # stem
 # fmt: off
 rename_keys.append(('''backbone.patch_embed.proj.weight''', '''model.pixel_level_module.encoder.model.embeddings.patch_embeddings.projection.weight''')     )
 rename_keys.append(('''backbone.patch_embed.proj.bias''', '''model.pixel_level_module.encoder.model.embeddings.patch_embeddings.projection.bias''')     )
 rename_keys.append(('''backbone.patch_embed.norm.weight''', '''model.pixel_level_module.encoder.model.embeddings.norm.weight''')     )
 rename_keys.append(('''backbone.patch_embed.norm.bias''', '''model.pixel_level_module.encoder.model.embeddings.norm.bias''')     )
 # stages
 for i in range(len(config.backbone_config.depths     )     ):
  for j in range(config.backbone_config.depths[i]     ):
   rename_keys.append((F"""backbone.layers.{i}.blocks.{j}.norm1.weight""", F"""model.pixel_level_module.encoder.model.encoder.layers.{i}.blocks.{j}.layernorm_before.weight""")     )
   rename_keys.append((F"""backbone.layers.{i}.blocks.{j}.norm1.bias""", F"""model.pixel_level_module.encoder.model.encoder.layers.{i}.blocks.{j}.layernorm_before.bias""")     )
   rename_keys.append((F"""backbone.layers.{i}.blocks.{j}.attn.relative_position_bias_table""", F"""model.pixel_level_module.encoder.model.encoder.layers.{i}.blocks.{j}.attention.self.relative_position_bias_table""")     )
   rename_keys.append((F"""backbone.layers.{i}.blocks.{j}.attn.relative_position_index""", F"""model.pixel_level_module.encoder.model.encoder.layers.{i}.blocks.{j}.attention.self.relative_position_index""")     )
   rename_keys.append((F"""backbone.layers.{i}.blocks.{j}.attn.proj.weight""", F"""model.pixel_level_module.encoder.model.encoder.layers.{i}.blocks.{j}.attention.output.dense.weight""")     )
   rename_keys.append((F"""backbone.layers.{i}.blocks.{j}.attn.proj.bias""", F"""model.pixel_level_module.encoder.model.encoder.layers.{i}.blocks.{j}.attention.output.dense.bias""")     )
   rename_keys.append((F"""backbone.layers.{i}.blocks.{j}.norm2.weight""", F"""model.pixel_level_module.encoder.model.encoder.layers.{i}.blocks.{j}.layernorm_after.weight""")     )
   rename_keys.append((F"""backbone.layers.{i}.blocks.{j}.norm2.bias""", F"""model.pixel_level_module.encoder.model.encoder.layers.{i}.blocks.{j}.layernorm_after.bias""")     )
   rename_keys.append((F"""backbone.layers.{i}.blocks.{j}.mlp.fc1.weight""", F"""model.pixel_level_module.encoder.model.encoder.layers.{i}.blocks.{j}.intermediate.dense.weight""")     )
   rename_keys.append((F"""backbone.layers.{i}.blocks.{j}.mlp.fc1.bias""", F"""model.pixel_level_module.encoder.model.encoder.layers.{i}.blocks.{j}.intermediate.dense.bias""")     )
   rename_keys.append((F"""backbone.layers.{i}.blocks.{j}.mlp.fc2.weight""", F"""model.pixel_level_module.encoder.model.encoder.layers.{i}.blocks.{j}.output.dense.weight""")     )
   rename_keys.append((F"""backbone.layers.{i}.blocks.{j}.mlp.fc2.bias""", F"""model.pixel_level_module.encoder.model.encoder.layers.{i}.blocks.{j}.output.dense.bias""")     )

  if i < 3:
   rename_keys.append((F"""backbone.layers.{i}.downsample.reduction.weight""", F"""model.pixel_level_module.encoder.model.encoder.layers.{i}.downsample.reduction.weight""")     )
   rename_keys.append((F"""backbone.layers.{i}.downsample.norm.weight""", F"""model.pixel_level_module.encoder.model.encoder.layers.{i}.downsample.norm.weight""")     )
   rename_keys.append((F"""backbone.layers.{i}.downsample.norm.bias""", F"""model.pixel_level_module.encoder.model.encoder.layers.{i}.downsample.norm.bias""")     )
  rename_keys.append((F"""backbone.norm{i}.weight""", F"""model.pixel_level_module.encoder.hidden_states_norms.{i}.weight""")     )
  rename_keys.append((F"""backbone.norm{i}.bias""", F"""model.pixel_level_module.encoder.hidden_states_norms.{i}.bias""")     )

 # FPN
 rename_keys.append(('''sem_seg_head.layer_4.weight''', '''model.pixel_level_module.decoder.fpn.stem.0.weight''')     )
 rename_keys.append(('''sem_seg_head.layer_4.norm.weight''', '''model.pixel_level_module.decoder.fpn.stem.1.weight''')     )
 rename_keys.append(('''sem_seg_head.layer_4.norm.bias''', '''model.pixel_level_module.decoder.fpn.stem.1.bias''')     )
 for source_index, target_index in zip(range(3		,     0		,     -1     )		,     range(0		,     3     )     ):
  rename_keys.append((F"""sem_seg_head.adapter_{source_index}.weight""", F"""model.pixel_level_module.decoder.fpn.layers.{target_index}.proj.0.weight""")     )
  rename_keys.append((F"""sem_seg_head.adapter_{source_index}.norm.weight""", F"""model.pixel_level_module.decoder.fpn.layers.{target_index}.proj.1.weight""")     )
  rename_keys.append((F"""sem_seg_head.adapter_{source_index}.norm.bias""", F"""model.pixel_level_module.decoder.fpn.layers.{target_index}.proj.1.bias""")     )
  rename_keys.append((F"""sem_seg_head.layer_{source_index}.weight""", F"""model.pixel_level_module.decoder.fpn.layers.{target_index}.block.0.weight""")     )
  rename_keys.append((F"""sem_seg_head.layer_{source_index}.norm.weight""", F"""model.pixel_level_module.decoder.fpn.layers.{target_index}.block.1.weight""")     )
  rename_keys.append((F"""sem_seg_head.layer_{source_index}.norm.bias""", F"""model.pixel_level_module.decoder.fpn.layers.{target_index}.block.1.bias""")     )
 rename_keys.append(('''sem_seg_head.mask_features.weight''', '''model.pixel_level_module.decoder.mask_projection.weight''')     )
 rename_keys.append(('''sem_seg_head.mask_features.bias''', '''model.pixel_level_module.decoder.mask_projection.bias''')     )

 # Transformer decoder
 for idx in range(config.decoder_config.decoder_layers     ):
  # self-attention out projection
  rename_keys.append((F"""sem_seg_head.predictor.transformer.decoder.layers.{idx}.self_attn.out_proj.weight""", F"""model.transformer_module.decoder.layers.{idx}.self_attn.out_proj.weight""")     )
  rename_keys.append((F"""sem_seg_head.predictor.transformer.decoder.layers.{idx}.self_attn.out_proj.bias""", F"""model.transformer_module.decoder.layers.{idx}.self_attn.out_proj.bias""")     )
  # cross-attention out projection
  rename_keys.append((F"""sem_seg_head.predictor.transformer.decoder.layers.{idx}.multihead_attn.out_proj.weight""", F"""model.transformer_module.decoder.layers.{idx}.encoder_attn.out_proj.weight""")     )
  rename_keys.append((F"""sem_seg_head.predictor.transformer.decoder.layers.{idx}.multihead_attn.out_proj.bias""", F"""model.transformer_module.decoder.layers.{idx}.encoder_attn.out_proj.bias""")     )
  # MLP 1
  rename_keys.append((F"""sem_seg_head.predictor.transformer.decoder.layers.{idx}.linear1.weight""", F"""model.transformer_module.decoder.layers.{idx}.fc1.weight""")     )
  rename_keys.append((F"""sem_seg_head.predictor.transformer.decoder.layers.{idx}.linear1.bias""", F"""model.transformer_module.decoder.layers.{idx}.fc1.bias""")     )
  # MLP 2
  rename_keys.append((F"""sem_seg_head.predictor.transformer.decoder.layers.{idx}.linear2.weight""", F"""model.transformer_module.decoder.layers.{idx}.fc2.weight""")     )
  rename_keys.append((F"""sem_seg_head.predictor.transformer.decoder.layers.{idx}.linear2.bias""", F"""model.transformer_module.decoder.layers.{idx}.fc2.bias""")     )
  # layernorm 1 (self-attention layernorm)
  rename_keys.append((F"""sem_seg_head.predictor.transformer.decoder.layers.{idx}.norm1.weight""", F"""model.transformer_module.decoder.layers.{idx}.self_attn_layer_norm.weight""")     )
  rename_keys.append((F"""sem_seg_head.predictor.transformer.decoder.layers.{idx}.norm1.bias""", F"""model.transformer_module.decoder.layers.{idx}.self_attn_layer_norm.bias""")     )
  # layernorm 2 (cross-attention layernorm)
  rename_keys.append((F"""sem_seg_head.predictor.transformer.decoder.layers.{idx}.norm2.weight""", F"""model.transformer_module.decoder.layers.{idx}.encoder_attn_layer_norm.weight""")     )
  rename_keys.append((F"""sem_seg_head.predictor.transformer.decoder.layers.{idx}.norm2.bias""", F"""model.transformer_module.decoder.layers.{idx}.encoder_attn_layer_norm.bias""")     )
  # layernorm 3 (final layernorm)
  rename_keys.append((F"""sem_seg_head.predictor.transformer.decoder.layers.{idx}.norm3.weight""", F"""model.transformer_module.decoder.layers.{idx}.final_layer_norm.weight""")     )
  rename_keys.append((F"""sem_seg_head.predictor.transformer.decoder.layers.{idx}.norm3.bias""", F"""model.transformer_module.decoder.layers.{idx}.final_layer_norm.bias""")     )

 rename_keys.append(('''sem_seg_head.predictor.transformer.decoder.norm.weight''', '''model.transformer_module.decoder.layernorm.weight''')     )
 rename_keys.append(('''sem_seg_head.predictor.transformer.decoder.norm.bias''', '''model.transformer_module.decoder.layernorm.bias''')     )

 # heads on top
 rename_keys.append(('''sem_seg_head.predictor.query_embed.weight''', '''model.transformer_module.queries_embedder.weight''')     )

 rename_keys.append(('''sem_seg_head.predictor.input_proj.weight''', '''model.transformer_module.input_projection.weight''')     )
 rename_keys.append(('''sem_seg_head.predictor.input_proj.bias''', '''model.transformer_module.input_projection.bias''')     )

 rename_keys.append(('''sem_seg_head.predictor.class_embed.weight''', '''class_predictor.weight''')     )
 rename_keys.append(('''sem_seg_head.predictor.class_embed.bias''', '''class_predictor.bias''')     )

 for i in range(3     ):
  rename_keys.append((F"""sem_seg_head.predictor.mask_embed.layers.{i}.weight""", F"""mask_embedder.{i}.0.weight""")     )
  rename_keys.append((F"""sem_seg_head.predictor.mask_embed.layers.{i}.bias""", F"""mask_embedder.{i}.0.bias""")     )
 # fmt: on

 return rename_keys
def 			__UpperCamelCase       (   UpperCAmelCase		,     UpperCAmelCase		,     UpperCAmelCase     ):
 lowercase__				:    Any  =					dct.pop(UpperCAmelCase     )
 lowercase__				:    Optional[int]  =					val
def 			__UpperCamelCase       (   UpperCAmelCase		,     UpperCAmelCase     ):
 lowercase__				:    Optional[int]  =					[int(backbone_config.embed_dim * 2**i     ) for i in range(len(backbone_config.depths     )     )]
 for i in range(len(backbone_config.depths     )     ):
  lowercase__				:    Tuple  =					num_features[i]
  for j in range(backbone_config.depths[i]     ):
   # fmt: off
   # read in weights + bias of input projection layer (in original implementation, this is a single matrix + bias)
   lowercase__				:    Any  =					state_dict.pop(F"""backbone.layers.{i}.blocks.{j}.attn.qkv.weight"""     )
   lowercase__				:    Optional[int]  =					state_dict.pop(F"""backbone.layers.{i}.blocks.{j}.attn.qkv.bias"""     )
   # next, add query, keys and values (in that order) to the state dict
   lowercase__				:    Tuple  =					in_proj_weight[:dim, :]
   lowercase__				:    List[str]  =					in_proj_bias[: dim]
   lowercase__				:    Dict  =					in_proj_weight[
       dim : dim * 2, :
   ]
   lowercase__				:    Tuple  =					in_proj_bias[
       dim : dim * 2
   ]
   lowercase__				:    int  =					in_proj_weight[
       -dim :, :
   ]
   lowercase__				:    int  =					in_proj_bias[-dim :]
   # fmt: on
def 			__UpperCamelCase       (   UpperCAmelCase		,     UpperCAmelCase     ):
 # fmt: off
 lowercase__				:    str  =					config.decoder_config.hidden_size
 for idx in range(config.decoder_config.decoder_layers     ):
  # read in weights + bias of self-attention input projection layer (in the original implementation, this is a single matrix + bias)
  lowercase__				:    int  =					state_dict.pop(F"""sem_seg_head.predictor.transformer.decoder.layers.{idx}.self_attn.in_proj_weight"""     )
  lowercase__				:    Optional[int]  =					state_dict.pop(F"""sem_seg_head.predictor.transformer.decoder.layers.{idx}.self_attn.in_proj_bias"""     )
  # next, add query, keys and values (in that order) to the state dict
  lowercase__				:    int  =					in_proj_weight[: hidden_size, :]
  lowercase__				:    Union[str, Any]  =					in_proj_bias[:config.hidden_size]
  lowercase__				:    Any  =					in_proj_weight[hidden_size : hidden_size * 2, :]
  lowercase__				:    Optional[int]  =					in_proj_bias[hidden_size : hidden_size * 2]
  lowercase__				:    Optional[int]  =					in_proj_weight[-hidden_size :, :]
  lowercase__				:    int  =					in_proj_bias[-hidden_size :]
  # read in weights + bias of cross-attention input projection layer (in the original implementation, this is a single matrix + bias)
  lowercase__				:    Optional[int]  =					state_dict.pop(F"""sem_seg_head.predictor.transformer.decoder.layers.{idx}.multihead_attn.in_proj_weight"""     )
  lowercase__				:    Optional[int]  =					state_dict.pop(F"""sem_seg_head.predictor.transformer.decoder.layers.{idx}.multihead_attn.in_proj_bias"""     )
  # next, add query, keys and values (in that order) to the state dict
  lowercase__				:    Optional[Any]  =					in_proj_weight[: hidden_size, :]
  lowercase__				:    Dict  =					in_proj_bias[:config.hidden_size]
  lowercase__				:    Tuple  =					in_proj_weight[hidden_size : hidden_size * 2, :]
  lowercase__				:    int  =					in_proj_bias[hidden_size : hidden_size * 2]
  lowercase__				:    Optional[int]  =					in_proj_weight[-hidden_size :, :]
  lowercase__				:    List[str]  =					in_proj_bias[-hidden_size :]
 # fmt: on
def 			__UpperCamelCase       (   ):
 lowercase__				:    Union[str, Any]  =					'''http://images.cocodataset.org/val2017/000000039769.jpg'''
 lowercase__				:    List[Any]  =					Image.open(requests.get(UpperCAmelCase		,     stream=UpperCAmelCase     ).raw     )
 return im
@torch.no_grad()
def 			__UpperCamelCase       (   UpperCAmelCase		,     UpperCAmelCase		,     UpperCAmelCase		,     UpperCAmelCase = False     ):
 lowercase__				:    int  =					get_maskformer_config(UpperCAmelCase     )

 # load original state_dict
 with open(UpperCAmelCase		,     '''rb'''     ) as f:
  lowercase__				:    Union[str, Any]  =					pickle.load(UpperCAmelCase     )
 lowercase__				:    str  =					data['''model''']

 # for name, param in state_dict.items():
 #     print(name, param.shape)

 # rename keys
 lowercase__				:    int  =					create_rename_keys(UpperCAmelCase     )
 for src, dest in rename_keys:
  rename_key(UpperCAmelCase		,     UpperCAmelCase		,     UpperCAmelCase     )
 read_in_swin_q_k_v(UpperCAmelCase		,     config.backbone_config     )
 read_in_decoder_q_k_v(UpperCAmelCase		,     UpperCAmelCase     )

 # update to torch tensors
 for key, value in state_dict.items():
  lowercase__				:    Optional[Any]  =					torch.from_numpy(UpperCAmelCase     )

 # load 🤗 model
 lowercase__				:    Dict  =					MaskFormerForInstanceSegmentation(UpperCAmelCase     )
 model.eval()

 for name, param in model.named_parameters():
  print(UpperCAmelCase		,     param.shape     )

 lowercase__ ,							lowercase__				:    int  =					model.load_state_dict(UpperCAmelCase		,     strict=UpperCAmelCase     )
 assert missing_keys == [
     "model.pixel_level_module.encoder.model.layernorm.weight",
     "model.pixel_level_module.encoder.model.layernorm.bias",
 ]
 assert len(UpperCAmelCase     ) == 0, F"""Unexpected keys: {unexpected_keys}"""

 # verify results
 lowercase__				:    List[str]  =					prepare_img()
 if "vistas" in model_name:
  lowercase__				:    List[str]  =					65
 elif "cityscapes" in model_name:
  lowercase__				:    Union[str, Any]  =					6_5535
 else:
  lowercase__				:    Optional[int]  =					255
 lowercase__				:    Union[str, Any]  =					True if '''ade''' in model_name else False
 lowercase__				:    Optional[Any]  =					MaskFormerImageProcessor(ignore_index=UpperCAmelCase		,     reduce_labels=UpperCAmelCase     )

 lowercase__				:    List[str]  =					image_processor(UpperCAmelCase		,     return_tensors='''pt'''     )

 lowercase__				:    Any  =					model(**UpperCAmelCase     )

 print('''Logits:'''		,     outputs.class_queries_logits[0, :3, :3]     )

 if model_name == "maskformer-swin-tiny-ade":
  lowercase__				:    List[str]  =					torch.tensor(
      [[3.6_3_5_3, -4.4_7_7_0, -2.6_0_6_5], [0.5_0_8_1, -4.2_3_9_4, -3.5_3_4_3], [2.1_9_0_9, -5.0_3_5_3, -1.9_3_2_3]]     )
 assert torch.allclose(outputs.class_queries_logits[0, :3, :3]		,     UpperCAmelCase		,     atol=1E-4     )
 print('''Looks ok!'''     )

 if pytorch_dump_folder_path is not None:
  print(F"""Saving model and image processor to {pytorch_dump_folder_path}"""     )
  Path(UpperCAmelCase     ).mkdir(exist_ok=UpperCAmelCase     )
  model.save_pretrained(UpperCAmelCase     )
  image_processor.save_pretrained(UpperCAmelCase     )

 if push_to_hub:
  print('''Pushing model and image processor to the hub...'''     )
  model.push_to_hub(F"""nielsr/{model_name}"""     )
  image_processor.push_to_hub(F"""nielsr/{model_name}"""     )


if __name__ == "__main__":
  __a: Union[str, Any]          =   argparse.ArgumentParser()
  # Required parameters
  parser.add_argument(
      """--model_name""",
      default="""maskformer-swin-tiny-ade""",
      type=str,
      help=("""Name of the MaskFormer model you'd like to convert""",),
  )
  parser.add_argument(
      """--checkpoint_path""",
      default="""/Users/nielsrogge/Documents/MaskFormer_checkpoints/MaskFormer-Swin-tiny-ADE20k/model.pkl""",
      type=str,
      help="""Path to the original state dict (.pth file).""",
  )
  parser.add_argument(
      """--pytorch_dump_folder_path""", default=None, type=str, help="""Path to the output PyTorch model directory."""
  )
  parser.add_argument(
      """--push_to_hub""", action="""store_true""", help="""Whether or not to push the converted model to the 🤗 hub."""
  )

  __a: int          =   parser.parse_args()
  convert_maskformer_checkpoint(
      args.model_name, args.checkpoint_path, args.pytorch_dump_folder_path, args.push_to_hub
  )


'''simple docstring'''

from typing import TYPE_CHECKING

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


__a: Dict          =   {
    """configuration_ctrl""": ["""CTRL_PRETRAINED_CONFIG_ARCHIVE_MAP""", """CTRLConfig"""],
    """tokenization_ctrl""": ["""CTRLTokenizer"""],
}

try:
  if not is_torch_available():
    raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
  pass
else:
  __a: int          =   [
      """CTRL_PRETRAINED_MODEL_ARCHIVE_LIST""",
      """CTRLForSequenceClassification""",
      """CTRLLMHeadModel""",
      """CTRLModel""",
      """CTRLPreTrainedModel""",
  ]

try:
  if not is_tf_available():
    raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
  pass
else:
  __a: int          =   [
      """TF_CTRL_PRETRAINED_MODEL_ARCHIVE_LIST""",
      """TFCTRLForSequenceClassification""",
      """TFCTRLLMHeadModel""",
      """TFCTRLModel""",
      """TFCTRLPreTrainedModel""",
  ]


if TYPE_CHECKING:
  from .configuration_ctrl import CTRL_PRETRAINED_CONFIG_ARCHIVE_MAP, CTRLConfig
  from .tokenization_ctrl import CTRLTokenizer

  try:
    if not is_torch_available():
      raise OptionalDependencyNotAvailable()
  except OptionalDependencyNotAvailable:
    pass
  else:
    from .modeling_ctrl import (
        CTRL_PRETRAINED_MODEL_ARCHIVE_LIST,
        CTRLForSequenceClassification,
        CTRLLMHeadModel,
        CTRLModel,
        CTRLPreTrainedModel,
    )

  try:
    if not is_tf_available():
      raise OptionalDependencyNotAvailable()
  except OptionalDependencyNotAvailable:
    pass
  else:
    from .modeling_tf_ctrl import (
        TF_CTRL_PRETRAINED_MODEL_ARCHIVE_LIST,
        TFCTRLForSequenceClassification,
        TFCTRLLMHeadModel,
        TFCTRLModel,
        TFCTRLPreTrainedModel,
    )

else:
  import sys

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

