Make the URL people should start at for this version of coverage.py.
2210
def _make_url(major, minor, micro, releaselevel, serial):
    """"""
    url = "https://django-pagination-bootstrap.readthedocs.io"
    if releaselevel != 'final':
        # For pre-releases, use a version-specific URL.
        url += "/en/" + _make_version(major, minor, micro, releaselevel, serial)
    return url
587729
def coverage(reportdir=None, extra=None):
    """"""

    import coverage as coverage_api
    cov = coverage_api.coverage()
    opts = {'directory': reportdir} if reportdir else {}

    cov.start()
    test(extra)
    cov.stop()
    cov.html_report(**opts)
952815
def from_args(cls, target_url, default_url, test_url):
        """"""
        return cls("You're trying to upload to the legacy PyPI site '{}'. "
                   "Uploading to those sites is deprecated. \n "
                   "The new sites are pypi.org and test.pypi.org. Try using "
                   "{} (or {}) to upload your packages instead. "
                   "These are the default URLs for Twine now. \n More at "
                   "https://packaging.python.org/guides/migrating-to-pypi-org/"
                   " .".format(target_url, default_url, test_url)
                   )
113011
def cover(ctx, html=False):
    ''''''
    params = '--cov-report term --cov-report html' if html else ''
    with ctx.cd(ROOT):
        ctx.run('pytest --cov flask_fs {0}'.format(params), pty=True)
407441
def wrap(cls, url):
    
    if isinstance(url, cls):
      return url
    elif isinstance(url, compatible_string):
      return cls(url)
    else:
      raise ValueError('url must be either a string or Link.')
101152
def fix_scheme(url):
    ''''''
    splitted = url.split('://')
    if len(splitted) == 2:
        if splitted[0] in ('http', 'https'):
            return url
        else:
            raise exc.WileECoyoteException(
                'Bad scheme! Got: {}, expected http or https'.format(
                    splitted[0]))
    elif len(splitted) == 1:
        return 'http://' + url
    else:
        raise exc.ZachMorrisException('Too many schemes!')
1315546
def coverage():
    ""
    coverage_index = path("build/coverage/index.html")
    coverage_index.remove()
    sh("paver test")
    coverage_index.exists() and webbrowser.open(coverage_index)
1139686
def _new_url(self, relative_url):
        """"""

        return Url(
            urljoin(self._base_url, relative_url),
            **self._default_kwargs
        )
482210
def makeCNBaseURL(url):
    """"""
    o = urllib.parse.urlparse(url, scheme=d1_common.const.DEFAULT_CN_PROTOCOL)
    if o.netloc and o.path:
        netloc = o.netloc
        path = o.path
    elif o.netloc:
        netloc = o.netloc
        path = d1_common.const.DEFAULT_CN_PATH
    elif o.path:
        s = o.path.split('/', 1)
        netloc = s[0]
        if len(s) == 1:
            path = d1_common.const.DEFAULT_CN_PATH
        else:
            path = s[1]
    else:
        netloc = d1_common.const.DEFAULT_CN_HOST
        path = d1_common.const.DEFAULT_CN_PATH
    return urllib.parse.urlunparse(
        (o.scheme, netloc, path, o.params, o.query, o.fragment)
    )
584951
def refine_get_urls(original):
    

    def get_urls():
        from django.conf.urls import url
        from django.conf import settings
        from django.contrib.staticfiles.urls import staticfiles_urlpatterns
        from django.views.static import serve
        if settings.DEBUG:
            return staticfiles_urlpatterns() + [
                url(r'^media/(?P<path>.*)$', serve, {
                    'document_root': settings.MEDIA_ROOT,
                }),
            ] + original()
        else:
            return original()
    return get_urls
725561
def url_should_contain(self, url):
    """"""

    if url not in world.browser.current_url:
        raise AssertionError(
            "Browser URL expected to contain {!r}, got {!r}.".format(
                url, world.browser.current_url))
1147774
def _edit_main(self, request):
        
        self.prefix = "{}_Pull_Request_{}".format(request.repo.name, request.pull.number)
        if not self.testmode:
            page = site.pages[self.basepage]
            text = page.text()
        else:
            text = "This is a fake wiki page.\n\n<!--@CI:Placeholder-->"
            
        self.newpage = self.prefix
        link = "Pull Request #{}".format(request.pull.number)
        text = text.replace("<!--@CI:Placeholder-->",
                            "* [[{}|{}]]\n<!--@CI:Placeholder-->".format(self.newpage, link))
        if not self.testmode:
            result = page.save(text, summary="Added {} unit test link.".format(link), minor=True, bot=True)
            return result[u'result'] == u'Success'
        else:
            return text
903604
def _urlretrieve(url, filename):
    
    ctx = create_default_context()
    ctx.check_hostname = False
    ctx.verify_mode = CERT_NONE

    with urlopen(url, context=ctx) as u, filename.open('wb') as f:
            f.write(u.read())
596431
def patch(self, url, headers=None, body=None, kwargs=None):
        
        return self._request(
            method='patch',
            url=url,
            headers=headers,
            body=body,
            kwargs=kwargs
        )
559252
def _buildUrl(self):
		""""""
		return '%(protocol)s://%(host)s:%(port)s%(address)s'%{
			'protocol': self._protocol,
			'host': self._host,
			'port': self._port,
			'address': self._address,
		}
647232
def make_url(self, container=None, resource=None, query_items=None):
        """"""
        pth = [self._base_url]
        if container:
            pth.append(container.strip('/'))
        if resource:
            pth.append(resource)
        else:
            pth.append('')
        url = '/'.join(pth)
        if isinstance(query_items, (list, tuple, set)):
            url += RestHttp._list_query_str(query_items)
            query_items = None
        p = requests.PreparedRequest()
        p.prepare_url(url, query_items)
        return p.url
373976
def url(self, version=None, **kwargs):
        """"""
        for url in self.urls(version):
            if [key for key in kwargs.keys() if not '{' + key + '}' in url]:
                continue

            return url.format(**kwargs)

        raise KeyError('URL that takes all provided parameters not found')