Sets the start_at of this Shift.
        RFC 3339; shifted to location timezone + offset. Precision up to the minute is respected; seconds are truncated.

        :param start_at: The start_at of this Shift.
        :type: str
501911
def start_at(self, start_at):
        

        if start_at is None:
            raise ValueError("Invalid value for `start_at`, must not be `None`")
        if len(start_at) < 1:
            raise ValueError("Invalid value for `start_at`, length must be greater than or equal to `1`")

        self._start_at = start_at
493865
def at_time(self, time, nearest_sample=False):
        
        if nearest_sample:
            time += self.delta_t / 2.0
        return self[int((time-self.start_time)*self.sample_rate)]
295540
def on_train_begin(self, epoch:int, **kwargs:Any)->None:
        ""
        res = {'epoch':self.start_epoch} if self.start_epoch is not None else None
        self.start_epoch = ifnone(self.start_epoch, epoch)
        self.scheds = [p.scheds for p in self.phases]
        self.opt = self.learn.opt
        for k,v in self.scheds[0].items(): 
            v.restart()
            self.opt.set_stat(k, v.start)
        self.idx_s = 0
        return res
1235388
public void setStart(int index, Date value)
   {
      set(selectField(ResourceFieldLists.CUSTOM_START, index), value);
   }
941030
def set_timestamp(self, timestamp=str(datetime.datetime.utcfromtimestamp(time.time()))):
        
        self.timestamp = timestamp
904500
public void setStart(final String s) {
      SimpleDateFormat stf = new SimpleDateFormat("HH:mm:ss");
      stf.setTimeZone(TimeZone.getTimeZone("UTC"));
      try {
         start = stf.parse(s).getTime();
      } catch(ParseException ex) {
          LogLog.warn("Error parsing start value " + s, ex);
      }
  }
794396
public void setStartTime(com.google.api.ads.admanager.axis.v201811.DateTime startTime) {
        this.startTime = startTime;
    }
906457
def when(self):
        
        offset   = 0
        timeFrom = dateFrom = timeTo = dateTo = None
        fromDt   = self._getFromDt()
        if fromDt is not None:
            offset = timezone.localtime(fromDt).toordinal() - fromDt.toordinal()
            dateFrom, timeFrom = getLocalDateAndTime(fromDt.date(), self.time_from,
                                                     self.tz, dt.time.min)
            daysDelta = dt.timedelta(days=self.num_days - 1)
            dateTo, timeTo = getLocalDateAndTime(fromDt.date() + daysDelta,
                                                 self.time_to, self.tz)
        if dateFrom == dateTo:
            retval = _("{repeat} {atTime}").format(
                    repeat=self.repeat._getWhen(offset),
                    atTime=timeFormat(timeFrom, timeTo, gettext("at ")))
        else:
            localNumDays = (dateTo - dateFrom).days + 1
            retval = _("{repeat} {startFinishTime}").format(
                    repeat=self.repeat._getWhen(offset, localNumDays),
                    startFinishTime=timeFormat(timeFrom, timeTo,
                                               prefix=gettext("starting at "),
                                               infix=gettext("finishing at")))
        return retval.strip()
1245288
def set_interval(self, start, end, value, compact=False):
        
        # for each interval to render
        for i, (s, e, v) in enumerate(self.iterperiods(start, end)):
            # look at all intervals included in the current interval
            # (always at least 1)
            if i == 0:
                # if the first, set initial value to new value of range
                self.set(s, value, compact)
            else:
                # otherwise, remove intermediate key
                del self[s]

        # finish by setting the end of the interval to the previous value
        self.set(end, v, compact)
876695
public Period setStart( Date theDate,  TemporalPrecisionEnum thePrecision) {
    start = new DateTimeType(theDate, thePrecision); 
    return this; 
  }
7154
def _init_dates(self):
        
        if self.total_transactions == 0:
            return None
        self.epoch_start = Result.select(Result.epoch).order_by(Result.epoch.asc()).limit(1).get().epoch
        self.epoch_finish = Result.select(Result.epoch).order_by(Result.epoch.desc()).limit(1).get().epoch
        self.start_datetime = time.strftime('%Y-%m-%d %H:%M:%S', time.localtime(self.epoch_start))
        self.finish_datetime = time.strftime('%Y-%m-%d %H:%M:%S', time.localtime(self.epoch_finish))
1327623
def setDateTimeStart(self, dtime):
        
        self._dateStart = dtime.date()
        self._timeStart = dtime.time()
        self._allDay = False
520640
def current_offset(local_tz=None):
    
    if local_tz is None:
        local_tz = DEFAULT_LOCAL_TZ
    dt = local_tz.localize(datetime.now())
    return dt.utcoffset()
180316
def countdown_set(self, duration, start_now):
        
        log.debug("countdown => set...")
        params = {'duration': duration, 'start_now': start_now}
        self._app_exec(
            "com.lametric.countdown", "countdown.configure", params
        )
474278
public void setStart(int index, Date value)
   {
      set(selectField(AssignmentFieldLists.CUSTOM_START, index), value);
   }
1371726
def set_updated_at
      if Dynamoid::Config.timestamps && !updated_at_changed?
        self.updated_at = DateTime.now.in_time_zone(Time.zone)
      end
    end
293234
def update_start_position(self):
        ""
        x_start = self.field_array.ScanFieldData.FieldXCoordinate
        y_start = self.field_array.ScanFieldData.FieldYCoordinate

        # empty template have all fields positions set to zero
        # --> avoid overwriting start position
        if x_start != 0 and y_start != 0:
            self.properties.ScanFieldStageStartPositionX = int(x_start * 1e6) # in um
            self.properties.ScanFieldStageStartPositionY = int(y_start * 1e6)