code: 
  '''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
  
  
  lowercase__						=			"https://github.com/huggingface/datasets/tree/main/src/datasets/utils"
  lowercase__						=			f"{BASE_REF_URL}/{__file__}"
  lowercase__						=			logging.getLogger(__name__)
  
  
  
  
  def       _UpperCamelCase	(					SCREAMING_SNAKE_CASE__ )     ->       Tuple[Any, str]:
  
  
  		'''simple docstring'''
  
  
  		snake_case     :					int     =	pkg_resources.read_text(SCREAMING_SNAKE_CASE__   ,					SCREAMING_SNAKE_CASE__ )
  		return yaml.safe_load(SCREAMING_SNAKE_CASE__ ), F'{BASE_REF_URL}/resources/{resource}'
  
  
  lowercase__					,     lowercase__						=			load_yaml_resource("readme_structure.yaml")
  
  lowercase__						=			[
      "[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
  lowercase__						=			Tuple[dict, List[str], List[str]]
  
  
  
  
  
  
  class   snake_case__					:
  
  
  
  
  
  
  
  		"""simple docstring"""
  
  		def __init__(			self							: int     ,  UpperCamelCase__							: str     ,  UpperCamelCase__							: str     ,  UpperCamelCase__							: List[str] = None     ,  UpperCamelCase__							: bool = False			)	-> List[str]:
  
  
  
  
  
  
  				"""simple docstring"""
  
  
  
  
  
  
  
  				snake_case     :					Union[str, Any]     =	name
  				snake_case     :					int     =	level
  				snake_case     :					Any     =	lines
  				snake_case     :					List[str]     =	''''''
  				snake_case     :					str     =	True
  				snake_case     :					Union[str, Any]     =	{}
  				snake_case     :					Any     =	[]
  				snake_case     :					Dict     =	[]
  				if self.lines is not None:
  						self.parse(suppress_parsing_errors=UpperCamelCase__			)
  
  
  
  		def 			lowerCAmelCase							(			self							: str     ,  UpperCamelCase__							: bool = False			)	-> Any:
  
  
  
  
  
  
  				"""simple docstring"""
  
  
  
  
  
  
  
  				snake_case     :					List[str]     =	''''''
  				snake_case     :					Union[str, Any]     =	[]
  				snake_case     :					Dict     =	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(UpperCamelCase__     ,  self.level + '''#'''     ,  UpperCamelCase__			)
  										snake_case     :					List[Any]     =	[]
  								else:
  										if current_lines != []:
  												self.text += "".join(UpperCamelCase__			).strip()
  												if self.text != "" and self.text not in FILLER_TEXT:
  														snake_case     :					Optional[Any]     =	False
  												snake_case     :					Dict     =	[]
  
  								snake_case     :					Any     =	''' '''.join(line.split()[1:]			).strip(''' \n'''			)
  						else:
  								current_lines.append(UpperCamelCase__			)
  				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     :					int     =	Section(UpperCamelCase__     ,  self.level + '''#'''     ,  UpperCamelCase__			)
  						else:
  								if current_lines != []:
  										self.text += "".join(UpperCamelCase__			).strip()
  										if self.text != "" and self.text not in FILLER_TEXT:
  												snake_case     :					int     =	False
  
  				if self.level == "" and not suppress_parsing_errors:
  						if self.parsing_error_list != [] or self.parsing_warning_list != []:
  								snake_case     :					List[str]     =	'''\n'''.join('''-\t''' + x for x in self.parsing_error_list + self.parsing_warning_list			)
  								snake_case     :					Optional[Any]     =	f'The following issues were found while parsing the README at `{self.name}`:\n' + errors
  								raise ValueError(UpperCamelCase__			)
  
  
  
  		def 			lowerCAmelCase							(			self							: Any     ,  UpperCamelCase__							: dict			)	-> ReadmeValidatorOutput:
  
  
  
  
  
  
  				"""simple docstring"""
  
  
  
  
  
  
  
  				snake_case     :					Optional[Any]     =	[]
  				snake_case     :					str     =	[]
  				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     :					Tuple     =	[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     :					Union[str, Any]     =	[subsection['''name'''] for subsection in structure['''subsections''']]
  								snake_case     :					Optional[Any]     =	False
  								for idx, name in enumerate(UpperCamelCase__			):
  										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     :					Tuple     =	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     :					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 			lowerCAmelCase							(			self							: Any			)	-> dict:
  
  
  
  
  
  
  				"""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   snake_case__					(			__SCREAMING_SNAKE_CASE				):  # Level 0
  
  
  
  
  
  
  
  		"""simple docstring"""
  
  		def __init__(			self							: Tuple     ,  UpperCamelCase__							: str     ,  UpperCamelCase__							: List[str]     ,  UpperCamelCase__							: dict = None     ,  UpperCamelCase__							: bool = False			)	-> List[str]:
  
  
  
  
  
  
  				"""simple docstring"""
  
  
  
  
  
  
  
  				super().__init__(name=UpperCamelCase__     ,  level=''''''			)  # Not using lines here as we need to use a child class parse
  				snake_case     :					Tuple     =	structure
  				snake_case     :					Tuple     =	-2
  				snake_case     :					Tuple     =	0
  				snake_case     :					List[Any]     =	lines
  				if self.lines is not None:
  						self.parse(suppress_parsing_errors=UpperCamelCase__			)
  
  
  
  		def 			lowerCAmelCase							(			self							: Union[str, Any]			)	-> Optional[Any]:
  
  
  
  
  
  
  				"""simple docstring"""
  
  
  
  
  
  
  
  				if self.structure is None:
  						snake_case ,snake_case ,snake_case     :					Optional[int]     =	self._validate(UpperCamelCase__			)
  				else:
  						snake_case ,snake_case ,snake_case     :					str     =	self._validate(self.structure			)
  				if error_list != [] or warning_list != []:
  						snake_case     :					str     =	'''\n'''.join(['''-\t''' + x for x in error_list + warning_list]			)
  						snake_case     :					str     =	f'The following issues were found for the README at `{self.name}`:\n' + errors
  						raise ValueError(UpperCamelCase__			)
  
  
  
  		@classmethod
  		def 			lowerCAmelCase							(			cls							: Union[str, Any]     ,  UpperCamelCase__							: Path     ,  UpperCamelCase__							: dict = None     ,  UpperCamelCase__							: bool = False			)	-> Union[str, Any]:
  
  
  
  
  
  
  				"""simple docstring"""
  
  
  
  
  
  
  
  				with open(UpperCamelCase__     ,  encoding='''utf-8'''			) as f:
  						snake_case     :					Optional[int]     =	f.readlines()
  				return cls(UpperCamelCase__     ,  UpperCamelCase__     ,  UpperCamelCase__     ,  suppress_parsing_errors=UpperCamelCase__			)
  
  
  
  		@classmethod
  		def 			lowerCAmelCase							(			cls							: Optional[int]     ,  UpperCamelCase__							: str     ,  UpperCamelCase__							: dict = None     ,  UpperCamelCase__							: str = "root"     ,  UpperCamelCase__							: bool = False			)	-> Any:
  
  
  
  
  
  
  				"""simple docstring"""
  
  
  
  
  
  
  
  				snake_case     :					Any     =	string.split('''\n'''			)
  				return cls(UpperCamelCase__     ,  UpperCamelCase__     ,  UpperCamelCase__     ,  suppress_parsing_errors=UpperCamelCase__			)
  
  
  
  		def 			lowerCAmelCase							(			self							: Union[str, Any]     ,  UpperCamelCase__							: bool = False			)	-> Tuple:
  
  
  
  
  
  
  				"""simple docstring"""
  
  
  
  
  
  
  
  				snake_case     :					str     =	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     :					int     =	self.lines[line_count + 1 :]  # Get the last + 1 th item.
  				else:
  						snake_case     :					Tuple     =	self.lines[self.tag_count :]
  				super().parse(suppress_parsing_errors=UpperCamelCase__			)
  
  
  
  		def __str__(			self							: Optional[int]			)	-> Union[str, Any]:
  
  
  
  
  
  
  				"""simple docstring"""
  
  
  
  
  
  
  
  				return str(self.to_dict()			)
  
  
  
  		def 			lowerCAmelCase							(			self							: int     ,  UpperCamelCase__							: List[str]			)	-> Dict:
  
  
  
  
  
  
  				"""simple docstring"""
  
  
  
  
  
  
  
  				snake_case     :					str     =	[]
  				snake_case     :					Tuple     =	[]
  				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     :					Any     =	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     :					Tuple     =	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     :					Tuple     =	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
  
  						lowercase__						=			ArgumentParser(usage="Validate the content (excluding YAML tags) of a README.md file.")
  						ap.add_argument("readme_filepath")
  						lowercase__						=			ap.parse_args()
  						lowercase__						=			Path(args.readme_filepath)
  						lowercase__						=			ReadMe.from_readme(readme_filepath)
  
  
  
style_context: 
  '''simple docstring'''
  import torch
  
  from transformers import AutoTokenizer
  
  
  
  
  
  
  class   snake_case__					(			__SCREAMING_SNAKE_CASE				):
  
  
  
  
  
  
  
  		"""simple docstring"""
  
  		def __init__(			self							: Union[str, Any]     ,  UpperCamelCase__							: List[str]			)	-> List[str]:
  
  
  
  
  
  
  				"""simple docstring"""
  
  
  
  
  
  
  
  				snake_case     :					List[Any]     =	AutoTokenizer.from_pretrained(UpperCamelCase__			)
  
  
  
  		def 			lowerCAmelCase							(			self							: Any     ,  UpperCamelCase__							: str			)	-> Dict:
  
  
  
  
  
  
  				"""simple docstring"""
  
  
  
  
  
  
  
  				if isinstance(UpperCamelCase__     ,  UpperCamelCase__			) and all(isinstance(_x     ,  UpperCamelCase__			) for _x in x			):
  						snake_case     :					Any     =	None
  						for l in x:
  								snake_case     :					str     =	self.tokenizer(
  								    UpperCamelCase__     ,  padding='''max_length'''     ,  max_length=384     ,  truncation=UpperCamelCase__     ,  return_tensors='''pt'''     ,  )
  								snake_case     :					Tuple     =	torch.tensor([len(UpperCamelCase__			)]			)
  								if d is not None:
  										for k in d.keys():
  												snake_case     :					int     =	torch.cat((d[k], t[k])     ,  0			)
  								else:
  										snake_case     :					List[str]     =	t
  
  						snake_case     :					Union[str, Any]     =	torch.tensor(self.tokenizer.convert_tokens_to_ids('''[E]'''			)			)
  						snake_case     :					int     =	torch.tensor(self.tokenizer.convert_tokens_to_ids('''[/E]'''			)			)
  
  				elif isinstance(UpperCamelCase__     ,  UpperCamelCase__			) and all(isinstance(_x     ,  UpperCamelCase__			) for _x in x			):
  						snake_case     :					Optional[int]     =	self.tokenizer(
  						    UpperCamelCase__     ,  padding='''max_length'''     ,  max_length=384     ,  truncation=UpperCamelCase__     ,  return_tensors='''pt'''     ,  )
  
  				else:
  						raise Exception(
  						    '''Type of parameter x was not recognized! Only `list of strings` for query or `list of lists of'''
  						    ''' strings` for supports are supported.'''			)
  
  				return d
  
  
  
  		def 			lowerCAmelCase							(			self							: int     ,  UpperCamelCase__							: List[Any]     ,  UpperCamelCase__							: List[Any]     ,  UpperCamelCase__							: Any     ,  UpperCamelCase__							: Tuple     ,  UpperCamelCase__							: Any=0.70			)	-> Dict:
  
  
  
  
  
  
  				"""simple docstring"""
  
  
  
  
  
  
  
  				snake_case     :					str     =	[]
  				for idx in range(len(W_query['''input_ids''']			)			):
  						snake_case     :					Optional[int]     =	range(p_start.shape[1]			)
  
  						snake_case     :					str     =	[]
  						for start_id in start_indexes:
  								for end_id in end_indexes:
  										if start_id < end_id:
  												output.append(
  												    (
  												        start_id,
  												        end_id,
  												        p_start[idx][start_id].item(),
  												        p_end[idx][end_id].item(),
  												    )			)
  
  						output.sort(key=lambda UpperCamelCase__			: (tup[2] * tup[3])     ,  reverse=UpperCamelCase__			)
  						snake_case     :					int     =	[]
  						for k in range(len(UpperCamelCase__			)			):
  								if output[k][2] * output[k][3] >= thresh:
  										snake_case ,snake_case     :					Tuple     =	output[k][0], output[k][1]
  										snake_case     :					str     =	self.tokenizer.decode(W_query['''input_ids'''][idx][c_start_pos:c_end_pos]			)
  										temp.append((decoded, output[k][2] * output[k][3])			)
  
  						final_outputs.append(UpperCamelCase__			)
  
  				return final_outputs
  
  
  