






"""simple docstring"""





import logging
from pathlib import Path
from typing import Any, List, Tuple

import yaml


# loading package files: https://stackoverflow.com/a/20885799
try:
    import importlib.resources as pkg_resources
except ImportError:
    # Try backported to PY<37 `importlib_resources`.
    import importlib_resources as pkg_resources

from . import resources


UpperCamelCase_						:					Any      				=			"https://github.com/huggingface/datasets/tree/main/src/datasets/utils"
UpperCamelCase_						:					str      				=			F'''{BASE_REF_URL}/{__file__}'''
UpperCamelCase_						:					str      				=			logging.getLogger(__name__)



def      __lowercase       (     a			:					str			)       ->       Tuple[Any, str]:
      __snake_case   :     List[Any]	      =pkg_resources.read_text(a							,		a			)
      return yaml.safe_load(a			), f'''{BASE_REF_URL}/resources/{resource}'''


UpperCamelCase_						:					Any      				=			load_yaml_resource("""readme_structure.yaml""")

UpperCamelCase_						:					List[Any]      				=			[
    "[Needs More Information]",
    "[More Information Needed]",
    "(https://github.com/huggingface/datasets/blob/main/CONTRIBUTING.md#how-to-contribute-to-the-dataset-cards)",
]

# Dictionary representation of section/readme, error_list, warning_list
UpperCamelCase_						:					Any      				=			Tuple[dict, List[str], List[str]]


class   _lowercase			:


      def __init__(     self					:						Dict				, a					:						int				, a					:						Union[str, Any]				, a					:						List[str] = None				, a					:						Optional[int] = False    ):





            """simple docstring"""







            __snake_case   :     List[Any]	      =name
            __snake_case   :     Optional[Any]	      =level
            __snake_case   :     str	      =lines
            __snake_case   :     List[Any]	      =''''''
            __snake_case   :     List[Any]	      =True
            __snake_case   :     Dict	      ={}
            __snake_case   :     Any	      =[]
            __snake_case   :     Union[str, Any]	      =[]
            if self.lines is not None:
                  self.parse(suppress_parsing_errors=SCREAMING_SNAKE_CASE_    )


      def _UpperCamelCase    (     self					:						Union[str, Any]				, a					:						Optional[int] = False    ):





            """simple docstring"""







            __snake_case   :     str	      =''''''
            __snake_case   :     List[str]	      =[]
            __snake_case   :     List[str]	      =False
            for line in self.lines:
                  if line.strip(''' \n'''    ) == "":
                        continue
                  elif line.strip(''' \n'''    )[:3] == "```":
                        __snake_case   :     List[Any]	      =not code_start
                  elif line.split()[0] == self.level + "#" and not code_start:
                        if current_sub_level != "":
                              __snake_case   :     Optional[int]	      =Section(SCREAMING_SNAKE_CASE_				, self.level + '''#'''				, SCREAMING_SNAKE_CASE_    )
                              __snake_case   :     Optional[Any]	      =[]
                        else:
                              if current_lines != []:
                                    self.text += "".join(SCREAMING_SNAKE_CASE_    ).strip()
                                    if self.text != "" and self.text not in FILLER_TEXT:
                                          __snake_case   :     Optional[int]	      =False
                                    __snake_case   :     Optional[Any]	      =[]

                        __snake_case   :     List[Any]	      =''' '''.join(line.split()[1:]    ).strip(''' \n'''    )
                  else:
                        current_lines.append(SCREAMING_SNAKE_CASE_    )
            else:
                  if current_sub_level != "":
                        if current_sub_level in self.content:
                              self.parsing_error_list.append(
                                  f'''Multiple sections with the same heading `{current_sub_level}` have been found. Please keep only one of these sections.'''    )
                        __snake_case   :     Any	      =Section(SCREAMING_SNAKE_CASE_				, self.level + '''#'''				, SCREAMING_SNAKE_CASE_    )
                  else:
                        if current_lines != []:
                              self.text += "".join(SCREAMING_SNAKE_CASE_    ).strip()
                              if self.text != "" and self.text not in FILLER_TEXT:
                                    __snake_case   :     str	      =False

            if self.level == "" and not suppress_parsing_errors:
                  if self.parsing_error_list != [] or self.parsing_warning_list != []:
                        __snake_case   :     List[Any]	      ='''\n'''.join('''-\t''' + x for x in self.parsing_error_list + self.parsing_warning_list    )
                        __snake_case   :     Union[str, Any]	      =f'''The following issues were found while parsing the README at `{self.name}`:\n''' + errors
                        raise ValueError(SCREAMING_SNAKE_CASE_    )


      def _UpperCamelCase    (     self					:						Dict				, a					:						Optional[int]    ):





            """simple docstring"""







            __snake_case   :     Optional[int]	      =[]
            __snake_case   :     Optional[Any]	      =[]
            if structure["allow_empty"] is False:
                  # If content is expected
                  if self.is_empty_text and self.content == {}:
                        # If no content is found, mention it in the error_list
                        error_list.append(f'''Expected some content in section `{self.name}` but it is empty.'''    )

            if structure["allow_empty_text"] is False:
                  # If some text is expected
                  if self.is_empty_text:
                        # If no text is found, mention it in the error_list
                        error_list.append(
                            f'''Expected some text in section `{self.name}` but it is empty (text in subsections are ignored).'''    )
        # Subsections Validation
            if structure["subsections"] is not None:
                  # If subsections are expected
                  if self.content == {}:
                        # If no subsections are present
                        __snake_case   :     Optional[Any]	      =[subsection['''name'''] for subsection in structure['''subsections''']]
                        # Mention the expected values in the error_list
                        error_list.append(
                            f'''Section `{self.name}` expected the following subsections: {", ".join(["`"+x+"`" for x in values]    )}. Found \'None\'.'''    )
                  else:
                        # If some subsections are present
                        __snake_case   :     List[str]	      =[subsection['''name'''] for subsection in structure['''subsections''']]
                        __snake_case   :     List[Any]	      =False
                        for idx, name in enumerate(SCREAMING_SNAKE_CASE_    ):
                              if name not in self.content:
                                    # If the expected subsection is not present
                                    error_list.append(f'''Section `{self.name}` is missing subsection: `{name}`.'''    )
                                    __snake_case   :     Optional[Any]	      =True
                              else:
                                    # If the subsection is present, validate subsection, return the result
                                    # and concat the errors from subsection to section error_list

                                    # Skip sublevel validation if current level is `###`
                                    if self.level == "###":
                                          continue
                                    else:
                                          __snake_case      ,					__snake_case      ,					__snake_case   :     List[str]	      =self.content[name].validate(
                                              structure['''subsections'''][idx]    )
                                    error_list += subsec_error_list
                                    warning_list += subsec_warning_list

                        if has_missing_subsections:  # we only allow to have extra subsections if all the other ones are here
                              for name in self.content:
                                    if name not in structure_names:
                                          # If an extra subsection is present
                                          warning_list.append(
                                              f'''`{self.name}` has an extra subsection: `{name}`. Skipping further validation checks for this subsection as expected structure is unknown.'''    )
            if error_list:
                  # If there are errors, do not return the dictionary as it is invalid
                  return {}, error_list, warning_list
            else:
                  return self.to_dict(), error_list, warning_list







      def _UpperCamelCase    (     self					:						Tuple    ):





            """simple docstring"""







            return {
                "name": self.name,
                "text": self.text,
                "is_empty_text": self.is_empty_text,
                "subsections": [value.to_dict() for value in self.content.values()],
            }



class   _lowercase			(  SCREAMING_SNAKE_CASE_    ):  # Level 0


      def __init__(     self					:						Any				, a					:						Optional[Any]				, a					:						List[Any]				, a					:						Optional[Any] = None				, a					:						List[str] = False    ):





            """simple docstring"""







            super().__init__(name=SCREAMING_SNAKE_CASE_				, level=''''''    )  # Not using lines here as we need to use a child class parse
            __snake_case   :     List[Any]	      =structure
            __snake_case   :     Any	      =-2
            __snake_case   :     Tuple	      =0
            __snake_case   :     List[str]	      =lines
            if self.lines is not None:
                  self.parse(suppress_parsing_errors=SCREAMING_SNAKE_CASE_    )


      def _UpperCamelCase    (     self					:						List[str]    ):





            """simple docstring"""







            if self.structure is None:
                  __snake_case      ,					__snake_case      ,					__snake_case   :     Any	      =self._validate(SCREAMING_SNAKE_CASE_    )
            else:
                  __snake_case      ,					__snake_case      ,					__snake_case   :     Tuple	      =self._validate(self.structure    )
            if error_list != [] or warning_list != []:
                  __snake_case   :     List[Any]	      ='''\n'''.join(['''-\t''' + x for x in error_list + warning_list]    )
                  __snake_case   :     Union[str, Any]	      =f'''The following issues were found for the README at `{self.name}`:\n''' + errors
                  raise ValueError(SCREAMING_SNAKE_CASE_    )


      @classmethod
      def _UpperCamelCase    (     cls					:						int				, a					:						str				, a					:						Union[str, Any] = None				, a					:						str = False    ):





            """simple docstring"""







            with open(SCREAMING_SNAKE_CASE_				, encoding='''utf-8'''    ) as f:
                  __snake_case   :     Union[str, Any]	      =f.readlines()
            return cls(SCREAMING_SNAKE_CASE_				, SCREAMING_SNAKE_CASE_				, SCREAMING_SNAKE_CASE_				, suppress_parsing_errors=SCREAMING_SNAKE_CASE_    )


      @classmethod
      def _UpperCamelCase    (     cls					:						Tuple				, a					:						Dict				, a					:						int = None				, a					:						Optional[Any] = "root"				, a					:						Union[str, Any] = False    ):





            """simple docstring"""







            __snake_case   :     Any	      =string.split('''\n'''    )
            return cls(SCREAMING_SNAKE_CASE_				, SCREAMING_SNAKE_CASE_				, SCREAMING_SNAKE_CASE_				, suppress_parsing_errors=SCREAMING_SNAKE_CASE_    )


      def _UpperCamelCase    (     self					:						int				, a					:						int = False    ):





            """simple docstring"""







            __snake_case   :     Optional[int]	      =0

            for line in self.lines:
                  self.yaml_tags_line_count += 1
                  if line.strip(''' \n'''    ) == "---":
                        self.tag_count += 1
                        if self.tag_count == 2:
                              break
                  line_count += 1
            if self.tag_count == 2:
                  __snake_case   :     Tuple	      =self.lines[line_count + 1 :]  # Get the last + 1 th item.
            else:
                  __snake_case   :     Optional[int]	      =self.lines[self.tag_count :]
            super().parse(suppress_parsing_errors=SCREAMING_SNAKE_CASE_    )


      def __str__(     self					:						Union[str, Any]    ):





            """simple docstring"""







            return str(self.to_dict()    )







      def _UpperCamelCase    (     self					:						Optional[Any]				, a					:						Optional[int]    ):





            """simple docstring"""







            __snake_case   :     Optional[Any]	      =[]
            __snake_case   :     int	      =[]
            if self.yaml_tags_line_count == 0:
                  warning_list.append('''Empty YAML markers are present in the README.'''    )
            elif self.tag_count == 0:
                  warning_list.append('''No YAML markers are present in the README.'''    )
            elif self.tag_count == 1:
                  warning_list.append('''Only the start of YAML tags present in the README.'''    )
            # Check how many first level sections are present.
            __snake_case   :     Dict	      =len(self.content.keys()    )
            if num_first_level_keys > 1:
                  # If more than one, add to the error list, continue
                  error_list.append(
                      f'''The README has several first-level headings: {", ".join(["`"+x+"`" for x in list(self.content.keys()    )]    )}. Only one heading is expected. Skipping further validation for this README.'''    )
            elif num_first_level_keys < 1:
                  # If less than one, append error.
                  error_list.append(
                      '''The README has no first-level headings. One heading is expected. Skipping further validation for this README.'''    )

            else:
                  # If one exactly
                  __snake_case   :     Union[str, Any]	      =list(self.content.keys()    )[0]  # Get the key
                  if start_key.startswith('''Dataset Card for'''    ):  # Check correct start
                        # If the starting is correct, validate all the sections
                        __snake_case      ,					__snake_case      ,					__snake_case   :     str	      =self.content[start_key].validate(
                            readme_structure['''subsections'''][0]    )
                        error_list += sec_error_list
                        warning_list += sec_warning_list
                  else:
                        # If not found, append error
                        error_list.append(
                            '''No first-level heading starting with `Dataset Card for` found in README. Skipping further validation for this README.'''    )
            if error_list:
                  # If there are errors, do not return the dictionary as it is invalid
                  return {}, error_list, warning_list
            else:
                  return self.to_dict(), error_list, warning_list


if __name__ == "__main__":
    from argparse import ArgumentParser

    UpperCamelCase_						:					Dict      				=			ArgumentParser(usage="""Validate the content (excluding YAML tags) of a README.md file.""")
    ap.add_argument("""readme_filepath""")
    UpperCamelCase_						:					Optional[Any]      				=			ap.parse_args()
    UpperCamelCase_						:					Any      				=			Path(args.readme_filepath)
    UpperCamelCase_						:					str      				=			ReadMe.from_readme(readme_filepath)




import argparse

import torch
from clip import load

from transformers import CLIPConfig, CLIPModel




def 						A_			(				snake_case				: List[str]			,   snake_case				: int			)   ->     Dict:



						'''simple docstring'''

						__UpperCamelCase	,				__UpperCamelCase	,				__UpperCamelCase  	=      pt_attn_layer.in_proj_weight.chunk(3			,   dim=0			)
						__UpperCamelCase	,				__UpperCamelCase	,				__UpperCamelCase  	=      pt_attn_layer.in_proj_bias.chunk(3			,   dim=0			)

						__UpperCamelCase  	=      pt_attn_layer.out_proj.weight
						__UpperCamelCase  	=      pt_attn_layer.out_proj.bias

						__UpperCamelCase  	=      q_proj
						__UpperCamelCase  	=      q_proj_bias

						__UpperCamelCase  	=      k_proj
						__UpperCamelCase  	=      k_proj_bias

						__UpperCamelCase  	=      v_proj
						__UpperCamelCase  	=      v_proj_bias

						__UpperCamelCase  	=      out_proj_weights
						__UpperCamelCase  	=      out_proj_bias




def 						A_			(				snake_case				: Optional[Any]			,   snake_case				: int			)   ->     Any:



						'''simple docstring'''

						copy_linear(hf_mlp.fca			,   pt_mlp.c_fc			)
						copy_linear(hf_mlp.fca			,   pt_mlp.c_proj			)




def 						A_			(				snake_case				: Union[str, Any]			,   snake_case				: Optional[Any]			)   ->     Union[str, Any]:



						'''simple docstring'''

						__UpperCamelCase  	=      pt_linear.weight
						__UpperCamelCase  	=      pt_linear.bias




def 						A_			(				snake_case				: Tuple			,   snake_case				: int			)   ->     str:



						'''simple docstring'''

						copy_linear(hf_layer.layer_norma			,   pt_layer.ln_a			)
						copy_linear(hf_layer.layer_norma			,   pt_layer.ln_a			)

						# copy MLP
						copy_mlp(hf_layer.mlp			,   pt_layer.mlp			)

						# copy attn
						copy_attn_layer(hf_layer.self_attn			,   pt_layer.attn			)




def 						A_			(				snake_case				: List[Any]			,   snake_case				: Any			)   ->     Optional[int]:



						'''simple docstring'''

						for hf_layer, pt_layer in zip(snake_case			,   snake_case			):
												copy_layer(snake_case			,   snake_case			)




def 						A_			(				snake_case				: str			,   snake_case				: Dict			)   ->     List[str]:



						'''simple docstring'''

						__UpperCamelCase  	=      pt_model.token_embedding.weight
						__UpperCamelCase  	=      pt_model.positional_embedding

						# copy layer norm
						copy_linear(hf_encoder.final_layer_norm			,   pt_model.ln_final			)

						# copy hidden layers
						copy_layers(hf_encoder.encoder.layers			,   pt_model.transformer.resblocks			)




def 						A_			(				snake_case				: str			,   snake_case				: List[str]			)   ->     Dict:



						'''simple docstring'''

						__UpperCamelCase  	=      pt_model.text_projection.data.T

						# copy text encoder
						copy_encoder(hf_model.text_model			,   snake_case			)




def 						A_			(				snake_case				: List[str]			,   snake_case				: Any			)   ->     str:



						'''simple docstring'''

						__UpperCamelCase  	=      pt_model.visual.proj.data.T

						# copy layer norms
						copy_linear(hf_model.vision_model.pre_layrnorm			,   pt_model.visual.ln_pre			)
						copy_linear(hf_model.vision_model.post_layernorm			,   pt_model.visual.ln_post			)

						# copy embeds
						__UpperCamelCase  	=      pt_model.visual.conva.weight.data
						__UpperCamelCase  	=      pt_model.visual.class_embedding
						__UpperCamelCase  	=      pt_model.visual.positional_embedding.data

						# copy encoder
						copy_layers(hf_model.vision_model.encoder.layers			,   pt_model.visual.transformer.resblocks			)




@torch.no_grad()
def 						A_			(				snake_case				: List[Any]			,   snake_case				: int			,   snake_case				: Any=None			)   ->     List[Any]:



						'''simple docstring'''

						if config_path is not None:
												__UpperCamelCase  	=      CLIPConfig.from_pretrained(snake_case			)
						else:
												__UpperCamelCase  	=      CLIPConfig(projection_dim=512			,   text_config={}			,   vision_config={}			)

						__UpperCamelCase  	=      CLIPModel(snake_case			).eval()

						__UpperCamelCase	,				__UpperCamelCase  	=      load(snake_case			,   device='''cpu'''			,   jit=snake_case			)
						__UpperCamelCase  	=      pt_model.eval()

						copy_text_model_and_projection(snake_case			,   snake_case			)
						copy_vison_model_and_projection(snake_case			,   snake_case			)
						__UpperCamelCase  	=      pt_model.logit_scale

						__UpperCamelCase  	=      torch.arange(0			,   77			).unsqueeze(0			)
						__UpperCamelCase  	=      torch.randn(1			,   3			,   224			,   224			)

						__UpperCamelCase  	=      hf_model(input_ids=snake_case			,   pixel_values=snake_case			,   return_dict=snake_case			)
						__UpperCamelCase  	=      hf_outputs.logits_per_image
						__UpperCamelCase  	=      hf_outputs.logits_per_text
						__UpperCamelCase	,				__UpperCamelCase  	=      pt_model(snake_case			,   snake_case			)

						assert torch.allclose(snake_case			,   snake_case			,   atol=1e-3			)
						assert torch.allclose(snake_case			,   snake_case			,   atol=1e-3			)

						hf_model.save_pretrained(snake_case			)


if __name__ == "__main__":
				lowercase__				:				Union[str, Any]						=      argparse.ArgumentParser()
				parser.add_argument("--pytorch_dump_folder_path", default=None, type=str, help="Path to the output PyTorch model.")
				parser.add_argument("--checkpoint_path", default=None, type=str, help="Path to fairseq checkpoint")
				parser.add_argument("--config_path", default=None, type=str, help="Path to hf config.json of model to convert")
				lowercase__				:				str						=      parser.parse_args()

				convert_clip_checkpoint(args.checkpoint_path, args.pytorch_dump_folder_path, args.config_path)




