then=time.time()
    print '>> loading CMU for MetricalParser...'
    sylcmu = pkl.load(open(os.path.join(dir_root,'Pickle Jar/sylcmu.pkl')))
    now=time.time()
    print '>> done loading in',round(now-then,2),'seconds'
326233
def set_paths(dir_root='.'):
    global DIR_ROOT,sylcmu
    DIR_ROOT = dir_root
    os.environ['STANFORD_PARSER'] = os.path.join(dir_root,'StanfordLibrary/stanford-parser-full-%s/stanford-parser.jar' % DATE)
    os.environ['STANFORD_MODELS'] = os.path.join(dir_root,'StanfordLibrary/stanford-parser-full-%s/stanford-parser-%s-models.jar' % (DATE, MODELS_VERSION))
    os.environ['STANFORD_EJML']   = os.path.join(dir_root,'StanfordLibrary/stanford-parser-full-%s/ejml-%s.jar' % (DATE, EJML_VERSION))

    
    sylcmu = {}
1202019
def timethis(func):
    """"""
    func_module, func_name = func.__module__, func.__name__

    @functools.wraps(func)
    def wrapper(*args, **kwargs):
        start = _time_perf_counter()
        r = func(*args, **kwargs)
        end = _time_perf_counter()
        print('timethis : <{}.{}> : {}'.format(func_module, func_name, end - start))
        return r
    return wrapper
266193
def until(time):
    
    end = time

    # Convert datetime to unix timestamp and adjust for locality
    if isinstance(time, datetime):
        zoneDiff = pytime.time() - (datetime.now()- datetime(1970, 1, 1)).total_seconds()
        end = (time - datetime(1970, 1, 1)).total_seconds() + zoneDiff

    # Type check
    if not isinstance(end, (int, float)):
        raise Exception('The time parameter is not a number or datetime object')

    # Now we wait
    while True:
        now = pytime.time()
        diff = end - now

        #
        # Time is up!
        #
        if diff <= 0:
            break
        else:
            # 'logarithmic' sleeping to minimize loop iterations
            sleep(diff / 2)
22468
def QA_util_calc_time(func, *args, **kwargs):
    
    _time = datetime.datetime.now()
    func(*args, **kwargs)
    print(datetime.datetime.now() - _time)
354125
def from_time(cls, source):
        
        return cls(hours=source.hour, minutes=source.minute,
            seconds=source.second, milliseconds=source.microsecond // 1000)
208912
def runnable? time
      result = [:minute,:hour,:day,:dow,:month].map{|ct|
        if self[ct] == true then
          true
        else
          case ct
          when :month,:day,:hour
            val = time.send(ct)
          when :dow
            val = time.wday
          when :minute
            val = time.min
          end

          case self[ct]
          when Numeric # Should be Fixnum
            self[ct] == val
          else # Assume array-like thing...
            self[ct].include?(val)
          end
        end
      }
      # Everything should be true to make us eligible for running:
      [result.inject(true){|s,v| s && v},result]
    end
432079
def ready(self):
        
        logger = self.get_logger()
        now = current_ts()
        logger.trace("Current time: {0}".format(now))
        logger.trace("Last Run: {0}".format(self._last_run))
        delta = (now - self._last_run)
        logger.trace("Delta: {0}, Interval: {1}"
                     .format(delta, self.interval * 1000))
        return delta > self.interval * 1000
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))
1074295
def next(time, base)
      current = time
      until match?(current, base) && current > time
        pot_next = align(potential_next(current, base), base)
        pot_next += min_step if pot_next == current

        current = pot_next
      end

      current
    end
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
409851
def timeit(method):
    """"""

    import datetime

    @functools.wraps(method)
    def timed_method(self, rinput):

        time_start = datetime.datetime.utcnow()
        result = method(self, rinput)
        time_end = datetime.datetime.utcnow()
        result.time_it(time_start, time_end)
        self.logger.info('total time measured')
        return result

    return timed_method
167075
def now(tzinfo=True):
    
    if dj_now:
        return dj_now()

    if tzinfo:
        # timeit shows that datetime.now(tz=utc) is 24% slower
        return datetime.utcnow().replace(tzinfo=utc)
    return datetime.now()
377341
def ctime(message=None):
    ""
    global t_elapsed
    t_elapsed = 0.0
    print('\n')
    t = time.time()
    yield
    if message:
        print(message + ":  ", end='')
    t_elapsed = time.time() - t
    print(round(t_elapsed, 4), "sec")
1334288
def timesince(self, now=None):
        
        return djtimesince(self.timestamp, now).encode('utf8').replace(b'\xc2\xa0', b' ').decode('utf8')
361918
def then(self, *args):
		
		ret = self.__class__(*self._args, **self._kwargs)
		ret.callback = args
		ret.times = self.times
		return ret
227614
def timeit(metric, func, *args, **kwargs):
    
    return _client.timeit(metric, func, *args, **kwargs)
1193029
function (time) {
            last = now;
            now = time;
            delta = (now - last);

            // fix for negative timestamp returned by wechat or chrome on startup
            if (delta < 0) {
                delta = 0;
            }

            // get the game tick
            api.tick = (delta > minstep && me.sys.interpolation) ? delta / step : 1;

            for (var i = 0, len = timers.length; i < len; i++) {
                var _timer = timers[i];
                if (!(_timer.pauseable && me.state.isPaused())) {
                    _timer.elapsed += delta;
                }
                if (_timer.elapsed >= _timer.delay) {
                    _timer.fn.apply(null, _timer.args);
                    if (_timer.repeat === true) {
                        _timer.elapsed -= _timer.delay;
                    } else {
                        me.timer.clearTimeout(_timer.timerId);
                    }
                }
            }
        }