"""simple docstring"""







import collections
import os
import re
from pathlib import Path


SCREAMING_SNAKE_CASE									=						'src/transformers'


# Matches is_xxx_available()
SCREAMING_SNAKE_CASE									=						re.compile(r'is\_([a-z_]*)_available()')
# Catches a one-line _import_struct = {xxx}
SCREAMING_SNAKE_CASE									=						re.compile(r'^_import_structure\s+=\s+\{([^\}]+)\}')
# Catches a line with a key-values pattern: "bla": ["foo", "bar"]
SCREAMING_SNAKE_CASE									=						re.compile(r'\s+"\S*":\s+\[([^\]]*)\]')
# Catches a line if not is_foo_available
SCREAMING_SNAKE_CASE									=						re.compile(r'^\s*if\s+not\s+is\_[a-z_]*\_available\(\)')
# Catches a line _import_struct["bla"].append("foo")
SCREAMING_SNAKE_CASE									=						re.compile(r'^\s*_import_structure\["\S*"\]\.append\("(\S*)"\)')
# Catches a line _import_struct["bla"].extend(["foo", "bar"]) or _import_struct["bla"] = ["foo", "bar"]
SCREAMING_SNAKE_CASE									=						re.compile(r'^\s*_import_structure\[\S*\](?:\.extend\(|\s*=\s+)\[([^\]]*)\]')
# Catches a line with an object between quotes and a comma:     "MyModel",
SCREAMING_SNAKE_CASE									=						re.compile(r'^\s+"([^"]+)",')
# Catches a line with objects between brackets only:    ["foo", "bar"],
SCREAMING_SNAKE_CASE									=						re.compile(r'^\s+\[([^\]]+)\]')
# Catches a line with from foo import bar, bla, boo
SCREAMING_SNAKE_CASE									=						re.compile(r'\s+from\s+\S*\s+import\s+([^\(\s].*)\n')
# Catches a line with try:
SCREAMING_SNAKE_CASE									=						re.compile(r'^\s*try:')
# Catches a line with else:
SCREAMING_SNAKE_CASE									=						re.compile(r'^\s*else:')


def      __lowerCAmelCase(		__UpperCAmelCase			):






	"""simple docstring"""





	if _re_test_backend.search(__UpperCAmelCase			) is None:
		return None
	_lowercase :    Any							=							[b[0] for b in _re_backend.findall(__UpperCAmelCase			)]
	backends.sort()
	return "_and_".join(__UpperCAmelCase			)


def      __lowerCAmelCase(		__UpperCAmelCase			):






	"""simple docstring"""





	with open(__UpperCAmelCase     ,'r'     ,encoding='utf-8'     ,newline='\n'			) as f:
		_lowercase :    int							=							f.readlines()

	_lowercase :    Any							=							0
	while line_index < len(__UpperCAmelCase			) and not lines[line_index].startswith('_import_structure = {'			):
		line_index += 1

	# If this is a traditional init, just return.
	if line_index >= len(__UpperCAmelCase			):
		return None

	# First grab the objects without a specific backend in _import_structure
	_lowercase :    Any							=							[]
	while not lines[line_index].startswith('if TYPE_CHECKING'			) and find_backend(lines[line_index]			) is None:
		_lowercase :    int							=							lines[line_index]
		# If we have everything on a single line, let's deal with it.
		if _re_one_line_import_struct.search(__UpperCAmelCase			):
			_lowercase :    Tuple							=							_re_one_line_import_struct.search(__UpperCAmelCase			).groups()[0]
			_lowercase :    str							=							re.findall(R'\[([^\]]+)\]'     ,__UpperCAmelCase			)
			for imp in imports:
				objects.extend([obj[1:-1] for obj in imp.split(', '			)]			)
			line_index += 1
			continue
		_lowercase :    List[str]							=							_re_import_struct_key_value.search(__UpperCAmelCase			)
		if single_line_import_search is not None:
			_lowercase :    List[Any]							=							[obj[1:-1] for obj in single_line_import_search.groups()[0].split(', '			) if len(__UpperCAmelCase			) > 0]
			objects.extend(__UpperCAmelCase			)
		elif line.startswith(' ' * 8 + '"'			):
			objects.append(line[9:-3]			)
		line_index += 1

	_lowercase :    Any							=							{'none': objects}
	# Let's continue with backend-specific objects in _import_structure
	while not lines[line_index].startswith('if TYPE_CHECKING'			):
		# If the line is an if not is_backend_available, we grab all objects associated.
		_lowercase :    Any							=							find_backend(lines[line_index]			)
		# Check if the backend declaration is inside a try block:
		if _re_try.search(lines[line_index - 1]			) is None:
			_lowercase :    Any							=							None

		if backend is not None:
			line_index += 1

			# Scroll until we hit the else block of try-except-else
			while _re_else.search(lines[line_index]			) is None:
				line_index += 1

			line_index += 1

			_lowercase :    Union[str, Any]							=							[]
			# Until we unindent, add backend objects to the list
			while len(lines[line_index]			) <= 1 or lines[line_index].startswith(' ' * 4			):
				_lowercase :    Union[str, Any]							=							lines[line_index]
				if _re_import_struct_add_one.search(__UpperCAmelCase			) is not None:
					objects.append(_re_import_struct_add_one.search(__UpperCAmelCase			).groups()[0]			)
				elif _re_import_struct_add_many.search(__UpperCAmelCase			) is not None:
					_lowercase :    Dict							=							_re_import_struct_add_many.search(__UpperCAmelCase			).groups()[0].split(', '			)
					_lowercase :    int							=							[obj[1:-1] for obj in imports if len(__UpperCAmelCase			) > 0]
					objects.extend(__UpperCAmelCase			)
				elif _re_between_brackets.search(__UpperCAmelCase			) is not None:
					_lowercase :    str							=							_re_between_brackets.search(__UpperCAmelCase			).groups()[0].split(', '			)
					_lowercase :    Dict							=							[obj[1:-1] for obj in imports if len(__UpperCAmelCase			) > 0]
					objects.extend(__UpperCAmelCase			)
				elif _re_quote_object.search(__UpperCAmelCase			) is not None:
					objects.append(_re_quote_object.search(__UpperCAmelCase			).groups()[0]			)
				elif line.startswith(' ' * 8 + '"'			):
					objects.append(line[9:-3]			)
				elif line.startswith(' ' * 12 + '"'			):
					objects.append(line[13:-3]			)
				line_index += 1

			_lowercase :    Union[str, Any]							=							objects
		else:
			line_index += 1

    # At this stage we are in the TYPE_CHECKING part, first grab the objects without a specific backend
	_lowercase :    Optional[Any]							=							[]
	while (
	    line_index < len(__UpperCAmelCase			)
	    and find_backend(lines[line_index]			) is None
	    and not lines[line_index].startswith('else'			)
	):
		_lowercase :    str							=							lines[line_index]
		_lowercase :    int							=							_re_import.search(__UpperCAmelCase			)
		if single_line_import_search is not None:
			objects.extend(single_line_import_search.groups()[0].split(', '			)			)
		elif line.startswith(' ' * 8			):
			objects.append(line[8:-2]			)
		line_index += 1

	_lowercase :    Optional[int]							=							{'none': objects}
	# Let's continue with backend-specific objects
	while line_index < len(__UpperCAmelCase			):
		# If the line is an if is_backend_available, we grab all objects associated.
		_lowercase :    Dict							=							find_backend(lines[line_index]			)
		# Check if the backend declaration is inside a try block:
		if _re_try.search(lines[line_index - 1]			) is None:
			_lowercase :    Tuple							=							None

		if backend is not None:
			line_index += 1

			# Scroll until we hit the else block of try-except-else
			while _re_else.search(lines[line_index]			) is None:
				line_index += 1

			line_index += 1

			_lowercase :    Optional[int]							=							[]
			# Until we unindent, add backend objects to the list
			while len(lines[line_index]			) <= 1 or lines[line_index].startswith(' ' * 8			):
				_lowercase :    Any							=							lines[line_index]
				_lowercase :    int							=							_re_import.search(__UpperCAmelCase			)
				if single_line_import_search is not None:
					objects.extend(single_line_import_search.groups()[0].split(', '			)			)
				elif line.startswith(' ' * 12			):
					objects.append(line[12:-2]			)
				line_index += 1

			_lowercase :    Dict							=							objects
		else:
			line_index += 1

	return import_dict_objects, type_hint_objects


def      __lowerCAmelCase(		__UpperCAmelCase     ,__UpperCAmelCase			):






	"""simple docstring"""





	def find_duplicates(__UpperCAmelCase			):
		return [k for k, v in collections.Counter(__UpperCAmelCase			).items() if v > 1]

	if list(import_dict_objects.keys()			) != list(type_hint_objects.keys()			):
		return ["Both sides of the init do not have the same backends!"]

	_lowercase :    Tuple							=							[]
	for key in import_dict_objects.keys():
		_lowercase :    Union[str, Any]							=							find_duplicates(import_dict_objects[key]			)
		if duplicate_imports:
			errors.append(F'''Duplicate _import_structure definitions for: {duplicate_imports}'''			)
		_lowercase :    Optional[int]							=							find_duplicates(type_hint_objects[key]			)
		if duplicate_type_hints:
			errors.append(F'''Duplicate TYPE_CHECKING objects for: {duplicate_type_hints}'''			)

		if sorted(set(import_dict_objects[key]			)			) != sorted(set(type_hint_objects[key]			)			):
			_lowercase :    Optional[Any]							=							'base imports' if key == 'none' else F'''{key} backend'''
			errors.append(F'''Differences for {name}:'''			)
			for a in type_hint_objects[key]:
				if a not in import_dict_objects[key]:
					errors.append(F'''  {a} in TYPE_HINT but not in _import_structure.'''			)
			for a in import_dict_objects[key]:
				if a not in type_hint_objects[key]:
					errors.append(F'''  {a} in _import_structure but not in TYPE_HINT.'''			)
	return errors


def      __lowerCAmelCase(		):






	"""simple docstring"""





	_lowercase :    Optional[int]							=							[]
	for root, _, files in os.walk(__UpperCAmelCase			):
		if "__init__.py" in files:
			_lowercase :    List[Any]							=							os.path.join(__UpperCAmelCase     ,'__init__.py'			)
			_lowercase :    Optional[Any]							=							parse_init(__UpperCAmelCase			)
			if objects is not None:
				_lowercase :    List[str]							=							analyze_results(*__UpperCAmelCase			)
				if len(__UpperCAmelCase			) > 0:
					_lowercase :    Union[str, Any]							=							F'''Problem in {fname}, both halves do not define the same objects.\n{errors[0]}'''
					failures.append('\n'.join(__UpperCAmelCase			)			)
	if len(__UpperCAmelCase			) > 0:
		raise ValueError('\n\n'.join(__UpperCAmelCase			)			)


def      __lowerCAmelCase(		):






	"""simple docstring"""





	_lowercase :    List[str]							=							[]
	for path, directories, files in os.walk(__UpperCAmelCase			):
		for folder in directories:
			# Ignore private modules
			if folder.startswith('_'			):
				directories.remove(__UpperCAmelCase			)
				continue
			# Ignore leftovers from branches (empty folders apart from pycache)
			if len(list((Path(__UpperCAmelCase			) / folder).glob('*.py'			)			)			) == 0:
				continue
			_lowercase :    List[Any]							=							str((Path(__UpperCAmelCase			) / folder).relative_to(__UpperCAmelCase			)			)
			_lowercase :    str							=							short_path.replace(os.path.sep     ,'.'			)
			submodules.append(__UpperCAmelCase			)
		for fname in files:
			if fname == "__init__.py":
				continue
			_lowercase :    int							=							str((Path(__UpperCAmelCase			) / fname).relative_to(__UpperCAmelCase			)			)
			_lowercase :    Optional[Any]							=							short_path.replace('.py'     ,''			).replace(os.path.sep     ,'.'			)
			if len(submodule.split('.'			)			) == 1:
				submodules.append(__UpperCAmelCase			)
	return submodules


SCREAMING_SNAKE_CASE									=						[
    'convert_pytorch_checkpoint_to_tf2',
    'modeling_flax_pytorch_utils',
    'models.esm.openfold_utils',
]


def      __lowerCAmelCase(		):






	"""simple docstring"""





	from transformers.utils import direct_transformers_import

	_lowercase :    int							=							direct_transformers_import(__UpperCAmelCase			)

	_lowercase :    Dict							=							set(transformers._import_structure.keys()			)
	# This contains all the base keys of the _import_structure object defined in the init, but if the user is missing
	# some optional dependencies, they may not have all of them. Thus we read the init to read all additions and
	# (potentiall re-) add them.
	with open(os.path.join(__UpperCAmelCase     ,'__init__.py'			)     ,'r'			) as f:
		_lowercase :    List[str]							=							f.read()
	import_structure_keys.update(set(re.findall(R'import_structure\[\"([^\"]*)\"\]'     ,__UpperCAmelCase			)			)			)

	_lowercase :    Optional[int]							=							[
	    module
	    for module in get_transformers_submodules()
	    if module not in IGNORE_SUBMODULES and module not in import_structure_keys
	]

	if len(__UpperCAmelCase			) > 0:
		_lowercase :    Union[str, Any]							=							'\n'.join(F'''- {module}''' for module in module_not_registered			)
		raise ValueError(
		    'The following submodules are not properly registed in the main init of Transformers:\n'
		    F'''{list_of_modules}\n'''
		    'Make sure they appear somewhere in the keys of `_import_structure` with an empty list as value.'			)


if __name__ == "__main__":
						check_all_inits()
						check_submodules()




"""simple docstring"""







import re
import time
from typing import Optional

import IPython.display as disp

from ..trainer_callback import TrainerCallback
from ..trainer_utils import IntervalStrategy, has_length


def      __lowerCAmelCase(		__UpperCAmelCase			):






	"""simple docstring"""





	_lowercase :    Optional[int]							=							int(__UpperCAmelCase			)
	_lowercase				,      _lowercase				,      _lowercase :    Union[str, Any]							=							t // 3_600, (t // 60) % 60, t % 60
	return F'''{h}:{m:02d}:{s:02d}''' if h != 0 else F'''{m:02d}:{s:02d}'''


def      __lowerCAmelCase(		__UpperCAmelCase     ,__UpperCAmelCase     ,__UpperCAmelCase     ,__UpperCAmelCase     ,__UpperCAmelCase=300			):






	"""simple docstring"""





	return F'''
    <div>
      {prefix}
      <progress value=\'{value}\' max=\'{total}\' style=\'width:{width}px; height:20px; vertical-align: middle;\'></progress>
      {label}
    </div>
    '''


def      __lowerCAmelCase(		__UpperCAmelCase			):






	"""simple docstring"""





	_lowercase :    List[Any]							=							'<table border="1" class="dataframe">\n'
	html_code += """  <thead>\n <tr style="text-align: left;">\n"""
	for i in items[0]:
		html_code += F'''      <th>{i}</th>\n'''
	html_code += "    </tr>\n  </thead>\n  <tbody>\n"
	for line in items[1:]:
		html_code += "    <tr>\n"
		for elt in line:
			_lowercase :    Optional[Any]							=							F'''{elt:.6f}''' if isinstance(__UpperCAmelCase     ,__UpperCAmelCase			) else str(__UpperCAmelCase			)
			html_code += F'''      <td>{elt}</td>\n'''
		html_code += "    </tr>\n"
	html_code += "  </tbody>\n</table><p>"
	return html_code



class  _lowerCamelCase			:
				_snake_case     =  5
				_snake_case     =  0.2







				def __init__( self    :       List[str]			,					lowerCamelCase_    :       int			,					lowerCamelCase_    :       Optional[str] = None			,					lowerCamelCase_    :       bool = True			,					lowerCamelCase_    :       Optional["NotebookTrainingTracker"] = None			,					lowerCamelCase_    :       int = 3_0_0			,					):

					"""simple docstring"""






					_lowercase :    int							=							total
					_lowercase :    Dict							=							'' if prefix is None else prefix
					_lowercase :    List[Any]							=							leave
					_lowercase :    Dict							=							parent
					_lowercase :    str							=							width
					_lowercase :    Any							=							None
					_lowercase :    Optional[int]							=							None
					_lowercase :    Union[str, Any]							=							None







				def 							__UpperCAmelCase					( self    :       Dict			,					lowerCamelCase_    :       int			,					lowerCamelCase_    :       bool = False			,					lowerCamelCase_    :       str = None						):

					"""simple docstring"""






					_lowercase :    Dict							=							value
					if comment is not None:
						_lowercase :    List[str]							=							comment
					if self.last_value is None:
						_lowercase :    List[Any]							=							time.time()
						_lowercase :    str							=							value
						_lowercase :    Any							=							None
						_lowercase :    List[Any]							=							self.warmup
						_lowercase :    Union[str, Any]							=							1
						self.update_bar(lowerCamelCase_						)
					elif value <= self.last_value and not force_update:
						return
					elif force_update or self.first_calls > 0 or value >= min(self.last_value + self.wait_for			,					self.total						):
						if self.first_calls > 0:
							self.first_calls -= 1
						_lowercase :    Tuple							=							time.time()
						_lowercase :    List[str]							=							current_time - self.start_time
						# We could have value = self.start_value if the update is called twixe with the same start value.
						if value > self.start_value:
							_lowercase :    List[Any]							=							self.elapsed_time / (value - self.start_value)
						else:
							_lowercase :    List[Any]							=							None
						if value >= self.total:
							_lowercase :    Optional[Any]							=							self.total
							_lowercase :    str							=							None
							if not self.leave:
								self.close()
						elif self.average_time_per_item is not None:
							_lowercase :    int							=							self.average_time_per_item * (self.total - value)
						self.update_bar(lowerCamelCase_						)
						_lowercase :    Optional[int]							=							value
						_lowercase :    Dict							=							current_time
						if self.average_time_per_item is None:
							_lowercase :    Union[str, Any]							=							1
						else:
							_lowercase :    Optional[Any]							=							max(int(self.update_every / self.average_time_per_item						)			,					1						)







				def 							__UpperCAmelCase					( self    :       str			,					lowerCamelCase_    :       int			,					lowerCamelCase_    :       Optional[Any]=None						):

					"""simple docstring"""






					_lowercase :    str							=							' ' * (len(str(self.total						)						) - len(str(lowerCamelCase_						)						)) + str(lowerCamelCase_						)
					if self.elapsed_time is None:
						_lowercase :    Dict							=							F'''[{spaced_value}/{self.total} : < :'''
					elif self.predicted_remaining is None:
						_lowercase :    Optional[int]							=							F'''[{spaced_value}/{self.total} {format_time(self.elapsed_time						)}'''
					else:
						_lowercase :    int							=							(
						    F'''[{spaced_value}/{self.total} {format_time(self.elapsed_time						)} <'''
						    F''' {format_time(self.predicted_remaining						)}'''
						)
						self.label += F''', {1/self.average_time_per_item:.2f} it/s'''
					self.label += "]" if self.comment is None or len(self.comment						) == 0 else F''', {self.comment}]'''
					self.display()







				def 							__UpperCAmelCase					( self    :       int						):

					"""simple docstring"""






					_lowercase :    int							=							html_progress_bar(self.value			,					self.total			,					self.prefix			,					self.label			,					self.width						)
					if self.parent is not None:
						# If this is a child bar, the parent will take care of the display.
						self.parent.display()
						return
					if self.output is None:
						_lowercase :    List[str]							=							disp.display(disp.HTML(self.html_code						)			,					display_id=lowerCamelCase_						)
					else:
						self.output.update(disp.HTML(self.html_code						)						)







				def 							__UpperCAmelCase					( self    :       Any						):

					"""simple docstring"""






					if self.parent is None and self.output is not None:
						self.output.update(disp.HTML(''						)						)



class  _lowerCamelCase			(__lowerCamelCase     ):







				def __init__( self    :       Optional[int]			,					lowerCamelCase_    :       Any			,					lowerCamelCase_    :       Tuple=None						):

					"""simple docstring"""






					super().__init__(lowerCamelCase_						)
					_lowercase :    Tuple							=							None if column_names is None else [column_names]
					_lowercase :    Optional[int]							=							None







				def 							__UpperCAmelCase					( self    :       Optional[Any]						):

					"""simple docstring"""






					_lowercase :    Union[str, Any]							=							html_progress_bar(self.value			,					self.total			,					self.prefix			,					self.label			,					self.width						)
					if self.inner_table is not None:
						self.html_code += text_to_html_table(self.inner_table						)
					if self.child_bar is not None:
						self.html_code += self.child_bar.html_code
					if self.output is None:
						_lowercase :    Dict							=							disp.display(disp.HTML(self.html_code						)			,					display_id=lowerCamelCase_						)
					else:
						self.output.update(disp.HTML(self.html_code						)						)







				def 							__UpperCAmelCase					( self    :       Optional[Any]			,					lowerCamelCase_    :       Optional[int]						):

					"""simple docstring"""






					if self.inner_table is None:
						_lowercase :    Optional[int]							=							[list(values.keys()						), list(values.values()						)]
					else:
						_lowercase :    str							=							self.inner_table[0]
						if len(self.inner_table						) == 1:
							# We give a chance to update the column names at the first iteration
							for key in values.keys():
								if key not in columns:
									columns.append(lowerCamelCase_						)
							_lowercase :    List[Any]							=							columns
						self.inner_table.append([values[c] for c in columns]						)







				def 							__UpperCAmelCase					( self    :       List[Any]			,					lowerCamelCase_    :       List[Any]			,					lowerCamelCase_    :       Union[str, Any]=None			,					lowerCamelCase_    :       int=3_0_0						):

					"""simple docstring"""






					_lowercase :    List[str]							=							NotebookProgressBar(lowerCamelCase_			,					prefix=lowerCamelCase_			,					parent=self			,					width=lowerCamelCase_						)
					return self.child_bar







				def 							__UpperCAmelCase					( self    :       Any						):

					"""simple docstring"""






					_lowercase :    Any							=							None
					self.display()



class  _lowerCamelCase			(__lowerCamelCase     ):







				def __init__( self    :       Optional[Any]						):

					"""simple docstring"""






					_lowercase :    int							=							None
					_lowercase :    Any							=							None
					_lowercase :    Optional[int]							=							False







				def 							__UpperCAmelCase					( self    :       Any			,					lowerCamelCase_    :       Optional[Any]			,					lowerCamelCase_    :       int			,					lowerCamelCase_    :       List[Any]			,					**lowerCamelCase_    :       Union[str, Any]						):

					"""simple docstring"""






					_lowercase :    Any							=							'Epoch' if args.evaluation_strategy == IntervalStrategy.EPOCH else 'Step'
					_lowercase :    Dict							=							0
					_lowercase :    Optional[Any]							=							0
					_lowercase :    Union[str, Any]							=							[self.first_column] + ['Training Loss']
					if args.evaluation_strategy != IntervalStrategy.NO:
						column_names.append('Validation Loss'						)
					_lowercase :    Tuple							=							NotebookTrainingTracker(state.max_steps			,					lowerCamelCase_						)







				def 							__UpperCAmelCase					( self    :       Union[str, Any]			,					lowerCamelCase_    :       Any			,					lowerCamelCase_    :       Optional[Any]			,					lowerCamelCase_    :       Union[str, Any]			,					**lowerCamelCase_    :       Dict						):

					"""simple docstring"""






					_lowercase :    Optional[Any]							=							int(state.epoch						) if int(state.epoch						) == state.epoch else F'''{state.epoch:.2f}'''
					self.training_tracker.update(
					    state.global_step + 1			,					comment=F'''Epoch {epoch}/{state.num_train_epochs}'''			,					force_update=self._force_next_update			,					)
					_lowercase :    Tuple							=							False







				def 							__UpperCAmelCase					( self    :       int			,					lowerCamelCase_    :       Dict			,					lowerCamelCase_    :       Optional[int]			,					lowerCamelCase_    :       Optional[int]			,					lowerCamelCase_    :       Union[str, Any]=None			,					**lowerCamelCase_    :       str						):

					"""simple docstring"""






					if not has_length(lowerCamelCase_						):
						return
					if self.prediction_bar is None:
						if self.training_tracker is not None:
							_lowercase :    Tuple							=							self.training_tracker.add_child(len(lowerCamelCase_						)						)
						else:
							_lowercase :    Optional[Any]							=							NotebookProgressBar(len(lowerCamelCase_						)						)
						self.prediction_bar.update(1						)
					else:
						self.prediction_bar.update(self.prediction_bar.value + 1						)







				def 							__UpperCAmelCase					( self    :       Tuple			,					lowerCamelCase_    :       Dict			,					lowerCamelCase_    :       Optional[Any]			,					lowerCamelCase_    :       Dict			,					**lowerCamelCase_    :       List[str]						):

					"""simple docstring"""






					if self.prediction_bar is not None:
						self.prediction_bar.close()
					_lowercase :    Union[str, Any]							=							None







				def 							__UpperCAmelCase					( self    :       List[str]			,					lowerCamelCase_    :       int			,					lowerCamelCase_    :       int			,					lowerCamelCase_    :       str			,					lowerCamelCase_    :       int=None			,					**lowerCamelCase_    :       List[Any]						):

					"""simple docstring"""






					if args.evaluation_strategy == IntervalStrategy.NO and "loss" in logs:
						_lowercase :    Any							=							{'Training Loss': logs['loss']}
						# First column is necessarily Step sine we're not in epoch eval strategy
						_lowercase :    Any							=							state.global_step
						self.training_tracker.write_line(lowerCamelCase_						)







				def 							__UpperCAmelCase					( self    :       int			,					lowerCamelCase_    :       List[Any]			,					lowerCamelCase_    :       int			,					lowerCamelCase_    :       List[str]			,					lowerCamelCase_    :       str=None			,					**lowerCamelCase_    :       List[Any]						):

					"""simple docstring"""






					if self.training_tracker is not None:
						_lowercase :    List[str]							=							{'Training Loss': 'No log', 'Validation Loss': 'No log'}
						for log in reversed(state.log_history						):
							if "loss" in log:
								_lowercase :    Union[str, Any]							=							log['loss']
								break

						if self.first_column == "Epoch":
							_lowercase :    Optional[int]							=							int(state.epoch						)
						else:
							_lowercase :    Optional[Any]							=							state.global_step
						_lowercase :    int							=							'eval'
						for k in metrics:
							if k.endswith('_loss'						):
								_lowercase :    Tuple							=							re.sub(r'\_loss$'			,					''			,					lowerCamelCase_						)
						_lowercase :    Optional[Any]							=							metrics.pop('total_flos'			,					lowerCamelCase_						)
						_lowercase :    List[str]							=							metrics.pop('epoch'			,					lowerCamelCase_						)
						_lowercase :    List[Any]							=							metrics.pop(F'''{metric_key_prefix}_runtime'''			,					lowerCamelCase_						)
						_lowercase :    Tuple							=							metrics.pop(F'''{metric_key_prefix}_samples_per_second'''			,					lowerCamelCase_						)
						_lowercase :    Any							=							metrics.pop(F'''{metric_key_prefix}_steps_per_second'''			,					lowerCamelCase_						)
						_lowercase :    Union[str, Any]							=							metrics.pop(F'''{metric_key_prefix}_jit_compilation_time'''			,					lowerCamelCase_						)
						for k, v in metrics.items():
							if k == F'''{metric_key_prefix}_loss''':
								_lowercase :    Optional[Any]							=							v
							else:
								_lowercase :    Tuple							=							k.split('_'						)
								_lowercase :    List[Any]							=							' '.join([part.capitalize() for part in splits[1:]]						)
								_lowercase :    List[Any]							=							v
						self.training_tracker.write_line(lowerCamelCase_						)
						self.training_tracker.remove_child()
						_lowercase :    Any							=							None
						# Evaluation takes a long time so we should force the next update.
						_lowercase :    Dict							=							True







				def 							__UpperCAmelCase					( self    :       Optional[int]			,					lowerCamelCase_    :       Tuple			,					lowerCamelCase_    :       Optional[Any]			,					lowerCamelCase_    :       Union[str, Any]			,					**lowerCamelCase_    :       Any						):

					"""simple docstring"""






					self.training_tracker.update(
					    state.global_step			,					comment=F'''Epoch {int(state.epoch						)}/{state.num_train_epochs}'''			,					force_update=lowerCamelCase_						)
					_lowercase :    List[Any]							=							None



