Generate the name of the request.
518614
def request_name(self):
        """"""
        if self.static and not self.uses_request:
            return 'Empty'

        if not self.uses_request:
            return None

        if isinstance(self.uses_request, str):
            return self.uses_request

        return to_camel_case(self.name) + "Request"
840607
def get_name(self, r):
        """"""
        namer = ResourceNameAdapters[self.manager.resource_type.service]
        return namer(r)
859635
def name(self):
        """"""
        if self._path:
            # follow h5py convention: add leading slash
            name = self._path
            if name[0] != '/':
                name = '/' + name
            return name
        return '/'
1110131
def make_name(self):
        """"""
        if self.title:
            self.name = six.text_type(make_name(self.title_for_name, maxlength=self.__name_length__))
1342926
protected function provideName()
    {
        $bt_len = 10;
        $backtrace = debug_backtrace(null, $bt_len);
        $str = '';
        for ($id = 2; $id < $bt_len; $id++) {
            $trace = isset($backtrace[$id]) ? $backtrace[$id] : [];
            if (empty($trace['class']) || !$this instanceof $trace['class']) {
                # may be closure
                if (isset($trace['file'], $trace['line'])) {
                    $str .= $trace['file'] . $trace['line'];
                }
            }
        }
        $this->config->setName(substr(md5($str), 0, 16));
    }
528283
private String generateSafeMethodName(StorableInfo info, String prefix) {
        Class type = info.getStorableType();

        // Try a few times to generate a unique name. There's nothing special
        // about choosing 100 as the limit.
        int value = 0;
        for (int i = 0; i < 100; i++) {
            String name = prefix + value;
            if (!methodExists(type, name)) {
                return name;
            }
            value = name.hashCode();
        }

        throw new InternalError("Unable to create unique method name starting with: "
                + prefix);
    }
192035
def generate_file_name(self):
        """"""
        if not self.project:
            raise UnderDefined("project name not given")

        out_data_dir = prms.Paths.outdatadir
        project_dir = os.path.join(out_data_dir, self.project)
        file_name = "cellpy_batch_%s.json" % self.name
        self.file_name = os.path.join(project_dir, file_name)
873599
def name(self, name=None):
        """"""

        if name is None:
            return self._name
        else:
            if not isinstance(name, str) and name is not None:
                raise TypeError("name must be str, not '%s'" % str(name))
            self._name = name
434335
function setname(req, res) {
  req.conn.client.name = req.args[0];
  res.send(null, Constants.OK);
}
1345867
public function generateRequest()
    {
        if (!$this->confirm('Do you want to create form request classes?')) {
            return;
        }

        foreach (['Create', 'Update'] as $request) {
            $name = $this->getPrefix('/').$this->getEntities().'/'.$request.Str::studly($this->getEntity()).'Request';

            $this->console->call('generate:request', [
                'name' => $name,
                '--scaffold' => true,
                '--auth' => true,
                '--rules' => $this->existing() ? $this->getTableDumper()->toSchema() : $this->getFields(),
                '--force' => $this->console->option('force'),
            ]);
        }
    }
1209836
def name(self):
        """"""
        if self.path:
            # follow h5py convention: add leading slash
            name = self.path
            if name[0] != '/':
                name = '/' + name
            return name
        return None
1189410
def get_api_name(self, func):
        """'"""
        words = func.__name__.split('_')
        words = [w.capitalize() for w in words]
        return ' '.join(words)
531336
def get_site_name(request):
    
    urlparts = request.urlparts
    return ':'.join([urlparts.hostname, str(urlparts.port)])
597945
def write_name (self, url_data):
        """"""
        args = (self.part("name"), cgi.escape(url_data.name))
        self.writeln(u"<tr><td>%s</td><td>`%s'</td></tr>" % args)
563928
public String getName() {
        String result = super.getName();

        if (result == null) {
            switch (this.code) {
                case 100:
                    result = "Continue";
                    break;
                case 101:
                    result = "Switching Protocols";
                    break;
                case 102:
                    result = "Processing";
                    break;

                case 200:
                    result = "OK";
                    break;
                case 201:
                    result = "Created";
                    break;
                case 202:
                    result = "Accepted";
                    break;
                case 203:
                    result = "Non-Authoritative Information";
                    break;
                case 204:
                    result = "No Content";
                    break;
                case 205:
                    result = "Reset Content";
                    break;
                case 206:
                    result = "Partial Content";
                    break;
                case 207:
                    result = "Multi-Status";
                    break;

                case 300:
                    result = "Multiple Choices";
                    break;
                case 301:
                    result = "Moved Permanently";
                    break;
                case 302:
                    result = "Found";
                    break;
                case 303:
                    result = "See Other";
                    break;
                case 304:
                    result = "Not Modified";
                    break;
                case 305:
                    result = "Use Proxy";
                    break;
                case 307:
                    result = "Temporary Redirect";
                    break;

                case 400:
                    result = "Bad Request";
                    break;
                case 401:
                    result = "Unauthorized";
                    break;
                case 402:
                    result = "Payment Required";
                    break;
                case 403:
                    result = "Forbidden";
                    break;
                case 404:
                    result = "Not Found";
                    break;
                case 405:
                    result = "Method Not Allowed";
                    break;
                case 406:
                    result = "Not Acceptable";
                    break;
                case 407:
                    result = "Proxy Authentication Required";
                    break;
                case 408:
                    result = "Request Timeout";
                    break;
                case 409:
                    result = "Conflict";
                    break;
                case 410:
                    result = "Gone";
                    break;
                case 411:
                    result = "Length Required";
                    break;
                case 412:
                    result = "Precondition Failed";
                    break;
                case 413:
                    result = "Request Entity Too Large";
                    break;
                case 414:
                    result = "Request URI Too Long";
                    break;
                case 415:
                    result = "Unsupported Media Type";
                    break;
                case 416:
                    result = "Requested Range Not Satisfiable";
                    break;
                case 417:
                    result = "Expectation Failed";
                    break;
                case 422:
                    result = "Unprocessable Entity";
                    break;
                case 423:
                    result = "Locked";
                    break;
                case 424:
                    result = "Failed Dependency";
                    break;

                case 500:
                    result = "Internal Server Error";
                    break;
                case 501:
                    result = "Not Implemented";
                    break;
                case 502:
                    result = "Bad Gateway";
                    break;
                case 503:
                    result = "Service Unavailable";
                    break;
                case 504:
                    result = "Gateway Timeout";
                    break;
                case 505:
                    result = "Version Not Supported";
                    break;
                case 507:
                    result = "Insufficient Storage";
                    break;

                case 1000:
                    result = "Connection Error";
                    break;
                case 1001:
                    result = "Communication Error";
                    break;
                case 1002:
                    result = "Internal Connector Error";
                    break;
            }
        }

        return result;
    }
176609
def get_name(self, origin=None):
        """"""

        token = self.get()
        if not token.is_identifier():
            raise dns.exception.SyntaxError('expecting an identifier')
        return dns.name.from_text(token.value, origin)
1059737
def _get_name_from_url(self, request):
        

        format = request.GET.get('format', None)
        if not format:
            match = self._format_query_pattern.match(request.path)
            if match and match.group('format'):
                format = match.group('format')
        return format