Gets the proper handle string for a contact with the given name
194154
function handleForName(name) {
    assert(typeof name == 'string', 'name must be a string')
    return osa(name => {
        const Messages = Application('Messages')
        return Messages.buddies.whose({ name: name })[0].handle()
    })(name)
}
987840
def getCallSetByName(self, name):
        
        if name not in self._callSetNameMap:
            raise exceptions.CallSetNameNotFoundException(name)
        return self._callSetNameMap[name]
1043695
def get_handler(preferred_handler_name = nil)
      servers = %w[puma mongrel thin webrick]
      servers.unshift(preferred_handler_name) if preferred_handler_name
      
      handler = nil
      while((server_name = servers.shift) && handler === nil) do 
        begin
          handler = ::Rack::Handler.get(server_name)
        rescue LoadError
        rescue NameError
        end
      end
            
      if preferred_handler_name && server_name != preferred_handler_name
        puts "Handler '#{preferred_handler_name}' not found, using fallback ('#{server_name}')."
      end
      handler
    end
198824
def _get_span_name(servicer_context):
    """"""
    method_name = servicer_context._rpc_event.call_details.method[1:]
    if isinstance(method_name, bytes):
        method_name = method_name.decode('utf-8')
    method_name = method_name.replace('/', '.')
    return '{}.{}'.format(RECV_PREFIX, method_name)
1099707
function _getTouchEventName(eventName) {
	// Detect touch event support
	if (maps.touchEvents[eventName]) {
		eventName = maps.touchEvents[eventName];
	}
	return eventName;
}
253950
def get_name(self, name):
        """"""
        if name not in self.get_names():
            raise exceptions.NameNotFoundError('name %s not found' % name)
        return self.get_names()[name]
93504
def retrieve_prop(name):
    
    handler_get, handler_set = None, None

    if name in props_get:
        handler_get = props_get[name]
    if name in props_set:
        handler_set = props_set[name]

    return (name, handler_get, handler_set)
467558
function getShorthandName(fullname, prefix) {
    if (fullname[0] === "@") {
        let matchResult = new RegExp(`^(@[^/]+)/${prefix}$`, "u").exec(fullname);

        if (matchResult) {
            return matchResult[1];
        }

        matchResult = new RegExp(`^(@[^/]+)/${prefix}-(.+)$`, "u").exec(fullname);
        if (matchResult) {
            return `${matchResult[1]}/${matchResult[2]}`;
        }
    } else if (fullname.startsWith(`${prefix}-`)) {
        return fullname.slice(prefix.length + 1);
    }

    return fullname;
}
965010
private String computeGetterName(String name)
	{
		StringBuilder _result = new StringBuilder().append(PREFIX__GETTER);
		_result.append(Character.toUpperCase(name.charAt(0))).append(name.substring(1));
		return _result.toString();
	}
1103316
function(name) {
        var self = this, found = false;
        if (!name) { return found; }
        utils.each(this._handlers, function(i) {
            if (name === this.name) {
                self._handlers.splice(i, 1);
                return (found = true, false);
            }
        });
        if (!found) {
            utils.each(this._lastHandlers, function(i) {
                if (name === this.name) {
                    self._lastHandlers.splice(i, 1);
                    return (found = true, false);
                }
            });
        }
        return found;
    }
1085858
def get_shortcut(self, name):
        

        name = self.__normalize_name(name)
        action = self.get_action(name)
        if not action:
            return ""

        return action.shortcut().toString()
167397
@SuppressWarnings("unchecked")
  public String getString(String name) {
    return ((Value<String>) getValue(name)).get();
  }
668496
function _getRuleAsString(responders, callback){

  var respondersArr = [];

  var respondersLen = responders.length;
  var srcLen;
  var fileStr;

  responders.forEach(function(entry, i){
    respondersArr.push(TAP + '{');
    respondersArr.push(TAP + TAP + 'pattern: \'' + entry.pattern + '\',' + entry.comment);
    respondersArr.push(TAP + TAP + 'responder: {');
    respondersArr.push(TAP + TAP + TAP + 'dir: ' + '\'' + entry.responder.dir + '\',');
    respondersArr.push(TAP + TAP + TAP + 'src: [');

    srcLen = entry.responder.src.length;

    entry.responder.src.forEach(function(file, j){
      fileStr = TAP + TAP + TAP + TAP + '\'' + file + '\'';
      if(j < srcLen - 1){
        fileStr += ',';
      }
      respondersArr.push(fileStr);
    });

    respondersArr.push(TAP + TAP + TAP + ']');
    respondersArr.push(TAP + TAP + '}');

    if( i < respondersLen - 1){
      respondersArr.push(TAP + '},');
    }else{
      respondersArr.push(TAP + '}');
    }

  });

  if(typeof callback === 'function'){
    callback(null, respondersArr.join(EOL));
  }
}
745765
def __get_handle_record_if_necessary(self, handle, handlerecord_json):
        '''
        

        '''
        if handlerecord_json is None:
            handlerecord_json = self.retrieve_handle_record_json(handle)
        else:
            if handle != handlerecord_json['handle']:
                handlerecord_json = self.retrieve_handle_record_json(handle)
        return handlerecord_json
986094
def _on_request(self, name, args):
        """"""
        if IS_PYTHON3:
            name = decode_if_bytes(name)
        handler = self._request_handlers.get(name, None)
        if not handler:
            msg = self._missing_handler_error(name, 'request')
            error(msg)
            raise ErrorResponse(msg)

        debug('calling request handler for "%s", args: "%s"', name, args)
        rv = handler(*args)
        debug("request handler for '%s %s' returns: %s", name, args, rv)
        return rv
419885
def resolve_name_with_call_id(caller_id, ns, name, remappings)
      name = canonicalize_name(expand_local_name(caller_id, name))
      if remappings
        remappings.each_pair do |key, value|
          if name == canonicalize_name(key)
            name = value
          end
        end
      end
      if ns
        name = ns + SEP + name
      end
      return canonicalize_name(name)
    end
409703
def nested_handle?(context)
      (handle?(context.description) || nested_handle?(context.parent)) if context.respond_to?(:description)
    end