get the value from pass identified by 'entry'
195773
def get(self, entry):
        
        try:
            output = yield utils.getProcessOutput(
                "pass",
                args=[entry],
                env=self._env
            )
            return output.decode("utf-8", "ignore").splitlines()[0]
        except IOError:
            return None
856154
def get_value(self, key):
        """"""
        for title in _TITLES.get(key, ()) + (key,):
            try:
                value = [entry['lastMeasurement']['value'] for entry in
                         self.data['sensors'] if entry['title'] == title][0]
                return value
            except IndexError:
                pass
        return None
5017
def _GetValue(self, name):
    """"""
    for value in self.values:
      if value.name == name:
        return value
1158629
Map getPassThruProps() {
        if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
            SibTr.entry(this, tc, "getPassThruProps");
        if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
            SibTr.exit(this, tc, "getPassThruProps", passThruProps);
        return passThruProps;
    }
412912
def getpass(self, prompt, default=None):
        """"""
        return click.prompt(prompt, hide_input=True, default=default)
566012
def value(self):
    
    if not self.filled:
      raise SlotNotFilledError('Slot with name "%s", key "%s" not yet filled.'
                               % (self.name, self.key))
    return self._value
994809
def entry_key(*entry):
    """"""
    if len(entry) == 1:
        return (entry[0].path, entry[0].stage)
    else:
        return tuple(entry)
211662
def get_env_pass(self,
	                 user=None,
	                 msg=None,
	                 shutit_pexpect_child=None,
	                 note=None):
		
		shutit_global.shutit_global_object.yield_to_draw()
		shutit_pexpect_child = shutit_pexpect_child or self.get_current_shutit_pexpect_session().pexpect_child
		shutit_pexpect_session = self.get_shutit_pexpect_session_from_child(shutit_pexpect_child)
		return shutit_pexpect_session.get_env_pass(user=user,
		                                           msg=msg,
		                                           note=note)
694959
def get_active_entry(user, select_for_update=False):
    """"""
    entries = apps.get_model('entries', 'Entry').no_join
    if select_for_update:
        entries = entries.select_for_update()
    entries = entries.filter(user=user, end_time__isnull=True)

    if not entries.exists():
        return None
    if entries.count() > 1:
        raise ActiveEntryError('Only one active entry is allowed.')
    return entries[0]
1333122
def process_entry(self, entry):
        
        try:
            corrections = self.get_corrections_dict(entry)
        except CompatibilityError:
            return None
        entry.correction = sum(corrections.values())
        return entry
852184
def _get_num_pass(data, n):
    
    numpass = tz.get_in(["config", "algorithm", "ensemble", "numpass"], data)
    if numpass:
        return int(numpass)
    trusted_pct = tz.get_in(["config", "algorithm", "ensemble", "trusted_pct"], data)
    if trusted_pct:
        return int(math.ceil(float(trusted_pct) * n))
    return 2
586914
private SerializableProtectedString getKeyPassword(String alias) {
        if (TraceComponent.isAnyTracingEnabled() && tc.isDebugEnabled())
            Tr.debug(tc, "getKeyPassword " + alias);

        SerializableProtectedString keyPass = certAliasInfo.get(alias);
        if (keyPass != null) {
            if (TraceComponent.isAnyTracingEnabled() && tc.isDebugEnabled())
                Tr.debug(tc, "getKeyPassword entry found.");
        } else {
            if (TraceComponent.isAnyTracingEnabled() && tc.isDebugEnabled())
                Tr.debug(tc, "getKeyPassword -> null");
        }
        return keyPass;
    }
404217
def _convert_entry(self, entry):
        """"""
        result = {}
        for key, value in entry.items():
            if isinstance(value, list):
                result[key] = [self._convert_field(key, val) for val in value]
            else:
                result[key] = self._convert_field(key, value)
        return result
67593
def get_value(self,
                  entry_name: Text,
                  entry_lines: Sequence[Text]) -> Optional[Text]:
        """"""
        raw_value = self._get_raw(entry_name, entry_lines)
        if raw_value is not None:
            return raw_value[self._prefix_length:]
        else:
            return None
777464
def get_query_param(request, key):
    """"""
    value = request.query_params.get(key) or request.data.get(key)
    if value is None:
        raise KeyError()
    return value
37353
def get_config_var_entry(self, index):
        """"""

        if index == 0 or index > len(self.config_database.entries):
            return [Error.INVALID_ARRAY_KEY, 0, 0, 0, b'\0'*8, 0, 0]

        entry = self.config_database.entries[index - 1]
        if not entry.valid:
            return [ConfigDatabaseError.OBSOLETE_ENTRY, 0, 0, 0, b'\0'*8, 0, 0]

        offset = sum(x.data_space() for x in self.config_database.entries[:index - 1])
        return [Error.NO_ERROR, self.config_database.ENTRY_MAGIC, offset, entry.data_space(), entry.target.encode(), 0xFF, 0]
435636
function fetch_entry() {
		$result = $this->stmt->fetch(\PDO::FETCH_ASSOC);

		if ($result === false) {
			return null;
		}
		else { // succesfully retrieved statement
			return $result;
		}
	}