





'''simple docstring'''

import re
from typing import Callable, List, Optional, Union

import tensorflow as tf


try:
    from tensorflow.keras.optimizers.legacy import Adam
except ImportError:
    from tensorflow.keras.optimizers import Adam







class __a (   tf.keras.optimizers.schedules.LearningRateSchedule			):





   def __init__(					self				:			List[str]				,lowerCamelCase				:			float				,lowerCamelCase				:			Callable				,lowerCamelCase				:			int				,lowerCamelCase				:			float = 1.0				,lowerCamelCase				:			str = None				,):

      '''simple docstring'''

      super().__init__()
      __SCREAMING_SNAKE_CASE      							=       initial_learning_rate
      __SCREAMING_SNAKE_CASE      							=       warmup_steps
      __SCREAMING_SNAKE_CASE      							=       power
      __SCREAMING_SNAKE_CASE      							=       decay_schedule_fn
      __SCREAMING_SNAKE_CASE      							=       name





   def __call__(					self				:			List[str]				,lowerCamelCase				:			List[str]    ):

      '''simple docstring'''

      with tf.name_scope(self.name or """WarmUp"""    ) as name:
         # Implements polynomial warmup. i.e., if global_step < warmup_steps, the
         # learning rate will be `global_step/num_warmup_steps * init_lr`.
         __SCREAMING_SNAKE_CASE      							=       tf.cast(lowerCamelCase				,tf.floataa    )
         __SCREAMING_SNAKE_CASE      							=       tf.cast(self.warmup_steps				,tf.floataa    )
         __SCREAMING_SNAKE_CASE      							=       global_step_float / warmup_steps_float
         __SCREAMING_SNAKE_CASE      							=       self.initial_learning_rate * tf.math.pow(lowerCamelCase				,self.power    )
         return tf.cond(
             global_step_float < warmup_steps_float				,lambda: warmup_learning_rate				,lambda: self.decay_schedule_fn(step - self.warmup_steps    )				,name=lowerCamelCase				,)





   def      UpperCAmelCase__     (					self				:			Any    ):

      '''simple docstring'''

      return {
          "initial_learning_rate": self.initial_learning_rate,
          "decay_schedule_fn": self.decay_schedule_fn,
          "warmup_steps": self.warmup_steps,
          "power": self.power,
          "name": self.name,
      }





def 						__magic_name__       (							__UpperCAmelCase							,	__UpperCAmelCase							,	__UpperCAmelCase							,	__UpperCAmelCase = 0.0							,	__UpperCAmelCase = 0.9							,	__UpperCAmelCase = 0.9_9_9							,	__UpperCAmelCase = 1e-8							,	__UpperCAmelCase = None							,	__UpperCAmelCase = None							,	__UpperCAmelCase = 0.0							,	__UpperCAmelCase = 1.0							,	__UpperCAmelCase = None							,	)						->					Tuple:

   '''simple docstring'''







   __SCREAMING_SNAKE_CASE      							=       tf.keras.optimizers.schedules.PolynomialDecay(
       initial_learning_rate=__UpperCAmelCase							,	decay_steps=num_train_steps - num_warmup_steps							,	end_learning_rate=init_lr * min_lr_ratio							,	power=__UpperCAmelCase							,	)
   if num_warmup_steps:
      __SCREAMING_SNAKE_CASE      							=       WarmUp(
          initial_learning_rate=__UpperCAmelCase							,	decay_schedule_fn=__UpperCAmelCase							,	warmup_steps=__UpperCAmelCase							,	)
   if weight_decay_rate > 0.0:
      __SCREAMING_SNAKE_CASE      							=       AdamWeightDecay(
          learning_rate=__UpperCAmelCase							,	weight_decay_rate=__UpperCAmelCase							,	beta_a=__UpperCAmelCase							,	beta_a=__UpperCAmelCase							,	epsilon=__UpperCAmelCase							,	clipnorm=__UpperCAmelCase							,	global_clipnorm=__UpperCAmelCase							,	exclude_from_weight_decay=["""LayerNorm""", """layer_norm""", """bias"""]							,	include_in_weight_decay=__UpperCAmelCase							,	)
   else:
      __SCREAMING_SNAKE_CASE      							=       tf.keras.optimizers.Adam(
          learning_rate=__UpperCAmelCase							,	beta_a=__UpperCAmelCase							,	beta_a=__UpperCAmelCase							,	epsilon=__UpperCAmelCase							,	clipnorm=__UpperCAmelCase							,	global_clipnorm=__UpperCAmelCase							,	)
   # We return the optimizer and the LR scheduler in order to better track the
   # evolution of the LR independently of the optimizer.
   return optimizer, lr_schedule







class __a (   _snake_case			):





   def __init__(					self				:			List[Any]				,lowerCamelCase				:			Union[float, tf.keras.optimizers.schedules.LearningRateSchedule] = 0.001				,lowerCamelCase				:			float = 0.9				,lowerCamelCase				:			float = 0.999				,lowerCamelCase				:			float = 1E-7				,lowerCamelCase				:			bool = False				,lowerCamelCase				:			float = 0.0				,lowerCamelCase				:			Optional[List[str]] = None				,lowerCamelCase				:			Optional[List[str]] = None				,lowerCamelCase				:			str = "AdamWeightDecay"				,**lowerCamelCase				:			str				,):

      '''simple docstring'''

      super().__init__(lowerCamelCase				,lowerCamelCase				,lowerCamelCase				,lowerCamelCase				,lowerCamelCase				,lowerCamelCase				,**lowerCamelCase    )
      __SCREAMING_SNAKE_CASE      							=       weight_decay_rate
      __SCREAMING_SNAKE_CASE      							=       include_in_weight_decay
      __SCREAMING_SNAKE_CASE      							=       exclude_from_weight_decay





   @classmethod
   def      UpperCAmelCase__     (					cls				:			int				,lowerCamelCase				:			Optional[int]    ):

      '''simple docstring'''

      __SCREAMING_SNAKE_CASE      							=       {"""WarmUp""": WarmUp}
      return super(lowerCamelCase				,cls    ).from_config(lowerCamelCase				,custom_objects=lowerCamelCase    )





   def      UpperCAmelCase__     (					self				:			Dict				,lowerCamelCase				:			Dict				,lowerCamelCase				:			Dict				,lowerCamelCase				:			Optional[Any]    ):

      '''simple docstring'''

      super(lowerCamelCase				,self    )._prepare_local(lowerCamelCase				,lowerCamelCase				,lowerCamelCase    )
      __SCREAMING_SNAKE_CASE      							=       tf.constant(
          self.weight_decay_rate				,name="""adam_weight_decay_rate"""    )





   def      UpperCAmelCase__     (					self				:			List[Any]				,lowerCamelCase				:			Any				,lowerCamelCase				:			Tuple				,lowerCamelCase				:			List[str]    ):

      '''simple docstring'''

      __SCREAMING_SNAKE_CASE      							=       self._do_use_weight_decay(var.name    )
      if do_decay:
         return var.assign_sub(
             learning_rate * var * apply_state[(var.device, var.dtype.base_dtype)]["""weight_decay_rate"""]				,use_locking=self._use_locking				,)
      return tf.no_op()





   def      UpperCAmelCase__     (					self				:			List[str]				,lowerCamelCase				:			int				,lowerCamelCase				:			Dict=None				,**lowerCamelCase				:			int    ):

      '''simple docstring'''

      __SCREAMING_SNAKE_CASE							,     __SCREAMING_SNAKE_CASE      							=       list(zip(*lowerCamelCase    )    )
      return super(lowerCamelCase				,self    ).apply_gradients(zip(lowerCamelCase				,lowerCamelCase    )				,name=lowerCamelCase				,**lowerCamelCase    )





   def      UpperCAmelCase__     (					self				:			List[Any]				,lowerCamelCase				:			List[str]				,lowerCamelCase				:			Optional[int]				,lowerCamelCase				:			Any    ):

      '''simple docstring'''

      if apply_state is None:
         return self._decayed_lr_t[var_dtype], {}

      __SCREAMING_SNAKE_CASE      							=       apply_state or {}
      __SCREAMING_SNAKE_CASE      							=       apply_state.get((var_device, var_dtype)    )
      if coefficients is None:
         __SCREAMING_SNAKE_CASE      							=       self._fallback_apply_state(lowerCamelCase				,lowerCamelCase    )
         __SCREAMING_SNAKE_CASE      							=       coefficients

      return coefficients["lr_t"], {"apply_state": apply_state}





   def      UpperCAmelCase__     (					self				:			List[str]				,lowerCamelCase				:			Any				,lowerCamelCase				:			Optional[Any]				,lowerCamelCase				:			List[str]=None    ):

      '''simple docstring'''

      __SCREAMING_SNAKE_CASE							,     __SCREAMING_SNAKE_CASE      							=       self._get_lr(var.device				,var.dtype.base_dtype				,lowerCamelCase    )
      __SCREAMING_SNAKE_CASE      							=       self._decay_weights_op(lowerCamelCase				,lowerCamelCase				,lowerCamelCase    )
      with tf.control_dependencies([decay]    ):
         return super(lowerCamelCase				,self    )._resource_apply_dense(lowerCamelCase				,lowerCamelCase				,**lowerCamelCase    )





   def      UpperCAmelCase__     (					self				:			Dict				,lowerCamelCase				:			Dict				,lowerCamelCase				:			int				,lowerCamelCase				:			Tuple				,lowerCamelCase				:			Union[str, Any]=None    ):

      '''simple docstring'''

      __SCREAMING_SNAKE_CASE							,     __SCREAMING_SNAKE_CASE      							=       self._get_lr(var.device				,var.dtype.base_dtype				,lowerCamelCase    )
      __SCREAMING_SNAKE_CASE      							=       self._decay_weights_op(lowerCamelCase				,lowerCamelCase				,lowerCamelCase    )
      with tf.control_dependencies([decay]    ):
         return super(lowerCamelCase				,self    )._resource_apply_sparse(lowerCamelCase				,lowerCamelCase				,lowerCamelCase				,**lowerCamelCase    )





   def      UpperCAmelCase__     (					self				:			Union[str, Any]    ):

      '''simple docstring'''

      __SCREAMING_SNAKE_CASE      							=       super().get_config()
      config.update({"""weight_decay_rate""": self.weight_decay_rate}    )
      return config





   def      UpperCAmelCase__     (					self				:			Optional[Any]				,lowerCamelCase				:			Optional[int]    ):

      '''simple docstring'''

      if self.weight_decay_rate == 0:
         return False

      if self._include_in_weight_decay:
         for r in self._include_in_weight_decay:
            if re.search(lowerCamelCase				,lowerCamelCase    ) is not None:
               return True

      if self._exclude_from_weight_decay:
         for r in self._exclude_from_weight_decay:
            if re.search(lowerCamelCase				,lowerCamelCase    ) is not None:
               return False
      return True







class __a (   _snake_case			):





   def __init__(					self				:			Any    ):

      '''simple docstring'''

      __SCREAMING_SNAKE_CASE      							=       []
      __SCREAMING_SNAKE_CASE      							=       None





   @property
   def      UpperCAmelCase__     (					self				:			int    ):

      '''simple docstring'''

      if self._accum_steps is None:
         __SCREAMING_SNAKE_CASE      							=       tf.Variable(
             tf.constant(0				,dtype=tf.intaa    )				,trainable=lowerCamelCase				,synchronization=tf.VariableSynchronization.ON_READ				,aggregation=tf.VariableAggregation.ONLY_FIRST_REPLICA				,)

      return self._accum_steps.value()





   @property
   def      UpperCAmelCase__     (					self				:			Any    ):

      '''simple docstring'''

      if not self._gradients:
         raise ValueError("""The accumulator should be called first to initialize the gradients"""    )
      return [gradient.value() if gradient is not None else gradient for gradient in self._gradients]





   def __call__(					self				:			str				,lowerCamelCase				:			Any    ):

      '''simple docstring'''

      if not self._gradients:
         __SCREAMING_SNAKE_CASE      							=       self.step  # Create the step variable.
         self._gradients.extend(
             [
                 tf.Variable(
                     tf.zeros_like(lowerCamelCase    )				,trainable=lowerCamelCase				,synchronization=tf.VariableSynchronization.ON_READ				,aggregation=tf.VariableAggregation.ONLY_FIRST_REPLICA				,)
                 if gradient is not None
                 else gradient
                 for gradient in gradients
             ]    )
      if len(lowerCamelCase    ) != len(self._gradients    ):
         raise ValueError(f"""Expected {len(self._gradients    )} gradients, but got {len(lowerCamelCase    )}"""    )

      for accum_gradient, gradient in zip(self._gradients				,lowerCamelCase    ):
         if accum_gradient is not None and gradient is not None:
            accum_gradient.assign_add(lowerCamelCase    )

      self._accum_steps.assign_add(1    )





   def      UpperCAmelCase__     (					self				:			List[Any]    ):

      '''simple docstring'''

      if not self._gradients:
         return
      self._accum_steps.assign(0    )
      for gradient in self._gradients:
         if gradient is not None:
            gradient.assign(tf.zeros_like(lowerCamelCase    )    )












'''simple docstring'''

import requests
from bsa import BeautifulSoup

def 						__magic_name__       (							__UpperCAmelCase = "AAPL"      )						->					str:

   '''simple docstring'''







   __SCREAMING_SNAKE_CASE      							=       f"""https://in.finance.yahoo.com/quote/{symbol}?s={symbol}"""
   __SCREAMING_SNAKE_CASE      							=       BeautifulSoup(requests.get(__UpperCAmelCase      ).text							,	"""html.parser"""      )
   __SCREAMING_SNAKE_CASE      							=       """My(6px) Pos(r) smartphone_Mt(6px)"""
   return soup.find("""div"""							,	class_=class_      ).find("""span"""      ).text


if __name__ == "__main__":
    for symbol in "AAPL AMZN IBM GOOG MSFT ORCL".split():
        print(F'''Current {symbol:<4} stock price is {stock_price(symbol):>8}''')





