






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        SCREAMING_SNAKE_CASE       (      lowerCamelCase_):
					a__          =  int(lowerCAmelCase__)
					a__       ,a__       ,a__          =  t // 3600, (t // 60) % 60, t % 60
					return f'{h}:{m:02d}:{s:02d}' if h != 0 else f'{m:02d}:{s:02d}'





def        SCREAMING_SNAKE_CASE       (      lowerCamelCase_ ,     lowerCamelCase_ ,     lowerCamelCase_ ,     lowerCamelCase_ ,     lowerCamelCase_=300):
					# docstyle-ignore
					return f'\n    <div>\n      {prefix}\n      <progress value=\'{value}\' max=\'{total}\' style=\'width:{width}px; height:20px; vertical-align: middle;\'></progress>\n      {label}\n    </div>\n    '





def        SCREAMING_SNAKE_CASE       (      lowerCamelCase_):
					a__          =  '''<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:
															a__          =  f'{elt:.6f}' if isinstance(lowerCAmelCase__ ,     lowerCAmelCase__) else str(lowerCAmelCase__)
															html_code += f'      <td>{elt}</td>\n'
										html_code += "    </tr>\n"
					html_code += "  </tbody>\n</table><p>"
					return html_code







class        _SCREAMING_SNAKE_CASE						:





							"""simple docstring"""





							_SCREAMING_SNAKE_CASE    =5
							_SCREAMING_SNAKE_CASE    =0.2




							def __init__(   self:     int				,		__A:     Tuple				,		__A:     Optional[int] = None				,		__A:     List[Any] = True				,		__A:     Any = None				,		__A:     int = 300				,		):

												'''simple docstring'''

												a__          =  total
												a__          =  '''''' if prefix is None else prefix
												a__          =  leave
												a__          =  parent
												a__          =  width
												a__          =  None
												a__          =  None
												a__          =  None




							def  lowercase		(   self:     List[Any]				,		__A:     int				,		__A:     Optional[Any] = False				,		__A:     Optional[Any] = None    ):

												'''simple docstring'''

												a__          =  value
												if comment is not None:
																	a__          =  comment
												if self.last_value is None:
																	a__          =  a__          =  time.time()
																	a__          =  a__          =  value
																	a__          =  a__          =  None
																	a__          =  self.warmup
																	a__          =  1
																	self.update_bar(_a    )
												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
																	a__          =  time.time()
																	a__          =  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:
																						a__          =  self.elapsed_time / (value - self.start_value)
																	else:
																						a__          =  None
																	if value >= self.total:
																						a__          =  self.total
																						a__          =  None
																						if not self.leave:
																											self.close()
																	elif self.average_time_per_item is not None:
																						a__          =  self.average_time_per_item * (self.total - value)
																	self.update_bar(_a    )
																	a__          =  value
																	a__          =  current_time
																	if self.average_time_per_item is None:
																						a__          =  1
																	else:
																						a__          =  max(int(self.update_every / self.average_time_per_item    )				,		1    )




							def  lowercase		(   self:     Union[str, Any]				,		__A:     Any				,		__A:     Any=None    ):

												'''simple docstring'''

												a__          =  ''' ''' * (len(str(self.total    )    ) - len(str(_a    )    )) + str(_a    )
												if self.elapsed_time is None:
																	a__          =  F'[{spaced_value}/{self.total} : < :'
												elif self.predicted_remaining is None:
																	a__          =  F'[{spaced_value}/{self.total} {format_time(self.elapsed_time    )}'
												else:
																	a__          =  (
																	    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  lowercase		(   self:     Optional[Any]    ):

												'''simple docstring'''

												a__          =  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:
																	a__          =  disp.display(disp.HTML(self.html_code    )				,		display_id=_a    )
												else:
																	self.output.update(disp.HTML(self.html_code    )    )





							def  lowercase		(   self:     Dict    ):

												'''simple docstring'''

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







class        _SCREAMING_SNAKE_CASE						(  __SCREAMING_SNAKE_CASE							):





							"""simple docstring"""





							def __init__(   self:     Any				,		__A:     Optional[int]				,		__A:     List[Any]=None    ):

												'''simple docstring'''

												super().__init__(_a    )
												a__          =  None if column_names is None else [column_names]
												a__          =  None




							def  lowercase		(   self:     int    ):

												'''simple docstring'''

												a__          =  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:
																	a__          =  disp.display(disp.HTML(self.html_code    )				,		display_id=_a    )
												else:
																	self.output.update(disp.HTML(self.html_code    )    )




							def  lowercase		(   self:     Tuple				,		__A:     Any    ):

												'''simple docstring'''

												if self.inner_table is None:
																	a__          =  [list(values.keys()    ), list(values.values()    )]
												else:
																	a__          =  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(_a    )
																						a__          =  columns
																	self.inner_table.append([values[c] for c in columns]    )




							def  lowercase		(   self:     Optional[Any]				,		__A:     Optional[Any]				,		__A:     Any=None				,		__A:     Union[str, Any]=300    ):

												'''simple docstring'''

												a__          =  NotebookProgressBar(_a				,		prefix=_a				,		parent=self				,		width=_a    )
												return self.child_bar





							def  lowercase		(   self:     str    ):

												'''simple docstring'''

												a__          =  None
												self.display()







class        _SCREAMING_SNAKE_CASE						(  __SCREAMING_SNAKE_CASE							):





							"""simple docstring"""





							def __init__(   self:     Optional[Any]    ):

												'''simple docstring'''

												a__          =  None
												a__          =  None
												a__          =  False




							def  lowercase		(   self:     int				,		__A:     Optional[int]				,		__A:     Optional[int]				,		__A:     Optional[int]				,		**__A:     List[Any]    ):

												'''simple docstring'''

												a__          =  '''Epoch''' if args.evaluation_strategy == IntervalStrategy.EPOCH else '''Step'''
												a__          =  0
												a__          =  0
												a__          =  [self.first_column] + ['''Training Loss''']
												if args.evaluation_strategy != IntervalStrategy.NO:
																	column_names.append('''Validation Loss'''    )
												a__          =  NotebookTrainingTracker(state.max_steps				,		_a    )




							def  lowercase		(   self:     int				,		__A:     str				,		__A:     Dict				,		__A:     Union[str, Any]				,		**__A:     Dict    ):

												'''simple docstring'''

												a__          =  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				,		)
												a__          =  False




							def  lowercase		(   self:     List[str]				,		__A:     Optional[Any]				,		__A:     Union[str, Any]				,		__A:     int				,		__A:     Union[str, Any]=None				,		**__A:     List[str]    ):

												'''simple docstring'''

												if not has_length(_a    ):
																	return
												if self.prediction_bar is None:
																	if self.training_tracker is not None:
																						a__          =  self.training_tracker.add_child(len(_a    )    )
																	else:
																						a__          =  NotebookProgressBar(len(_a    )    )
																	self.prediction_bar.update(1    )
												else:
																	self.prediction_bar.update(self.prediction_bar.value + 1    )




							def  lowercase		(   self:     Optional[Any]				,		__A:     List[str]				,		__A:     Optional[Any]				,		__A:     Any				,		**__A:     Optional[int]    ):

												'''simple docstring'''

												if self.prediction_bar is not None:
																	self.prediction_bar.close()
												a__          =  None




							def  lowercase		(   self:     int				,		__A:     Optional[int]				,		__A:     Tuple				,		__A:     Tuple				,		__A:     Union[str, Any]=None				,		**__A:     Any    ):

												'''simple docstring'''

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




							def  lowercase		(   self:     List[Any]				,		__A:     int				,		__A:     Any				,		__A:     List[str]				,		__A:     Optional[int]=None				,		**__A:     int    ):

												'''simple docstring'''

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

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





							def  lowercase		(   self:     Tuple				,		__A:     List[str]				,		__A:     Tuple				,		__A:     Optional[int]				,		**__A:     Optional[Any]    ):

												'''simple docstring'''

												self.training_tracker.update(
												    state.global_step				,		comment=F'Epoch {int(state.epoch    )}/{state.num_train_epochs}'				,		force_update=_a    )
												a__          =  None










"""simple docstring"""







from typing import TYPE_CHECKING

from ...utils import (
    OptionalDependencyNotAvailable,
    _LazyModule,
    is_tf_available,
    is_torch_available,
    is_vision_available,
)


__a       :	Tuple             = {'configuration_deit': ['DEIT_PRETRAINED_CONFIG_ARCHIVE_MAP', 'DeiTConfig', 'DeiTOnnxConfig']}

try:
	if not is_vision_available():
		raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
	pass
else:
	__a       :	Tuple             = ['DeiTFeatureExtractor']
	__a       :	Optional[Any]             = ['DeiTImageProcessor']

try:
	if not is_torch_available():
		raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
	pass
else:
	__a       :	Optional[int]             = [
	    'DEIT_PRETRAINED_MODEL_ARCHIVE_LIST',
	    'DeiTForImageClassification',
	    'DeiTForImageClassificationWithTeacher',
	    'DeiTForMaskedImageModeling',
	    'DeiTModel',
	    'DeiTPreTrainedModel',
	]

try:
	if not is_tf_available():
		raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
	pass
else:
	__a       :	Dict             = [
	    'TF_DEIT_PRETRAINED_MODEL_ARCHIVE_LIST',
	    'TFDeiTForImageClassification',
	    'TFDeiTForImageClassificationWithTeacher',
	    'TFDeiTForMaskedImageModeling',
	    'TFDeiTModel',
	    'TFDeiTPreTrainedModel',
	]


if TYPE_CHECKING:
	from .configuration_deit import DEIT_PRETRAINED_CONFIG_ARCHIVE_MAP, DeiTConfig, DeiTOnnxConfig

	try:
		if not is_vision_available():
			raise OptionalDependencyNotAvailable()
	except OptionalDependencyNotAvailable:
		pass
	else:
		from .feature_extraction_deit import DeiTFeatureExtractor
		from .image_processing_deit import DeiTImageProcessor

	try:
		if not is_torch_available():
			raise OptionalDependencyNotAvailable()
	except OptionalDependencyNotAvailable:
		pass
	else:
		from .modeling_deit import (
		    DEIT_PRETRAINED_MODEL_ARCHIVE_LIST,
		    DeiTForImageClassification,
		    DeiTForImageClassificationWithTeacher,
		    DeiTForMaskedImageModeling,
		    DeiTModel,
		    DeiTPreTrainedModel,
		)

	try:
		if not is_tf_available():
			raise OptionalDependencyNotAvailable()
	except OptionalDependencyNotAvailable:
		pass
	else:
		from .modeling_tf_deit import (
		    TF_DEIT_PRETRAINED_MODEL_ARCHIVE_LIST,
		    TFDeiTForImageClassification,
		    TFDeiTForImageClassificationWithTeacher,
		    TFDeiTForMaskedImageModeling,
		    TFDeiTModel,
		    TFDeiTPreTrainedModel,
		)


else:
	import sys

	__a       :	List[Any]             = _LazyModule(__name__, globals()['__file__'], _import_structure, module_spec=__spec__)


