






"""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       _A    (__a							)				-> Optional[Any]:
    """simple docstring"""






    SCREAMING_SNAKE_CASE_   :						Dict							=	int(__a							)
    SCREAMING_SNAKE_CASE_		,    SCREAMING_SNAKE_CASE_		,    SCREAMING_SNAKE_CASE_   :						Any							=	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       _A    (__a					,       __a					,       __a					,       __a					,       __a=3_00							)				-> Union[str, Any]:
    """simple docstring"""






    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       _A    (__a							)				-> List[str]:
    """simple docstring"""






    SCREAMING_SNAKE_CASE_   :						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:
            SCREAMING_SNAKE_CASE_   :						Optional[Any]							=	f'{elt:.6f}' if isinstance(__a					,       __a							) else str(__a							)
            html_code += f'      <td>{elt}</td>\n'
        html_code += "    </tr>\n"
    html_code += "  </tbody>\n</table><p>"
    return html_code




class 							lowerCAmelCase__       :






      '''simple docstring'''

      __UpperCamelCase							=						5
      __UpperCamelCase							=						0.2
      def __init__(		self  :						List[str]		,			lowercase_  :						int		,			lowercase_  :						Optional[str] = None		,			lowercase_  :						bool = True		,			lowercase_  :						Optional["NotebookTrainingTracker"] = None		,			lowercase_  :						int = 300		,			):




          '''simple docstring'''


          SCREAMING_SNAKE_CASE_   :						Dict							=	total
          SCREAMING_SNAKE_CASE_   :						str							=	'''''' if prefix is None else prefix
          SCREAMING_SNAKE_CASE_   :						Union[str, Any]							=	leave
          SCREAMING_SNAKE_CASE_   :						Tuple							=	parent
          SCREAMING_SNAKE_CASE_   :						Union[str, Any]							=	width
          SCREAMING_SNAKE_CASE_   :						List[Any]							=	None
          SCREAMING_SNAKE_CASE_   :						Optional[int]							=	None
          SCREAMING_SNAKE_CASE_   :						List[Any]							=	None
      def _SCREAMING_SNAKE_CASE				(		self  :						Union[str, Any]		,			lowercase_  :						int		,			lowercase_  :						bool = False		,			lowercase_  :						str = None):




          '''simple docstring'''


          SCREAMING_SNAKE_CASE_   :						Optional[Any]							=	value
          if comment is not None:
              SCREAMING_SNAKE_CASE_   :						List[str]							=	comment
          if self.last_value is None:
              SCREAMING_SNAKE_CASE_   :						Optional[int]							=	time.time()
              SCREAMING_SNAKE_CASE_   :						Any							=	value
              SCREAMING_SNAKE_CASE_   :						Tuple							=	None
              SCREAMING_SNAKE_CASE_   :						Optional[Any]							=	self.warmup
              SCREAMING_SNAKE_CASE_   :						int							=	1
              self.update_bar(lowercase_)
          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_   :						Optional[Any]							=	time.time()
              SCREAMING_SNAKE_CASE_   :						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:
                  SCREAMING_SNAKE_CASE_   :						List[Any]							=	self.elapsed_time / (value - self.start_value)
              else:
                  SCREAMING_SNAKE_CASE_   :						str							=	None
              if value >= self.total:
                  SCREAMING_SNAKE_CASE_   :						Optional[Any]							=	self.total
                  SCREAMING_SNAKE_CASE_   :						Any							=	None
                  if not self.leave:
                      self.close()
              elif self.average_time_per_item is not None:
                  SCREAMING_SNAKE_CASE_   :						Optional[int]							=	self.average_time_per_item * (self.total - value)
              self.update_bar(lowercase_)
              SCREAMING_SNAKE_CASE_   :						str							=	value
              SCREAMING_SNAKE_CASE_   :						Tuple							=	current_time
              if self.average_time_per_item is None:
                  SCREAMING_SNAKE_CASE_   :						List[Any]							=	1
              else:
                  SCREAMING_SNAKE_CASE_   :						Optional[int]							=	max(int(self.update_every / self.average_time_per_item)		,			1)
      def _SCREAMING_SNAKE_CASE				(		self  :						List[Any]		,			lowercase_  :						Tuple		,			lowercase_  :						List[str]=None):




          '''simple docstring'''


          SCREAMING_SNAKE_CASE_   :						Tuple							=	''' ''' * (len(str(self.total)) - len(str(lowercase_))) + str(lowercase_)
          if self.elapsed_time is None:
              SCREAMING_SNAKE_CASE_   :						List[str]							=	F'[{spaced_value}/{self.total} : < :'
          elif self.predicted_remaining is None:
              SCREAMING_SNAKE_CASE_   :						Union[str, Any]							=	F'[{spaced_value}/{self.total} {format_time(self.elapsed_time)}'
          else:
              SCREAMING_SNAKE_CASE_   :						Optional[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 _SCREAMING_SNAKE_CASE				(		self  :						int):




          '''simple docstring'''


          SCREAMING_SNAKE_CASE_   :						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:
              SCREAMING_SNAKE_CASE_   :						List[Any]							=	disp.display(disp.HTML(self.html_code)		,			display_id=lowercase_)
          else:
              self.output.update(disp.HTML(self.html_code))



      def _SCREAMING_SNAKE_CASE				(		self  :						List[str]):




          '''simple docstring'''


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




class 							lowerCAmelCase__       (    UpperCAmelCase__				):






      '''simple docstring'''

      def __init__(		self  :						List[Any]		,			lowercase_  :						Tuple		,			lowercase_  :						Union[str, Any]=None):




          '''simple docstring'''


          super().__init__(lowercase_)
          SCREAMING_SNAKE_CASE_   :						Union[str, Any]							=	None if column_names is None else [column_names]
          SCREAMING_SNAKE_CASE_   :						List[Any]							=	None
      def _SCREAMING_SNAKE_CASE				(		self  :						Dict):




          '''simple docstring'''


          SCREAMING_SNAKE_CASE_   :						List[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:
              SCREAMING_SNAKE_CASE_   :						Dict							=	disp.display(disp.HTML(self.html_code)		,			display_id=lowercase_)
          else:
              self.output.update(disp.HTML(self.html_code))
      def _SCREAMING_SNAKE_CASE				(		self  :						Optional[int]		,			lowercase_  :						List[str]):




          '''simple docstring'''


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




          '''simple docstring'''


          SCREAMING_SNAKE_CASE_   :						Union[str, Any]							=	NotebookProgressBar(lowercase_		,			prefix=lowercase_		,			parent=self		,			width=lowercase_)
          return self.child_bar



      def _SCREAMING_SNAKE_CASE				(		self  :						List[Any]):




          '''simple docstring'''


          SCREAMING_SNAKE_CASE_   :						Optional[Any]							=	None
          self.display()




class 							lowerCAmelCase__       (    UpperCAmelCase__				):






      '''simple docstring'''

      def __init__(		self  :						Any):




          '''simple docstring'''


          SCREAMING_SNAKE_CASE_   :						List[str]							=	None
          SCREAMING_SNAKE_CASE_   :						Tuple							=	None
          SCREAMING_SNAKE_CASE_   :						List[str]							=	False
      def _SCREAMING_SNAKE_CASE				(		self  :						int		,			lowercase_  :						List[Any]		,			lowercase_  :						Optional[Any]		,			lowercase_  :						Any		,			**lowercase_  :						Any):




          '''simple docstring'''


          SCREAMING_SNAKE_CASE_   :						List[str]							=	'''Epoch''' if args.evaluation_strategy == IntervalStrategy.EPOCH else '''Step'''
          SCREAMING_SNAKE_CASE_   :						Optional[int]							=	0
          SCREAMING_SNAKE_CASE_   :						Optional[int]							=	0
          SCREAMING_SNAKE_CASE_   :						List[str]							=	[self.first_column] + ['''Training Loss''']
          if args.evaluation_strategy != IntervalStrategy.NO:
              column_names.append('''Validation Loss''')
          SCREAMING_SNAKE_CASE_   :						Optional[int]							=	NotebookTrainingTracker(state.max_steps		,			lowercase_)
      def _SCREAMING_SNAKE_CASE				(		self  :						Tuple		,			lowercase_  :						List[str]		,			lowercase_  :						Optional[Any]		,			lowercase_  :						Tuple		,			**lowercase_  :						List[Any]):




          '''simple docstring'''


          SCREAMING_SNAKE_CASE_   :						int							=	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_   :						int							=	False
      def _SCREAMING_SNAKE_CASE				(		self  :						Union[str, Any]		,			lowercase_  :						List[str]		,			lowercase_  :						List[Any]		,			lowercase_  :						str		,			lowercase_  :						Tuple=None		,			**lowercase_  :						int):




          '''simple docstring'''


          if not has_length(lowercase_):
              return
          if self.prediction_bar is None:
              if self.training_tracker is not None:
                  SCREAMING_SNAKE_CASE_   :						Dict							=	self.training_tracker.add_child(len(lowercase_))
              else:
                  SCREAMING_SNAKE_CASE_   :						Optional[Any]							=	NotebookProgressBar(len(lowercase_))
              self.prediction_bar.update(1)
          else:
              self.prediction_bar.update(self.prediction_bar.value + 1)
      def _SCREAMING_SNAKE_CASE				(		self  :						Any		,			lowercase_  :						str		,			lowercase_  :						Dict		,			lowercase_  :						str		,			**lowercase_  :						str):




          '''simple docstring'''


          if self.prediction_bar is not None:
              self.prediction_bar.close()
          SCREAMING_SNAKE_CASE_   :						Any							=	None
      def _SCREAMING_SNAKE_CASE				(		self  :						Union[str, Any]		,			lowercase_  :						List[Any]		,			lowercase_  :						Dict		,			lowercase_  :						Dict		,			lowercase_  :						Optional[int]=None		,			**lowercase_  :						List[str]):




          '''simple docstring'''


          if args.evaluation_strategy == IntervalStrategy.NO and "loss" in logs:
              SCREAMING_SNAKE_CASE_   :						int							=	{'''Training Loss''': logs['''loss''']}
              # First column is necessarily Step sine we're not in epoch eval strategy
              SCREAMING_SNAKE_CASE_   :						Optional[int]							=	state.global_step
              self.training_tracker.write_line(lowercase_)
      def _SCREAMING_SNAKE_CASE				(		self  :						Optional[Any]		,			lowercase_  :						Tuple		,			lowercase_  :						Dict		,			lowercase_  :						Union[str, Any]		,			lowercase_  :						List[Any]=None		,			**lowercase_  :						str):




          '''simple docstring'''


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

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



      def _SCREAMING_SNAKE_CASE				(		self  :						Optional[Any]		,			lowercase_  :						Dict		,			lowercase_  :						Dict		,			lowercase_  :						Dict		,			**lowercase_  :						List[Any]):




          '''simple docstring'''


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










"""simple docstring"""






from __future__ import annotations

from numpy import array, cos, cross, floataa, radians, sin
from numpy.typing import NDArray



def       _A    (__a					,       __a					,       __a = False							)				-> list[float]:
    """simple docstring"""






    if radian_mode:
        return [magnitude * cos(__a							), magnitude * sin(__a							)]
    return [magnitude * cos(radians(__a							)							), magnitude * sin(radians(__a							)							)]



def       _A    (__a					,       __a					,       __a = 10**-1							)				-> bool:
    """simple docstring"""






    SCREAMING_SNAKE_CASE_   :						NDArray[floataa]							=	cross(__a					,       __a							)
    SCREAMING_SNAKE_CASE_   :						float							=	sum(__a							)
    return abs(__a							) < eps


if __name__ == "__main__":
  # Test to check if it works
  UpperCAmelCase_     :				Union[str, Any]         =				array(
      [
          polar_force(7_1_8.4, 180 - 30),
          polar_force(8_7_9.5_4, 45),
          polar_force(100, -90),
      ]
  )

  UpperCAmelCase_     :				NDArray[floataa]         =				array([[0, 0], [0, 0], [0, 0]])

  assert in_static_equilibrium(forces, location)

  # Problem 1 in image_data/2D_problems.jpg
  UpperCAmelCase_     :				Union[str, Any]         =				array(
      [
          polar_force(30 * 9.8_1, 15),
          polar_force(215, 180 - 45),
          polar_force(264, 90 - 30),
      ]
  )

  UpperCAmelCase_     :				Optional[int]         =				array([[0, 0], [0, 0], [0, 0]])

  assert in_static_equilibrium(forces, location)

  # Problem in image_data/2D_problems_1.jpg
  UpperCAmelCase_     :				List[str]         =				array([[0, -2000], [0, -1200], [0, 15600], [0, -12400]])

  UpperCAmelCase_     :				Any         =				array([[0, 0], [6, 0], [10, 0], [12, 0]])

  assert in_static_equilibrium(forces, location)

  import doctest

  doctest.testmod()


