code: def update(self, source_clock_sample, target_clock_sample):
          
          if self._resolved_time is None or self.source_clock_overflow_period is None:
              self._resolved_time = decimal.Decimal(source_clock_sample)
              self._prev_source_sample = source_clock_sample
              self._prev_target_sample = target_clock_sample
          else:
              # Time between updates in the target clock domain
              tgt_delta = target_clock_sample - self._prev_target_sample
              self._prev_target_sample = target_clock_sample
              assert tgt_delta >= 0
  
              # Time between updates in the source clock domain
              src_delta = source_clock_sample - self._prev_source_sample
              self._prev_source_sample = source_clock_sample
  
              # Using the target clock we can resolve the integer ambiguity (number of overflows)
              full_cycles = int(round((tgt_delta - src_delta) / float(self.source_clock_overflow_period), 0))
  
              # Updating the source clock now; in two steps, in order to avoid error accumulation in floats
              self._resolved_time += decimal.Decimal(full_cycles * self.source_clock_overflow_period)
              self._resolved_time += decimal.Decimal(src_delta)
  
          return self._resolved_time
docs: Args:
              source_clock_sample: Sample of the source clock, in seconds
              target_clock_sample: Sample of the target clock, in seconds
  
          Returns: Resolved absolute source clock value