Determines when has this process started running.

        @rtype:  win32.SYSTEMTIME
        @return: Process start time.
328379
def get_start_time(self):
        
        if win32.PROCESS_ALL_ACCESS == win32.PROCESS_ALL_ACCESS_VISTA:
            dwAccess = win32.PROCESS_QUERY_LIMITED_INFORMATION
        else:
            dwAccess = win32.PROCESS_QUERY_INFORMATION
        hProcess = self.get_handle(dwAccess)
        CreationTime = win32.GetProcessTimes(hProcess)[0]
        return win32.FileTimeToSystemTime(CreationTime)
534326
def before_start(self, when=None):
        
        if when is None:
            when = datetime.now()

        return self._val[0] > when
466242
def get_time():
    '''
    
    '''
    ret = salt.utils.mac_utils.execute_return_result('systemsetup -gettime')
    return salt.utils.mac_utils.parse_return(ret)
169535
def start(self, interval_s):
    
    if self.running:
      return False

    self.stopped.clear()

    def _execute():
      # Always execute immediately once
      if not self.method() and self.stop_if_false:
        return
      while not self.stopped.wait(interval_s):
        if not self.method() and self.stop_if_false:
          return

    self.thread = threading.Thread(target=_execute)
    self.thread.daemon = True
    self.thread.start()
    return True
505147
def is_running(self):
        

        if self._process:
            if self._process.returncode is None:
                return True
            else:
                self._process = None
        return False
935551
def status(self):
        
        myNow = timezone.localtime(timezone=self.tz)
        if getAwareDatetime(self.date_to, self.time_to, self.tz) < myNow:
            return "finished"
        elif getAwareDatetime(self.date_from, self.time_from, self.tz) < myNow:
            return "started"
33229
def __start(self):
        
        logging.debug("starting %i" % id(self))
        self.__kill_if_not_shut_properly()
        self.FNULL = open(os.devnull, 'w')
        flags = self.__flags()
        cmd = [hoverfly] + flags
        if self._showCmd:
            print(cmd)
        self._process = Popen(
            [hoverfly] +
            flags,
            stdin=self.FNULL,
            stdout=self.FNULL,
            stderr=subprocess.STDOUT)
        start = time.time()
        while time.time() - start < 1:
            try:
                url = "http://%s:%i/api/health" % (self._host, self._adminPort)
                r = self._session.get(url)
                j = r.json()
                up = "message" in j and "healthy" in j["message"]
                if up:
                    logging.debug("has pid %i" % self._process.pid)
                    self.__writepid(self._process.pid)
                    return self._process
                else:
                    time.sleep(1/100.0)
            except:
                # import traceback
                # traceback.print_exc()
                # wait 10 ms before trying again
                time.sleep(1/100.0)
                pass

        logging.error("Could not start hoverfly!")
        raise ValueError("Could not start hoverfly!")
199464
def main():
    
    start_time = datetime.now()
    output_q = Queue(maxsize=20)

    procs = []
    for a_device in devices:
        my_proc = Process(target=show_version_queue, args=(a_device, output_q))
        my_proc.start()
        procs.append(my_proc)

    # Make sure all processes have finished
    for a_proc in procs:
        a_proc.join()

    while not output_q.empty():
        my_dict = output_q.get()
        for k, val in my_dict.items():
            print(k)
            print(val)

    print("\nElapsed time: " + str(datetime.now() - start_time))
867789
def is_running(self):
        
        pp = self.pid
        if pp:
            try:
                proc = psutil.Process(pp)

                # Possible status:
                # "STATUS_RUNNING", "STATUS_IDLE",
                # "STATUS_SLEEPING", "STATUS_DISK_SLEEP",
                # "STATUS_STOPPED", "STATUS_TRACING_STOP",
                # "STATUS_ZOMBIE", "STATUS_DEAD",
                # "STATUS_WAKING", "STATUS_LOCKED",

                if proc.status in (psutil.STATUS_STOPPED,
                                   psutil.STATUS_DEAD,
                                   psutil.STATUS_ZOMBIE):
                    # The PID is still in the process table so call stop to
                    # remove the PID.
                    self.stop()
                    return False
                else:
                    # OK, it's running.
                    return True

            except psutil.NoSuchProcess:
                pass
        return False
928738
public Calendar getStart() {
		Calendar cal = Calendar.getInstance();
		cal.setTimeInMillis(start);
		return cal;
	}
903521
def main():
    
    now = datetime.datetime.now
    try:
        while True:
            sys.stdout.write(str(now()) + ' ')
            time.sleep(1)
    except KeyboardInterrupt:
        pass
    except IOError as exc:
        if exc.errno != errno.EPIPE:
            raise
657176
def start(self):
        
        if self._timer.isActive():
            return

        self._starttime = datetime.datetime.now()
        self._timer.start()
842006
async def runOnceNicely(self):
        
        start = time.perf_counter()
        msgsProcessed = await self.prodAllOnce()
        if msgsProcessed == 0:
            # if no let other stuff run
            await asyncio.sleep(0.01, loop=self.loop)
        dur = time.perf_counter() - start
        if dur >= 15:
            logger.info("it took {:.3f} seconds to run once nicely".
                        format(dur), extra={"cli": False})
68564
def duration(self):
        
        if not self.started:
            return None
        start = self.started
        end = self.completed
        if not end:
            end = datetime.utcnow()
        return end - start
1181521
def get_std_start_date(self):
        
        first, _ = self._val
        if first != datetime.min and first != datetime.max:
            return first.strftime("%Y-%m-%d %H:%M:%S")
        else:
            return ""
23979
def is_running(self) -> bool:
        """"""
        if self._proc is None or self._proc.returncode is not None:
            return False
        return True
947960
def start(self):
        
        if not self._is_running:
            self._do_run = True
            self._thread.start()
        return self