Gets the bump info
 @private
 @return [Bump::BumpInfo]
489412
def create_bump_info
      repo = BumpInfoRepository.new @file

      begin
        bump_info = repo.from_file
      rescue Errno::ENOENT
        log_red "Error: the file `#{@file}` not found."
        return nil
      end

      bump_info
    end
922234
def bump(self):
        
        # read client
        values = self.client.mget(self.keys.indicator, self.keys.dispenser)
        indicator, dispenser = map(int, values)

        # determine active users
        numbers = range(indicator, dispenser + 1)
        keys = [self.keys.key(n) for n in numbers]
        pairs = zip(keys, self.client.mget(*keys))

        try:
            # determine number of first active user
            number = next(self.keys.number(key)
                          for key, value in pairs if value is not None)
        except:
            # set number to next result of incr on dispenser
            number = dispenser + 1

        # set indicator to it if necessary
        if number != indicator:
            self.client.set(self.keys.indicator, number)

        # announce and return it anyway
        self.announce(number)
        return number
413531
function getPushInfo()
    {
        if ($this->pushInfo == null) {
            $this->pushInfo = new PushInfo();
            $this->pushInfo->set_invalidAPN(true);
            $this->pushInfo->set_invalidMPN(true);
        }

        return $this->pushInfo;
    }
1309010
def getBumper(self):
        '''
        

        '''
        if self.hasproxy():
            self.lock.acquire()
            bumper = self.bumper
            self.lock.release()
            return bumper

        return None
72796
def get_all_triggers(bump, file_triggers):
    """"""
    triggers = set()
    if file_triggers:
        triggers = triggers.union(detect_file_triggers(config.trigger_patterns))
    if bump:
        _LOG.debug("trigger: %s bump requested", bump)
        triggers.add(bump)
    return triggers
746354
def get_info(cls):
        
        return '\n'.join(
            [str(cls._instances[key]) for key in cls._instances]
        )
1106607
def get_raw(self):
        
        return [self.name, self.size, self.last_modified, self.location]
1013490
def index data
      current = @first
      i = 0
      while !current.nil?
        return i if current.data == data
        current = current.next
        i += 1
      end
      nil
    end
597269
function() {
			this._commitUndo();
			var changes = [];
			for (var i=this.index; i >= 0; i--) {
				changes = changes.concat(this.stack[i].getUndoChanges());
			}
			return changes;
		}
506943
def bumpversion(self, part, commit=True, tag=False, message=None,
                    allow_dirty=False):
        
        import bumpversion

        args = (
            (['--verbose'] if self.verbose > 1 else []) +
            (['--allow-dirty'] if allow_dirty else []) +
            (['--commit'] if commit else ['--no-commit']) +
            (['--tag'] if tag else ['--no-tag']) +
            (['--message', message] if message is not None else []) +
            ['--list', part]
        )
        log.debug(
            "$ bumpversion %s" % " ".join(a.replace(" ", "\\ ") for a in args))

        with capture_logger("bumpversion.list") as out:
            bumpversion.main(args)

        last_line = out.getvalue().splitlines()[-1]
        new_version = last_line.replace("new_version=", "")
        return new_version
116416
def _mod_info(modname, toskip=[], onlylocals=True):
    

    hascls = hasfunc = False

    for localnm, fqnm, obj in zip(*find_mod_objs(modname, onlylocals=onlylocals)):
        if localnm not in toskip:
            hascls = hascls or inspect.isclass(obj)
            hasfunc = hasfunc or inspect.isroutine(obj)
            if hascls and hasfunc:
                break

    # find_mod_objs has already imported modname
    # TODO: There is probably a cleaner way to do this, though this is pretty
    # reliable for all Python versions for most cases that we care about.
    pkg = sys.modules[modname]
    ispkg = (hasattr(pkg, '__file__') and isinstance(pkg.__file__, str) and
             os.path.split(pkg.__file__)[1].startswith('__init__.py'))

    return ispkg, hascls, hasfunc
66499
def info(version=nil, &block)
      if version.nil?
        if block_given?
          @global_info.instance_eval(&block)
        else
          @global_info
        end
      else
        i = @infos[version]
        if block_given?
          i.instance_eval(&block)
        end
        i
      end
    end
214826
private synchronized float getInternal() {
    int phaseCount = phases.size();
    if (phaseCount != 0) {
      float subProgress =
        currentPhase < phaseCount ? phase().getInternal() : 0.0f;
      return progressPerPhase*(currentPhase + subProgress);
    } else {
      return progress;
    }
  }
1058118
public Map<String, Object> getDebugInfo()
  {
    long currTime = System.currentTimeMillis();

    Object notSuccessfullySyncedFor;
    if (lastSuccessfulSyncTime == 0) {
      notSuccessfullySyncedFor = "Never Successfully Synced";
    } else {
      notSuccessfullySyncedFor = (currTime - lastSuccessfulSyncTime) / 1000;
    }
    return ImmutableMap.of(
        "notSyncedForSecs", lastSyncTime == 0 ? "Never Synced" : (currTime - lastSyncTime) / 1000,
        "notSuccessfullySyncedFor", notSuccessfullySyncedFor,
        "consecutiveFailedAttemptCount", consecutiveFailedAttemptCount,
        "syncScheduled", startStopLock.isStarted()
    );
  }
439434
public static StackInfo getStack() {
		 StackInfo result = MDC.get();
		 return result == null ? new StackInfo() : result;
	 }
1229234
def inspect
      result = "#{self.class}["
      each_with_index { |obj, i| result << ', ' if i > 0; result << obj.inspect }
      return result << "]"
    end
762473
def element_info(cls_or_slf, node, siblings, level, value_dims):
        
        info = cls_or_slf.component_type(node)
        if len(node.kdims) >= 1:
            info += cls_or_slf.tab + '[%s]' % ','.join(d.name for d in node.kdims)
        if value_dims and len(node.vdims) >= 1:
            info += cls_or_slf.tab + '(%s)' % ','.join(d.name for d in node.vdims)
        return level, [(level, info)]