Sets the recording start Time

        Parameters
        ----------
        recording_start_time: datetime object
            Sets the recording start Time
964706
def setStartdatetime(self, recording_start_time):
        
        if isinstance(recording_start_time,datetime):
            self.recording_start_time = recording_start_time
        else:
            self.recording_start_time = datetime.strptime(recording_start_time,"%d %b %Y %H:%M:%S")
        self.update_header()
794396
public void setStartTime(com.google.api.ads.admanager.axis.v201811.DateTime startTime) {
        this.startTime = startTime;
    }
1184021
def get_start_time(self):
        
        start_time = c_double()
        self.library.get_start_time.argtypes = [POINTER(c_double)]
        self.library.get_start_time.restype = None
        self.library.get_start_time(byref(start_time))
        return start_time.value
195678
def start_recording(self):
        """"""
        self._recording = True
        self._stop_recording.clear()
        self._source.start()
272352
def on_episode_begin(self, episode, logs):
        
        self.episode_start[episode] = timeit.default_timer()
        self.observations[episode] = []
        self.rewards[episode] = []
        self.actions[episode] = []
        self.metrics[episode] = []
217325
def record(self):
        # type: () -> bytes
        '''
        
        '''
        if not self._initialized:
            raise pycdlibexception.PyCdlibInternalError('PD record not yet initialized!')

        return b'PD' + struct.pack('=BB', RRPDRecord.length(self.padding),
                                   SU_ENTRY_VERSION) + self.padding
1259080
private void startRecording(String line, DispatchCallback callback) {
    OutputFile outputFile = sqlLine.getRecordOutputFile();
    if (outputFile != null) {
      callback.setToFailure();
      sqlLine.error(sqlLine.loc("record-already-running", outputFile));
      return;
    }

    String filename;
    if (line.length() == "record".length()
        || (filename =
            sqlLine.dequote(line.substring("record".length() + 1))) == null) {
      sqlLine.error("Usage: record <file name>");
      callback.setToFailure();
      return;
    }

    try {
      outputFile = new OutputFile(expand(filename));
      sqlLine.setRecordOutputFile(outputFile);
      sqlLine.output(sqlLine.loc("record-started", outputFile));
      callback.setToSuccess();
    } catch (Exception e) {
      callback.setToFailure();
      sqlLine.error(e);
    }
  }
651952
def setRecord(self, record):
        
        self._record = record
        if record is not None:
            self.loadValues(record.recordValues(autoInflate=True))
        else:
            self.loadValues({})
409273
def stop_recording():
    
    global _recording
    if not _recording:
        raise ValueError('Must call "start_recording" before.')
    recorded_events_queue, hooked = _recording
    unhook(hooked)
    return list(recorded_events_queue.queue)
1301368
def start(self):
        
        if not self._start:
            self._first_start = time.perf_counter()
            self._start = self._first_start
        else:
            self._start = time.perf_counter()
644233
def on_train_begin(self, **kwargs: Any) -> None:
        ""
        self.path.parent.mkdir(parents=True, exist_ok=True)      
        self.file = self.path.open('a') if self.append else self.path.open('w')
        self.file.write(','.join(self.learn.recorder.names[:(None if self.add_time else -1)]) + '\n')
795988
def set_start(self,time,pass_to_command_line=True):
    
    if pass_to_command_line:
      self.add_var_opt('gps-start-time',time)
    self.__start = time
    self.__data_start = time
728664
def start(self, *msg):
        
        self.start_time = datetime.datetime.now()
        label = colors.purple("START")
        self._msg(label, *msg)
1127453
def _update_recording(self, frame, config):
    ''''''
    # pylint: disable=redefined-variable-type
    should_record = config['is_recording']

    if should_record:
      if not self.is_recording:
        self.is_recording = True
        logger.info(
            'Starting recording using %s',
            self.video_writer.current_output().name())
      self.video_writer.write_frame(frame)
    elif self.is_recording:
      self.is_recording = False
      self.video_writer.finish()
      logger.info('Finished recording')
208661
def start(self):
		
		tracker = self.tracker_storage()
		if tracker is not None and self.track_start() is True:
			details = self.event_details(WTrackerEvents.start)
			tracker.register_start(self, event_details=details)
		WThreadTask.start(self)
1097582
protected void sendRecordingStartedNotification(Session session, Recording recording) {
		this.recordingManager.getSessionEventsHandler().sendRecordingStartedNotification(session, recording);
	}
952833
def start_record():
    
    global record, playback, current
    if record:
        raise StateError("Already recording.")
    if playback:
        raise StateError("Currently playing back.")
    record = True
    current = ReplayData()
    install(RecordingHTTPConnection, RecordingHTTPSConnection)