Get initial yield value, or result of send(name) if name given.
8445
def get(self, name=None):
        """"""
        if name is None:
            return self.init_value
        elif not self.support_name:
            msg = "generator does not support get-by-name: function {!r}"
            raise TypeError(msg.format(self.function))
        try:
            value = self.generator.send(name)
        except StopIteration:
            msg = "generator didn't yield: function {!r}"
            raise RuntimeError(msg.format(self.function))
        return value
1063148
def get_index_by_name(self, name):
        """"""
        for i in range(self.n_blocks):
            if self.get_block_name(i) == name:
                return i
        raise KeyError('Block name ({}) not found'.format(name))
985909
def get_value(self, name):
        """"""
        code = u"get_ipython().kernel.get_value('%s')" % name
        if self._reading:
            method = self.kernel_client.input
            code = u'!' + code
        else:
            method = self.silent_execute

        # Wait until the kernel returns the value
        wait_loop = QEventLoop()
        self.sig_got_reply.connect(wait_loop.quit)
        method(code)
        wait_loop.exec_()

        # Remove loop connection and loop
        self.sig_got_reply.disconnect(wait_loop.quit)
        wait_loop = None

        # Handle exceptions
        if self._kernel_value is None:
            if self._kernel_reply:
                msg = self._kernel_reply[:]
                self._kernel_reply = None
                raise ValueError(msg)

        return self._kernel_value
694438
private String getInitials(String name)
   {
      String result = null;

      if (name != null && name.length() != 0)
      {
         StringBuilder sb = new StringBuilder();
         sb.append(name.charAt(0));
         int index = 1;
         while (true)
         {
            index = name.indexOf(' ', index);
            if (index == -1)
            {
               break;
            }

            ++index;
            if (index < name.length() && name.charAt(index) != ' ')
            {
               sb.append(name.charAt(index));
            }

            ++index;
         }

         result = sb.toString();
      }

      return result;
   }
428845
def get_initial(self):
        '''
        
        '''
        initial = super(SendEmailView, self).get_initial()

        form_data = self.request.session.get(EMAIL_VALIDATION_STR, {}).get('form_data', {})
        if form_data:
            initial.update(form_data)
        return initial
62750
def get_value(self, name):
        """"""
        ns = self._get_current_namespace()
        value = ns[name]
        try:
            self.send_spyder_msg('data', data=value)
        except:
            # * There is no need to inform users about
            #   these errors.
            # * value = None makes Spyder to ignore
            #   petitions to display a value
            self.send_spyder_msg('data', data=None)
        self._do_publish_pdb_state = False
546480
def get_initial(self, form, name):
        

        if hasattr(form, 'initial'):
            return form.initial.get(name, None)
        return None
544836
def get_local(self, name, recurse=True):
        
        self._dlog("getting local '{}'".format(name))
        return self._search("vars", name, recurse)
892745
def _var_uint_field_handler(handler, ctx):
    
    _, self = yield
    queue = ctx.queue
    value = 0
    while True:
        if len(queue) == 0:
            # We don't know when the field ends, so read at least one byte.
            yield ctx.read_data_transition(1, self)
        octet = queue.read_byte()
        value <<= _VAR_INT_VALUE_BITS
        value |= octet & _VAR_INT_VALUE_MASK
        if octet & _VAR_INT_SIGNAL_MASK:
            break
    yield ctx.immediate_transition(handler(value, ctx))
697788
public String getValue(String name) {
		String result = null;
		for (InitParam initParam : initParams) {
			if (initParam.getName().equals(name)) {
				result = initParam.getValue();
				break;
			}
		}
		return result;
	}
544949
def send(self, data, **kws):
        """"""
        return yield_(Send(self, data, timeout=self._timeout, **kws))
1216706
def get_parameter(self, name):
        """"""
        default_value = "$%!)(INVALID)(!%$"
        value = self.lib.tdGetDeviceParameter(self.id, name, default_value)
        if value == default_value:
            raise AttributeError(name)
        return value
446265
def get_value(self, field):
        '''
        
        '''
        if field not in self._field_generators:
            self._field_generators[field] = self.get_generator(field)
        generator = self._field_generators[field]
        if generator is None:
            return self.IGNORE_FIELD
        value = generator()
        return value
549042
def get_value(self, name):
        """"""
        value = self.shellwidget.get_value(name)
        # Reset temporal variable where value is saved to
        # save memory
        self.shellwidget._kernel_value = None
        return value
923414
def getrec(self, name, include_self=True, *default):
        """"""
        for node in self.iter_up(include_self):
            try:
                return getattr(node, name)
            except AttributeError: pass
            
        if default:
            return default[0]
        else:
            raise AttributeError(name)
238635
def element(self, name, attrs=None):
    """"""
    self.open(name, attrs)
    yield
    self.close()
1203717
def _get_var_name(self, name, fresh=False):
        
        if name not in self._var_name_mappers:
            self._var_name_mappers[name] = VariableNamer(name)

        if fresh:
            var_name = self._var_name_mappers[name].get_next()
        else:
            var_name = self._var_name_mappers[name].get_current()

        return var_name