




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_    (    SCREAMING_SNAKE_CASE   ):
			'''simple docstring'''
			SCREAMING_SNAKE_CASE           =					int(SCREAMING_SNAKE_CASE   )
			SCREAMING_SNAKE_CASE     ,  SCREAMING_SNAKE_CASE     ,  SCREAMING_SNAKE_CASE           =					t // 36_00, (t // 60) % 60, t % 60
			return f"""{h}:{m:02d}:{s:02d}""" if h != 0 else f"""{m:02d}:{s:02d}"""
def 					lowerCamelCase_    (    SCREAMING_SNAKE_CASE					,	SCREAMING_SNAKE_CASE					,	SCREAMING_SNAKE_CASE					,	SCREAMING_SNAKE_CASE					,	SCREAMING_SNAKE_CASE=3_00   ):
			'''simple docstring'''
			# docstyle-ignore
			return f"""
    <div>
      {prefix}
      <progress value='{value}' max='{total}' style='width:{width}px; height:20px; vertical-align: middle;'></progress>
      {label}
    </div>
    """
def 					lowerCamelCase_    (    SCREAMING_SNAKE_CASE   ):
			'''simple docstring'''
			SCREAMING_SNAKE_CASE           =					"""<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:
									SCREAMING_SNAKE_CASE           =					f"""{elt:.6f}""" if isinstance(SCREAMING_SNAKE_CASE					,	SCREAMING_SNAKE_CASE   ) else str(SCREAMING_SNAKE_CASE   )
									html_code += f"""      <td>{elt}</td>\n"""
						html_code += "    </tr>\n"
			html_code += "  </tbody>\n</table><p>"
			return html_code




class 			UpperCAmelCase_      :




							'''simple docstring'''



							a__						  =     5
							a__						  =     0.2





							def __init__(					self       :	List[Any]       ,     a       :	int       ,     a       :	Optional[str] = None       ,     a       :	bool = True       ,     a       :	Optional["NotebookTrainingTracker"] = None       ,     a       :	int = 300       ,     )			->					str:
										SCREAMING_SNAKE_CASE           =					total
										SCREAMING_SNAKE_CASE           =					"""""" if prefix is None else prefix
										SCREAMING_SNAKE_CASE           =					leave
										SCREAMING_SNAKE_CASE           =					parent
										SCREAMING_SNAKE_CASE           =					width
										SCREAMING_SNAKE_CASE           =					None
										SCREAMING_SNAKE_CASE           =					None
										SCREAMING_SNAKE_CASE           =					None





							def    _UpperCAmelCase     (					self       :	Dict       ,     a       :	int       ,     a       :	bool = False       ,     a       :	str = None			)			->					Union[str, Any]:
										SCREAMING_SNAKE_CASE           =					value
										if comment is not None:
													SCREAMING_SNAKE_CASE           =					comment
										if self.last_value is None:
													SCREAMING_SNAKE_CASE           =					SCREAMING_SNAKE_CASE           =					time.time()
													SCREAMING_SNAKE_CASE           =					SCREAMING_SNAKE_CASE           =					value
													SCREAMING_SNAKE_CASE           =					SCREAMING_SNAKE_CASE           =					None
													SCREAMING_SNAKE_CASE           =					self.warmup
													SCREAMING_SNAKE_CASE           =					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
													SCREAMING_SNAKE_CASE           =					time.time()
													SCREAMING_SNAKE_CASE           =					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:
																SCREAMING_SNAKE_CASE           =					self.elapsed_time / (value - self.start_value)
													else:
																SCREAMING_SNAKE_CASE           =					None
													if value >= self.total:
																SCREAMING_SNAKE_CASE           =					self.total
																SCREAMING_SNAKE_CASE           =					None
																if not self.leave:
																			self.close()
													elif self.average_time_per_item is not None:
																SCREAMING_SNAKE_CASE           =					self.average_time_per_item * (self.total - value)
													self.update_bar(a			)
													SCREAMING_SNAKE_CASE           =					value
													SCREAMING_SNAKE_CASE           =					current_time
													if self.average_time_per_item is None:
																SCREAMING_SNAKE_CASE           =					1
													else:
																SCREAMING_SNAKE_CASE           =					max(int(self.update_every / self.average_time_per_item			)       ,     1			)





							def    _UpperCAmelCase     (					self       :	int       ,     a       :	List[Any]       ,     a       :	List[Any]=None			)			->					str:
										SCREAMING_SNAKE_CASE           =					""" """ * (len(str(self.total			)			) - len(str(a			)			)) + str(a			)
										if self.elapsed_time is None:
													SCREAMING_SNAKE_CASE           =					f"""[{spaced_value}/{self.total} : < :"""
										elif self.predicted_remaining is None:
													SCREAMING_SNAKE_CASE           =					f"""[{spaced_value}/{self.total} {format_time(self.elapsed_time			)}"""
										else:
													SCREAMING_SNAKE_CASE           =					(
													    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       :	Any			)			->					str:
										SCREAMING_SNAKE_CASE           =					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:
													SCREAMING_SNAKE_CASE           =					disp.display(disp.HTML(self.html_code			)       ,     display_id=a			)
										else:
													self.output.update(disp.HTML(self.html_code			)			)







							def    _UpperCAmelCase     (					self       :	Dict			)			->					Dict:
										if self.parent is None and self.output is not None:
													self.output.update(disp.HTML(""""""			)			)





class 			UpperCAmelCase_      (   A       ):




							'''simple docstring'''



							def __init__(					self       :	Optional[Any]       ,     a       :	int       ,     a       :	Union[str, Any]=None			)			->					List[Any]:
										super().__init__(a			)
										SCREAMING_SNAKE_CASE           =					None if column_names is None else [column_names]
										SCREAMING_SNAKE_CASE           =					None





							def    _UpperCAmelCase     (					self       :	List[str]			)			->					str:
										SCREAMING_SNAKE_CASE           =					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:
													SCREAMING_SNAKE_CASE           =					disp.display(disp.HTML(self.html_code			)       ,     display_id=a			)
										else:
													self.output.update(disp.HTML(self.html_code			)			)





							def    _UpperCAmelCase     (					self       :	Union[str, Any]       ,     a       :	Tuple			)			->					Optional[Any]:
										if self.inner_table is None:
													SCREAMING_SNAKE_CASE           =					[list(values.keys()			), list(values.values()			)]
										else:
													SCREAMING_SNAKE_CASE           =					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			)
																SCREAMING_SNAKE_CASE           =					columns
													self.inner_table.append([values[c] for c in columns]			)





							def    _UpperCAmelCase     (					self       :	List[Any]       ,     a       :	List[Any]       ,     a       :	int=None       ,     a       :	List[Any]=300			)			->					Any:
										SCREAMING_SNAKE_CASE           =					NotebookProgressBar(a       ,     prefix=a       ,     parent=self       ,     width=a			)
										return self.child_bar







							def    _UpperCAmelCase     (					self       :	int			)			->					Union[str, Any]:
										SCREAMING_SNAKE_CASE           =					None
										self.display()





class 			UpperCAmelCase_      (   A       ):




							'''simple docstring'''



							def __init__(					self       :	str			)			->					Optional[Any]:
										SCREAMING_SNAKE_CASE           =					None
										SCREAMING_SNAKE_CASE           =					None
										SCREAMING_SNAKE_CASE           =					False





							def    _UpperCAmelCase     (					self       :	Optional[int]       ,     a       :	str       ,     a       :	int       ,     a       :	Optional[Any]       ,     **a       :	Tuple			)			->					Any:
										SCREAMING_SNAKE_CASE           =					"""Epoch""" if args.evaluation_strategy == IntervalStrategy.EPOCH else """Step"""
										SCREAMING_SNAKE_CASE           =					0
										SCREAMING_SNAKE_CASE           =					0
										SCREAMING_SNAKE_CASE           =					[self.first_column] + ["""Training Loss"""]
										if args.evaluation_strategy != IntervalStrategy.NO:
													column_names.append("""Validation Loss"""			)
										SCREAMING_SNAKE_CASE           =					NotebookTrainingTracker(state.max_steps       ,     a			)





							def    _UpperCAmelCase     (					self       :	Dict       ,     a       :	Any       ,     a       :	Union[str, Any]       ,     a       :	Any       ,     **a       :	Optional[int]			)			->					List[Any]:
										SCREAMING_SNAKE_CASE           =					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       ,     )
										SCREAMING_SNAKE_CASE           =					False





							def    _UpperCAmelCase     (					self       :	Any       ,     a       :	str       ,     a       :	int       ,     a       :	List[Any]       ,     a       :	List[str]=None       ,     **a       :	List[str]			)			->					int:
										if not has_length(a			):
													return
										if self.prediction_bar is None:
													if self.training_tracker is not None:
																SCREAMING_SNAKE_CASE           =					self.training_tracker.add_child(len(a			)			)
													else:
																SCREAMING_SNAKE_CASE           =					NotebookProgressBar(len(a			)			)
													self.prediction_bar.update(1			)
										else:
													self.prediction_bar.update(self.prediction_bar.value + 1			)





							def    _UpperCAmelCase     (					self       :	Dict       ,     a       :	List[Any]       ,     a       :	Tuple       ,     a       :	int       ,     **a       :	Dict			)			->					Optional[Any]:
										if self.prediction_bar is not None:
													self.prediction_bar.close()
										SCREAMING_SNAKE_CASE           =					None





							def    _UpperCAmelCase     (					self       :	Dict       ,     a       :	Optional[int]       ,     a       :	List[Any]       ,     a       :	Optional[Any]       ,     a       :	Any=None       ,     **a       :	Optional[Any]			)			->					Optional[int]:
										# Only for when there is no evaluation
										if args.evaluation_strategy == IntervalStrategy.NO and "loss" in logs:
													SCREAMING_SNAKE_CASE           =					{"""Training Loss""": logs["""loss"""]}
													# First column is necessarily Step sine we're not in epoch eval strategy
													SCREAMING_SNAKE_CASE           =					state.global_step
													self.training_tracker.write_line(a			)





							def    _UpperCAmelCase     (					self       :	int       ,     a       :	str       ,     a       :	Optional[Any]       ,     a       :	int       ,     a       :	Dict=None       ,     **a       :	Optional[int]			)			->					str:
										if self.training_tracker is not None:
													SCREAMING_SNAKE_CASE           =					{"""Training Loss""": """No log""", """Validation Loss""": """No log"""}
													for log in reversed(state.log_history			):
																if "loss" in log:
																			SCREAMING_SNAKE_CASE           =					log["""loss"""]
																			break

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







							def    _UpperCAmelCase     (					self       :	int       ,     a       :	Union[str, Any]       ,     a       :	int       ,     a       :	int       ,     **a       :	List[Any]			)			->					Dict:
										self.training_tracker.update(
										    state.global_step       ,     comment=f"""Epoch {int(state.epoch			)}/{state.num_train_epochs}"""       ,     force_update=a			)
										SCREAMING_SNAKE_CASE           =					None












import importlib
import shutil
import threading
import warnings
from typing import List

import fsspec
import fsspec.asyn

from . import compression
from .hffilesystem import HfFileSystem


__A						:							Tuple							=  importlib.util.find_spec("""s3fs""") is not None

if _has_safs:
		from .safilesystem import SaFileSystem  # noqa: F401

__A						:							List[compression.BaseCompressedFileFileSystem]							=  [
    compression.BzaFileSystem,
    compression.GzipFileSystem,
    compression.LzaFileSystem,
    compression.XzFileSystem,
    compression.ZstdFileSystem,
]

# Register custom filesystems
for fs_class in COMPRESSION_FILESYSTEMS + [HfFileSystem]:
		if fs_class.protocol in fsspec.registry and fsspec.registry[fs_class.protocol] is not fs_class:
				warnings.warn(f'''A filesystem protocol was already set for {fs_class.protocol} and will be overwritten.''')
		fsspec.register_implementation(fs_class.protocol, fs_class, clobber=True)
def 					lowerCamelCase_    (    SCREAMING_SNAKE_CASE   ):
			'''simple docstring'''
			if "://" in dataset_path:
						SCREAMING_SNAKE_CASE           =					dataset_path.split("""://"""   )[1]
			return dataset_path
def 					lowerCamelCase_    (    SCREAMING_SNAKE_CASE   ):
			'''simple docstring'''
			if fs is not None and fs.protocol != "file":
						return True
			else:
						return False
def 					lowerCamelCase_    (    SCREAMING_SNAKE_CASE					,	SCREAMING_SNAKE_CASE					,	SCREAMING_SNAKE_CASE   ):
			'''simple docstring'''
			SCREAMING_SNAKE_CASE           =					not is_remote_filesystem(SCREAMING_SNAKE_CASE   )
			if is_local:
						# LocalFileSystem.mv does copy + rm, it is more efficient to simply move a local directory
						shutil.move(fs._strip_protocol(SCREAMING_SNAKE_CASE   )					,	fs._strip_protocol(SCREAMING_SNAKE_CASE   )   )
			else:
						fs.mv(SCREAMING_SNAKE_CASE					,	SCREAMING_SNAKE_CASE					,	recursive=SCREAMING_SNAKE_CASE   )




def 					lowerCamelCase_    (    ):
			'''simple docstring'''
			if hasattr(fsspec.asyn					,	"""reset_lock"""   ):
						# for future fsspec>2022.05.0
						fsspec.asyn.reset_lock()
			else:
						SCREAMING_SNAKE_CASE           =					None
						SCREAMING_SNAKE_CASE           =					None
						SCREAMING_SNAKE_CASE           =					threading.Lock()






