
"""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			:       List[Any]   		=       logging.get_logger(__name__)


def   __magic_name__	(      __snake_case				:       str  ) ->				List[str]:
       lowercase    :				Dict       		=							SwinConfig.from_pretrained(
           "microsoft/swin-tiny-patch4-window7-224"     , out_features=["stage1", "stage2", "stage3", "stage4"]  )
       lowercase    :				Union[str, Any]       		=							MaskFormerConfig(backbone_config=__snake_case  )

       lowercase    :				Optional[int]       		=							"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    :				int       		=							150
              lowercase    :				Optional[Any]       		=							"ade20k-id2label.json"
       elif "coco-stuff" in model_name:
              # this should be ok
              lowercase    :				Optional[int]       		=							171
              lowercase    :				Optional[int]       		=							"maskformer-coco-stuff-id2label.json"
       elif "coco" in model_name:
              # TODO
              lowercase    :				List[str]       		=							133
              lowercase    :				List[Any]       		=							"coco-panoptic-id2label.json"
       elif "cityscapes" in model_name:
              # this should be ok
              lowercase    :				Any       		=							19
              lowercase    :				List[str]       		=							"cityscapes-id2label.json"
       elif "vistas" in model_name:
              # this should be ok
              lowercase    :				Dict       		=							65
              lowercase    :				List[str]       		=							"mapillary-vistas-id2label.json"

       lowercase    :				List[Any]       		=							json.load(open(hf_hub_download(__snake_case     , __snake_case     , repo_type="dataset"  )     , "r"  )  )
       lowercase    :				List[str]       		=							{int(__snake_case  ): v for k, v in idalabel.items()}

       return config


def   __magic_name__	(      __snake_case				:       int  ) ->				List[Any]:
       lowercase    :				List[Any]       		=							[]
       # 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   __magic_name__	(      __snake_case				:       List[Any]     , __snake_case				:       List[str]     , __snake_case				:       List[str]  ) ->				Optional[int]:
       lowercase    :				Optional[int]       		=							dct.pop(__snake_case  )
       lowercase    :				Tuple       		=							val


def   __magic_name__	(      __snake_case				:       List[Any]     , __snake_case				:       Any  ) ->				Dict:
       lowercase    :				List[Any]       		=							[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    :				List[Any]       		=							state_dict.pop(f"""backbone.layers.{i}.blocks.{j}.attn.qkv.weight"""  )
                     lowercase    :				Optional[Any]       		=							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    :				int       		=							in_proj_weight[:dim, :]
                     lowercase    :				Optional[int]       		=							in_proj_bias[: dim]
                     lowercase    :				int       		=							in_proj_weight[
                         dim : dim * 2, :
                     ]
                     lowercase    :				int       		=							in_proj_bias[
                         dim : dim * 2
                     ]
                     lowercase    :				Union[str, Any]       		=							in_proj_weight[
                         -dim :, :
                     ]
                     lowercase    :				int       		=							in_proj_bias[-dim :]
                     # fmt: on


def   __magic_name__	(      __snake_case				:       str     , __snake_case				:       Union[str, Any]  ) ->				Optional[int]:
       # fmt: off
       lowercase    :				Tuple       		=							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    :				str       		=							state_dict.pop(f"""sem_seg_head.predictor.transformer.decoder.layers.{idx}.self_attn.in_proj_weight"""  )
              lowercase    :				Any       		=							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    :				Any       		=							in_proj_weight[: hidden_size, :]
              lowercase    :				int       		=							in_proj_bias[:config.hidden_size]
              lowercase    :				Optional[int]       		=							in_proj_weight[hidden_size : hidden_size * 2, :]
              lowercase    :				List[Any]       		=							in_proj_bias[hidden_size : hidden_size * 2]
              lowercase    :				Optional[int]       		=							in_proj_weight[-hidden_size :, :]
              lowercase    :				Dict       		=							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    :				str       		=							state_dict.pop(f"""sem_seg_head.predictor.transformer.decoder.layers.{idx}.multihead_attn.in_proj_weight"""  )
              lowercase    :				Union[str, Any]       		=							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    :				Dict       		=							in_proj_weight[: hidden_size, :]
              lowercase    :				Optional[Any]       		=							in_proj_bias[:config.hidden_size]
              lowercase    :				List[str]       		=							in_proj_weight[hidden_size : hidden_size * 2, :]
              lowercase    :				Union[str, Any]       		=							in_proj_bias[hidden_size : hidden_size * 2]
              lowercase    :				str       		=							in_proj_weight[-hidden_size :, :]
              lowercase    :				int       		=							in_proj_bias[-hidden_size :]
       # fmt: on


def   __magic_name__	(      ) ->				torch.Tensor:
       lowercase    :				List[str]       		=							"http://images.cocodataset.org/val2017/000000039769.jpg"
       lowercase    :				Dict       		=							Image.open(requests.get(__snake_case     , stream=__snake_case  ).raw  )
       return im


@torch.no_grad()
def   __magic_name__	(      __snake_case				:       str     , __snake_case				:       str     , __snake_case				:       str     , __snake_case				:       bool = False  ) ->				List[str]:
       lowercase    :				Optional[Any]       		=							get_maskformer_config(__snake_case  )

       # load original state_dict
       with open(__snake_case     , "rb"  ) as f:
              lowercase    :				Tuple       		=							pickle.load(__snake_case  )
       lowercase    :				List[Any]       		=							data["model"]

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

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

       # update to torch tensors
       for key, value in state_dict.items():
              lowercase    :				List[str]       		=							torch.from_numpy(__snake_case  )

       # load 🤗 model
       lowercase    :				str       		=							MaskFormerForInstanceSegmentation(__snake_case  )
       model.eval()

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

       lowercase		,    lowercase    :				Optional[int]       		=							model.load_state_dict(__snake_case     , strict=__snake_case  )
       assert missing_keys == [
           "model.pixel_level_module.encoder.model.layernorm.weight",
           "model.pixel_level_module.encoder.model.layernorm.bias",
       ]
       assert len(__snake_case  ) == 0, f"""Unexpected keys: {unexpected_keys}"""

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

       lowercase    :				Optional[Any]       		=							image_processor(__snake_case     , return_tensors="pt"  )

       lowercase    :				Tuple       		=							model(**__snake_case  )

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

       if model_name == "maskformer-swin-tiny-ade":
              lowercase    :				Any       		=							torch.tensor(
                  [[3.63_53, -4.47_70, -2.60_65], [0.50_81, -4.23_94, -3.53_43], [2.19_09, -5.03_53, -1.93_23]]  )
       assert torch.allclose(outputs.class_queries_logits[0, :3, :3]     , __snake_case     , 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(__snake_case  ).mkdir(exist_ok=__snake_case  )
              model.save_pretrained(__snake_case  )
              image_processor.save_pretrained(__snake_case  )

       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			:       Dict   		=       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			:       List[str]   		=       parser.parse_args()
   convert_maskformer_checkpoint(
       args.model_name, args.checkpoint_path, args.pytorch_dump_folder_path, args.push_to_hub
   )




"""simple docstring"""




import os
import zipfile

import requests
from get_ci_error_statistics import download_artifact, get_artifacts_links


def   __magic_name__	(      __snake_case				:       Union[str, Any]     , __snake_case				:       List[str]=7  ) ->				str:
       lowercase    :				int       		=							None
       if token is not None:
              lowercase    :				Any       		=							{"Accept": "application/vnd.github+json", "Authorization": f"""Bearer {token}"""}

       # The id of a workflow (not of a workflow run)
       lowercase    :				int       		=							"636036"

       lowercase    :				Dict       		=							f"""https://api.github.com/repos/huggingface/transformers/actions/workflows/{workflow_id}/runs"""
       # On `main` branch + event being `schedule` + not returning PRs + only `num_runs` results
       url += f"""?branch=main&event=schedule&exclude_pull_requests=true&per_page={num_runs}"""

       lowercase    :				int       		=							requests.get(__snake_case     , headers=__snake_case  ).json()

       return result["workflow_runs"]


def   __magic_name__	(      __snake_case				:       Dict  ) ->				Tuple:
       lowercase    :				Tuple       		=							get_daily_ci_runs(__snake_case  )
       lowercase    :				Union[str, Any]       		=							None
       for workflow_run in workflow_runs:
              if workflow_run["status"] == "completed":
                     lowercase    :				List[Any]       		=							workflow_run["id"]
                     break

       return workflow_run_id


def   __magic_name__	(      __snake_case				:       Optional[int]     , __snake_case				:       Optional[Any]     , __snake_case				:       Union[str, Any]  ) ->				int:
       lowercase    :				Dict       		=							get_last_daily_ci_runs(__snake_case  )
       if workflow_run_id is not None:
              lowercase    :				Dict       		=							get_artifacts_links(worflow_run_id=__snake_case     , token=__snake_case  )
              for artifact_name in artifact_names:
                     if artifact_name in artifacts_links:
                            lowercase    :				Optional[int]       		=							artifacts_links[artifact_name]
                            download_artifact(
                                artifact_name=__snake_case     , artifact_url=__snake_case     , output_dir=__snake_case     , token=__snake_case  )


def   __magic_name__	(      __snake_case				:       List[Any]     , __snake_case				:       Optional[int]     , __snake_case				:       Tuple  ) ->				Optional[int]:
       get_last_daily_ci_artifacts(__snake_case     , __snake_case     , __snake_case  )

       lowercase    :				str       		=							{}
       for artifact_name in artifact_names:
              lowercase    :				Optional[Any]       		=							os.path.join(__snake_case     , f"""{artifact_name}.zip"""  )
              if os.path.isfile(__snake_case  ):
                     lowercase    :				List[Any]       		=							{}
                     with zipfile.ZipFile(__snake_case  ) as z:
                            for filename in z.namelist():
                                   if not os.path.isdir(__snake_case  ):
                                          # read the file
                                          with z.open(__snake_case  ) as f:
                                                 lowercase    :				str       		=							f.read().decode("UTF-8"  )

       return results


