The url ``str`` for :tl:`KeyboardButtonUrl` objects.
511221
def url(self):
        """"""
        if isinstance(self.button, types.KeyboardButtonUrl):
            return self.button.url
224251
def on_text_url(self, event):
        ''''''
        try:
            import webbrowser
        except ImportError:
            return
        mouse_event = event.GetMouseEvent()
        if mouse_event.LeftDClick():
            url_start = event.GetURLStart()
            url_end = event.GetURLEnd()
            url = self.control.GetRange(url_start, url_end)
            try:
                # attempt to use google-chrome
                browser_controller = webbrowser.get('google-chrome')
                browser_controller.open_new_tab(url)
            except webbrowser.Error:
                # use the system configured default browser
                webbrowser.open_new_tab(url)
1155570
def url(self) -> str:
        
        url_str = self.parse_url.path or ""
        if self.parse_url.querystring is not None:
            url_str += "?" + self.parse_url.querystring
        return url_str
1372543
async def get_url(self):
        
        if self.type == ChatType.PRIVATE:
            return f"tg://user?id={self.id}"

        if self.username:
            return f'https://t.me/{self.username}'

        if self.invite_link:
            return self.invite_link

        await self.update_chat()
        return self.invite_link
868974
def _url_val(val, key, obj, **kwargs):
    
    if isinstance(val, URLFor):
        return val.serialize(key, obj, **kwargs)
    else:
        return val
409129
private TitledUrl findFormattedUrl(TextCursor cursor, int limit) {
        start_loop:
        for (int start = cursor.currentOffset; start < limit; start++) {

            // Finding beginning of url
            if (cursor.text.charAt(start) == '[') {
                if (!isGoodAnchor(cursor.text, start - 1)) {
                    continue start_loop;
                }
            } else {
                continue start_loop;
            }

            // Finding middle part of url
            middle_loop:
            for (int middle = start + 1; middle < limit - 1; middle++) {
                if (cursor.text.charAt(middle) != ']' || cursor.text.charAt(middle + 1) != '(') {
                    continue middle_loop;
                }

                end_loop:
                for (int end = middle + 2; end < limit; end++) {
                    if (cursor.text.charAt(end) != ')') {
                        continue end_loop;
                    }
                    return new TitledUrl(start, middle, end);
                }
            }
        }

        return null;
    }
407603
private BasicUrl findUrl(TextCursor cursor, int limit) {
        for (int i = cursor.currentOffset; i < limit; i++) {
            if (!isGoodAnchor(cursor.text, i - 1)) {
                continue;
            }
            String currentText = cursor.text.substring(i, limit);
            MatcherCompat matcher = Patterns.WEB_URL_START.matcher(currentText);
            if (matcher.hasMatch()) {
                String url = matcher.group();
                int start = i + matcher.start();
                return new BasicUrl(start, start + url.length());
            }
        }
        return null;
    }
28584
def get_url(self, url, fields=None, **urlopen_kw):
        
        return self.request_encode_url('GET', url, fields=fields,
                                       **urlopen_kw)
1164568
def to_url(self):
        
        if self.__collection_format == 'multi':
            return [str(s) for s in self]
        else:
            return [str(self)]
559292
def urls(self):
        
        url_bases = self._url_module.url_bases
        unformatted_paths = self._url_module.url_paths

        urls = {}
        for url_base in url_bases:
            for url_path, handler in unformatted_paths.items():
                url = url_path.format(url_base)
                urls[url] = handler

        return urls
811532
def url_for(self, *args, **kwargs):
        """"""
        return yarl.URL(self.url(parts=kwargs))
1017650
def url(self, key):
        
        return urlunparse((self.protocol, '%s:%s' % (self.domain, self.port),
                           '%s/api/v1%s' % (self.prefix, URLS[key]),
                           '', '', ''))
293294
def url(self, url):
        
        if url and url.endswith('/'):
            url = url[:-1]

        self._url = url
596447
def url(self, value):
        

        if value is not None:
            assert type(value) is unicode, "'{0}' attribute: '{1}' type is not 'unicode'!".format(
                "url", value)
        self.__url = value
1235234
def urls(self):
        
        from django.conf.urls import url
        urls = [
            url(r'^$', self.documentation),
            url(r'^map$', self.map_view),
        ]

        for resource_name in self.resource_map:
            urls.extend([
                url(r'(?P<resource_name>{})$'.format(
                    resource_name), self.handler_view),
                url(r'(?P<resource_name>{})/(?P<ids>[\w\-\,]+)$'.format(
                    resource_name), self.handler_view),
            ])

        return urls
939374
def buttons(self):
        
        if self._buttons is None and self.reply_markup:
            if not self.input_chat:
                return
            try:
                bot = self._needed_markup_bot()
            except ValueError:
                return
            else:
                self._set_buttons(self._input_chat, bot)

        return self._buttons
849729
def button_to(*arguments, &block)
      if block_given?
        body = block
        url = arguments[0]
        html_options = arguments[1] || {}
      else
        body = arguments[0]
        url = arguments[1]
        html_options = arguments[2] || {}
      end

      if block_given?
        super(url, html_options, &body)
      else
        super(url, html_options) { body }
      end
    end