def url_for(endpoint, **values):
"""
Generates a URL to the given endpoint.
If the endpoint is for a static resource then a Rackspace Cloud File URL is
generated, otherwise the call is passed on to `flask.url_for`.
Because this function is set as a jinja environment variable when
`FlaskRSF.init_app` is invoked, this function replaces `flask.url_for` in
templates automatically. It is unlikely that this function will
need to be directly called from within your application code, unless you
need to refer to static assets outside of your templates.
"""
app = current_app
if "RSF_CONTAINER_NAME" not in app.config:
raise ValueError("RSF_CONTAINER_NAME not found in app configuration.")
if app.debug and not app.config["USE_RSF_DEBUG"]:
return flask_url_for(endpoint, **values)
if endpoint == "static" or endpoint.endswith(".static"):
pyrax.set_credentials(["RSF_USERNAME"], ["RSF_API_KEY"])
cf = pyrax.cloudfiles
cont = cf.create_container(app.config["RSF_CONTAINER_NAME"])
scheme = "http"
bucket_path = cont.cdn_uri
if app.config["RSF_USE_HTTPS"]:
scheme = "https"
bucket_path = cont.cdn_ssl_uri
bucket_path = re.sub(r"(http[s]*://)", r"", bucket_path)
urls = app.url_map.bind(bucket_path, url_scheme=scheme)
return urls.build(endpoint, values=values, force_external=True)
return flask_url_for(endpoint, **values)
def url_for(endpoint, **values):
"""
Generates a URL to the given endpoint.
If the endpoint is for a static resource then an Amazon S3 URL is
generated, otherwise the call is passed on to `flask.url_for`.
Because this function is set as a jinja environment variable when
`FlaskS3.init_app` is invoked, this function replaces
`flask.url_for` in templates automatically. It is unlikely that this
function will need to be directly called from within your
application code, unless you need to refer to static assets outside
of your templates.
"""
app = current_app
if 'S3_BUCKET_NAME' not in app.config:
raise ValueError("S3_BUCKET_NAME not found in app configuration.")
if app.debug and not app.config['USE_S3_DEBUG']:
return flask_url_for(endpoint, **values)
if endpoint == 'static' or endpoint.endswith('.static'):
scheme = 'http'
if app.config['S3_USE_HTTPS']:
scheme = 'https'
bucket_path = '%s.%s' % (app.config['S3_BUCKET_NAME'],
app.config['S3_BUCKET_DOMAIN'])
urls = app.url_map.bind(bucket_path, url_scheme=scheme)
return urls.build(endpoint, values=values, force_external=True)
return flask_url_for(endpoint, **values)
def url_for(endpoint, **values):
if redirect_url_prefix is None:
return flask_url_for(endpoint, **values)
else:
if '_external' in values:
del values['_external']
return redirect_url_prefix + flask_url_for(endpoint, **values)
def static_url_for(self, endpoint, **values):
"""
This function uses Flask's url_for under the hood and accepts the
same arguments. The only differences are it will prefix a host URL if
one exists and if a manifest is available it will look up the filename
from the manifest.
:param endpoint: The endpoint of the URL
:type endpoint: str
:param values: Arguments of the URL rule
:return: Static file path.
"""
if not self.has_manifest:
if self.host_url:
return self._prepend_host_url(self.host_url,
values.get("filename"))
else:
return flask_url_for(endpoint, **values)
new_filename = {}
filename = values.get("filename")
if filename:
# If the manifest lookup fails then use the original filename
# so that Flask doesn't throw a 500, but instead a proper 404.
# The above only happens if your template has an invalid filename.
new_filename["filename"] = self.manifest.get(filename, filename)
merged_values = {**values, **new_filename}
if self.host_url:
return self._prepend_host_url(self.host_url,
merged_values.get("filename"))
else:
return flask_url_for(endpoint, **merged_values)
def url_for(endpoint, **values):
app = current_app
if app.config.get('TESTING', False):
return flask_url_for(endpoint, **values)
if 'AZURE_STORAGE_CONTAINER_NAME' not in app.config:
raise ValueError(
"AZURE_STORAGE_CONTAINER_NAME not found in app configuration.")
if endpoint == 'static' or endpoint.endswith('.static'):
scheme = 'https'
if not app.config.get("AZURE_STORAGE_USE_HTTPS", True):
scheme = 'http'
# allow per url override for scheme
scheme = values.pop('_scheme', scheme)
# manage other special values, all have no meaning for static urls
values.pop('_external', False) # external has no meaning here
values.pop('_anchor', None) # anchor as well
values.pop('_method', None) # method too
url_format = '%(container_domain)s/%(container_name)s/%(virtual_folder)s'
bucket_path = url_format % {
'container_domain': app.config['AZURE_STORAGE_DOMAIN'],
'container_name': app.config['AZURE_STORAGE_CONTAINER_NAME'],
'virtual_folder': app.config['AZURE_STORAGE_VIRTUAL_FOLDER_NAME']
}
urls = app.url_map.bind(bucket_path, url_scheme=scheme)
return urls.build(endpoint, values=values, force_external=True)
return flask_url_for(endpoint, **values)
def url_for(endpoint, **values):
"""
Generates a URL to the given endpoint.
If the endpoint is for a static resource then an Amazon S3 URL is
generated, otherwise the call is passed on to `flask.url_for`.
Because this function is set as a jinja environment variable when
`FlaskS3.init_app` is invoked, this function replaces
`flask.url_for` in templates automatically. It is unlikely that this
function will need to be directly called from within your
application code, unless you need to refer to static assets outside
of your templates.
"""
app = current_app
if app.config.get('TESTING', False) and not app.config.get('FLASKS3_OVERRIDE_TESTING', True):
return flask_url_for(endpoint, **values)
if 'FLASKS3_BUCKET_NAME' not in app.config:
raise ValueError("FLASKS3_BUCKET_NAME not found in app configuration.")
if endpoint == 'static' or endpoint.endswith('.static'):
scheme = 'https'
if not app.config.get("FLASKS3_USE_HTTPS", True):
scheme = 'http'
# allow per url override for scheme
scheme = values.pop('_scheme', scheme)
bucket_path, values = _get_bucket_name(**values)
urls = app.url_map.bind(bucket_path, url_scheme=scheme)
built = urls.build(endpoint, values=values, force_external=True)
return built
return flask_url_for(endpoint, **values)
def url_for(endpoint, **values):
"""
Generates a URL to the given endpoint.
If the endpoint is for a static resource then an Amazon S3 URL is
generated, otherwise the call is passed on to `flask.url_for`.
Because this function is set as a jinja environment variable when
`FlaskS3.init_app` is invoked, this function replaces `flask.url_for` in
templates automatically. It is unlikely that this function will
need to be directly called from within your application code, unless you
need to refer to static assets outside of your templates.
"""
app = current_app
if 'S3_BUCKET_NAME' not in app.config:
raise ValueError("S3_BUCKET_NAME not found in app configuration.")
if app.debug and not app.config['USE_S3_DEBUG']:
return flask_url_for(endpoint, **values)
if endpoint == 'static' or endpoint.endswith('.static'):
scheme = 'http'
if app.config['S3_USE_HTTPS']:
scheme = 'https'
bucket_path = '%s.%s' % (app.config['S3_BUCKET_NAME'],
app.config['S3_BUCKET_DOMAIN'])
urls = app.url_map.bind(bucket_path, url_scheme=scheme)
return urls.build(endpoint, values=values, force_external=True)
return flask_url_for(endpoint, **values)
def url_for(endpoint, **values):
"""
Generates a URL to the given endpoint.
If the endpoint is for a static resource then a URL to the CDN is
generated, otherwise the call is passed on to `flask.url_for`.
Because this function is set as a jinja environment variable when
`CDN.init_app` is invoked, this function replaces `flask.url_for` in
templates automatically. It is unlikely that this function will need to be
directly called from within your application code, unless you need to refer
to static assets outside of your templates.
"""
app = current_app
if app.config['CDN_DEBUG'] or _request_ctx_stack.top is None:
return flask_url_for(endpoint, **values)
def endpoint_match(endpoint):
if endpoint in app.config['CDN_ENDPOINTS']:
return True
for x in app.config['CDN_ENDPOINTS']:
if endpoint.endswith('.%s' % x):
return True
return False
if endpoint_match(endpoint):
try:
scheme = values.pop('_scheme')
except KeyError:
scheme = 'http'
cdn_https = app.config['CDN_HTTPS']
if cdn_https is True or (cdn_https is None and request.is_secure):
scheme = 'https'
static_folder = app.static_folder
if (request.blueprint is not None
and request.blueprint in app.blueprints
and app.blueprints[request.blueprint].has_static_folder):
static_folder = app.blueprints[request.blueprint].static_folder
elif '.' in endpoint:
blueprint_name = endpoint.split('.')[0]
if blueprint_name in app.blueprints and app.blueprints[
blueprint_name].has_static_folder:
static_folder = app.blueprints[blueprint_name].static_folder
urls = app.url_map.bind(app.config['CDN_DOMAIN'], url_scheme=scheme)
if app.config['CDN_TIMESTAMP']:
path = os.path.join(static_folder, values['filename'])
values['t'] = int(os.path.getmtime(path))
values['v'] = app.config['CDN_VERSION']
return urls.build(endpoint, values=values, force_external=True)
return flask_url_for(endpoint, **values)
def url_for(endpoint, **values):
"""
Generates a URL to the given endpoint.
If the endpoint is for a static resource then an Amazon S3 URL is
generated, otherwise the call is passed on to `flask.url_for`.
Because this function is set as a jinja environment variable when
`FlaskS3.init_app` is invoked, this function replaces
`flask.url_for` in templates automatically. It is unlikely that this
function will need to be directly called from within your
application code, unless you need to refer to static assets outside
of your templates.
"""
app = current_app
if app.config.get('TESTING', False) and not app.config.get('FLASKS3_OVERRIDE_TESTING', True):
return flask_url_for(endpoint, **values)
if 'FLASKS3_BUCKET_NAME' not in app.config:
raise ValueError("FLASKS3_BUCKET_NAME not found in app configuration.")
if endpoint == 'static' or endpoint.endswith('.static'):
scheme = 'https'
if not app.config.get("FLASKS3_USE_HTTPS", True):
scheme = 'http'
# allow per url override for scheme
scheme = values.pop('_scheme', scheme)
# manage other special values, all have no meaning for static urls
values.pop('_external', False) # external has no meaning here
values.pop('_anchor', None) # anchor as well
values.pop('_method', None) # method too
if app.config['FLASKS3_URL_STYLE'] == 'host':
url_format = '%(bucket_name)s.%(bucket_domain)s'
elif app.config['FLASKS3_URL_STYLE'] == 'path':
url_format = '%(bucket_domain)s/%(bucket_name)s'
else:
raise ValueError('Invalid S3 URL style: "%s"'
% app.config['FLASKS3_URL_STYLE'])
bucket_path = url_format % {
'bucket_name': app.config['FLASKS3_BUCKET_NAME'],
'bucket_domain': app.config['FLASKS3_BUCKET_DOMAIN'],
}
if app.config['FLASKS3_CDN_DOMAIN']:
bucket_path = '%s' % app.config['FLASKS3_CDN_DOMAIN']
# Both S3 and CDN urls should use the prefix if it exists
bucket_path += _get_statics_prefix(app).rstrip('/')
urls = app.url_map.bind(bucket_path, url_scheme=scheme)
return urls.build(endpoint, values=values, force_external=True)
return flask_url_for(endpoint, **values)
def url_for(endpoint, **values):
if "_domain" in values:
domain = values["_domain"]
del values["_domain"]
else:
domain = _MultidomainBlueprint__endpoint_domain.get(endpoint, None)
if domain and domain != g.domain:
values["_external"] = False # Remove external parameter for flask
return "http://" + domain + DOMAIN_SUFFIX + flask_url_for(endpoint, **values)
return flask_url_for(endpoint, **values)
def url_for(endpoint, **values):
"""
Generates a URL to the given endpoint.
If the endpoint is for a static resource then an Amazon S3 URL is
generated, otherwise the call is passed on to `flask.url_for`.
Because this function is set as a jinja environment variable when
`FlaskS3.init_app` is invoked, this function replaces
`flask.url_for` in templates automatically. It is unlikely that this
function will need to be directly called from within your
application code, unless you need to refer to static assets outside
of your templates.
"""
app = current_app
if app.config.get('TESTING', False) and not app.config.get('FLASKS3_OVERRIDE_TESTING', True):
return flask_url_for(endpoint, **values)
if 'FLASKS3_BUCKET_NAME' not in app.config:
raise ValueError("FLASKS3_BUCKET_NAME not found in app configuration.")
if endpoint == 'static' or endpoint.endswith('.static'):
scheme = 'https'
if not app.config.get("FLASKS3_USE_HTTPS", True):
scheme = 'http'
# allow per url override for scheme
scheme = values.pop('_scheme', scheme)
# manage other special values, all have no meaning for static urls
values.pop('_external', False) # external has no meaning here
values.pop('_anchor', None) # anchor as well
values.pop('_method', None) # method too
if app.config['FLASKS3_URL_STYLE'] == 'host':
url_format = '%(bucket_name)s.%(bucket_domain)s'
elif app.config['FLASKS3_URL_STYLE'] == 'path':
url_format = '%(bucket_domain)s/%(bucket_name)s'
else:
raise ValueError('Invalid S3 URL style: "%s"'
% app.config['FLASKS3_URL_STYLE'])
bucket_path = url_format % {
'bucket_name': app.config['FLASKS3_BUCKET_NAME'],
'bucket_domain': app.config['FLASKS3_BUCKET_DOMAIN'],
}
if app.config['FLASKS3_CDN_DOMAIN']:
bucket_path = '%s' % app.config['FLASKS3_CDN_DOMAIN']
# Both S3 and CDN urls should use the prefix if it exists
bucket_path += _get_statics_prefix(app).rstrip('/')
urls = app.url_map.bind(bucket_path, url_scheme=scheme)
return urls.build(endpoint, values=values, force_external=True)
return flask_url_for(endpoint, **values)
def url_for(endpoint, **values):
"""
Generates a URL to the given endpoint.
If the endpoint is for a static resource then a URL to the CDN is
generated, otherwise the call is passed on to `flask.url_for`.
Because this function is set as a jinja environment variable when
`CDN.init_app` is invoked, this function replaces `flask.url_for` in
templates automatically. It is unlikely that this function will need to be
directly called from within your application code, unless you need to refer
to static assets outside of your templates.
"""
app = current_app
if app.config['CDN_DEBUG']:
return flask_url_for(endpoint, **values)
def endpoint_match(endpoint):
if endpoint in app.config['CDN_ENDPOINTS']:
return True
for x in app.config['CDN_ENDPOINTS']:
if endpoint.endswith('.%s' % x):
return True
return False
if endpoint_match(endpoint):
try:
scheme = values.pop('_scheme')
except KeyError:
scheme = 'http'
cdn_https = app.config['CDN_HTTPS']
if cdn_https is True or (cdn_https is None and request.is_secure):
scheme = 'https'
static_folder = app.static_folder
if (request.blueprint is not None and
app.blueprints[request.blueprint].has_static_folder):
static_folder = app.blueprints[request.blueprint].static_folder
urls = app.url_map.bind(app.config['CDN_DOMAIN'], url_scheme=scheme)
if app.config['CDN_TIMESTAMP']:
path = os.path.join(static_folder, values['filename'])
values['t'] = int(os.path.getmtime(path))
return urls.build(endpoint, values=values, force_external=True)
return flask_url_for(endpoint, **values)
def url_for(endpoint, **values):
"""
Generates a URL to the given endpoint.
If the endpoint is for a static resource then a URL to the CDN is
generated, otherwise the call is passed on to `flask.url_for`.
Because this function is set as a jinja environment variable when
`CDN.init_app` is invoked, this function replaces `flask.url_for` in
templates automatically. It is unlikely that this function will need to be
directly called from within your application code, unless you need to refer
to static assets outside of your templates.
"""
app = current_app
if app.debug:
return flask_url_for(endpoint, **values)
if endpoint == 'static' or endpoint.endswith('.static'):
cdn_https = app.config['CDN_HTTPS']
scheme = 'http'
if cdn_https is True or (cdn_https is None and request.is_secure):
scheme = 'https'
static_folder = app.static_folder
if request.blueprint is not None:
static_folder = app.blueprints[request.blueprint].static_folder
domain = app.config['CDN_DOMAIN']
if app.config['CDN_FOLDER'] is not None:
domain = domain + "/"
domain = domain + str(app.config['CDN_FOLDER'])
if app.config['CDN_VERSION'] is not None:
domain = domain + "/"
domain = domain + str(app.config['CDN_VERSION'])
urls = app.url_map.bind(domain, url_scheme=scheme)
if app.config['CDN_TIMESTAMP']:
path = os.path.join(static_folder, values['filename'])
values['t'] = int(os.path.getmtime(path))
return urls.build(endpoint, values=values, force_external=True)
return flask_url_for(endpoint, **values)
def url_for(endpoint, **values):
"""
Generates a URL to the given endpoint.
If the endpoint is for a static resource then a URL to the CDN is
generated, otherwise the call is passed on to `flask.url_for`.
Because this function is set as a jinja environment variable when
`CDN.init_app` is invoked, this function replaces `flask.url_for` in
templates automatically. It is unlikely that this function will need to be
directly called from within your application code, unless you need to refer
to static assets outside of your templates.
"""
app = current_app
if app.debug:
return flask_url_for(endpoint, **values)
if endpoint == 'static' or endpoint.endswith('.static'):
cdn_https = app.config['CDN_HTTPS']
scheme = 'http'
if cdn_https is True or (cdn_https is None and request.is_secure):
scheme = 'https'
static_folder = app.static_folder
if request.blueprint is not None:
static_folder = app.blueprints[request.blueprint].static_folder
domain = app.config['CDN_DOMAIN']
if app.config['CDN_FOLDER'] is not None:
domain = domain + "/"
domain = domain + str(app.config['CDN_FOLDER'])
if app.config['CDN_VERSION'] is not None:
domain = domain + "/"
domain = domain + str(app.config['CDN_VERSION'])
urls = app.url_map.bind(domain, url_scheme=scheme)
if app.config['CDN_TIMESTAMP']:
path = os.path.join(static_folder, values['filename'])
values['t'] = int(os.path.getmtime(path))
return urls.build(endpoint, values=values, force_external=True)
return flask_url_for(endpoint, **values)
def url_for(*args, **kwargs):
""" `flask.url_for`는 flask 앱의 context가 필요합니다. 따라서 context안에서
생성한 url을 가져와서 사용하면됩니다. 테스트 코드 내부에서 그냥
`flask.url_for`를 사용하면 에러가 나게됩니다.
"""
with app.test_request_context() as ctx_:
return flask_url_for(*args, **kwargs)
def url_for(self, model, **kw):
"""Returns the URL for the specified model, similar to
:func:`flask.url_for`.
`model` is a SQLAlchemy model class. This must be a model on
which :meth:`create_api_blueprint` has been invoked previously,
otherwise a :exc:`KeyError` is raised.
This method only returns URLs for endpoints created by this
:class:`APIManager`.
The remaining keyword arguments are passed directly on to
:func:`flask.url_for`.
.. _Flask request context: http://flask.pocoo.org/docs/0.10/reqcontext/
"""
collection_name = self.created_apis_for[model].collection_name
blueprint_name = self.created_apis_for[model].blueprint_name
api_name = APIManager.api_name(collection_name)
parts = [blueprint_name, api_name]
# If we are looking for a relationship URL, the view name ends with
# '.relationships'.
if 'relationship' in kw and kw.pop('relationship'):
parts.append('relationships')
url = flask_url_for('.'.join(parts), **kw)
# if _absolute_url:
# url = urljoin(request.url_root, url)
return url
def url_for(self, endpoint, **kwargs):
"""
A small helper to generate a URL to the given endpoint in the context of `self.app_context`.
"""
with app.app_context():
url = flask_url_for(endpoint, **kwargs)
return self.get_server_url() + url
def url_for(self, endpoint, **kwargs):
"""
A small helper to generate a URL to the given endpoint in the context of `self.app_context`.
"""
with self.app_context:
url = flask_url_for(endpoint, **kwargs)
return url
def url_for(endpoint, **values):
if endpoint == 'admin.static':
filename = values.pop('filename')
query = url_encode(values)
url_prefix = current_app.config['ADMIN_STATIC_URL']
return '{}?{}'.format(url_join(url_prefix, filename), query)
return flask_url_for(endpoint, **values)
def url_for(self, model, **kw):
"""Returns the URL for the specified model, similar to
:func:`flask.url_for`.
`model` is a SQLAlchemy model class. This must be a model on
which :meth:`create_api_blueprint` has been invoked previously,
otherwise a :exc:`KeyError` is raised.
This method only returns URLs for endpoints created by this
:class:`APIManager`.
The remaining keyword arguments are passed directly on to
:func:`flask.url_for`.
.. _Flask request context: http://flask.pocoo.org/docs/0.10/reqcontext/
"""
collection_name = self.created_apis_for[model].collection_name
blueprint_name = self.created_apis_for[model].blueprint_name
api_name = APIManager.api_name(collection_name)
parts = [blueprint_name, api_name]
# If we are looking for a relationship URL, the view name ends with
# '.relationships'.
if 'relationship' in kw and kw.pop('relationship'):
parts.append('relationships')
url = flask_url_for('.'.join(parts), **kw)
# if _absolute_url:
# url = urljoin(request.url_root, url)
return url
def url_for(*args, **kwargs) -> str:
host = get_host()
redirect_url = urlparse(flask_url_for(*args, **kwargs))
# noinspection PyProtectedMember
return redirect_url._replace(
netloc=host,
scheme="https" if getenv("ENV") == "prod" else "http").geturl()
def url_for(endpoint, **values):
if endpoint == 'admin.static':
filename = values.pop('filename')
query = url_encode(values)
url_prefix = current_app.config['ADMIN_STATIC_URL']
return '{}?{}'.format(url_join(url_prefix, filename), query)
return flask_url_for(endpoint, **values)
def url_for(*a, **kw):
"""Generate external URLs with HTTPS (if configured)."""
try:
kw['_external'] = False
path = flask_url_for(*a, **kw)
return urljoin(get_app_url(), path)
except RuntimeError:
return None
def url_for(endpoint, **kwargs):
if os.getenv('SANDSTORM'):
kwargs.setdefault('_external', True)
if request.headers.get('X-Forwarded-Proto') == "https":
kwargs.setdefault('_scheme', 'https')
else:
kwargs.setdefault('_scheme', 'http')
return flask_url_for(endpoint, **kwargs)
def url_for(*args, **kwargs):
"""Generate url using flask.url_for and the current app ctx.
This is necessary as we don't want to share the same application
context across requests.
"""
with app.app_context():
return flask_url_for(*args, **kwargs)
def url_for(*args, **kwargs):
"""Generate url using flask.url_for and the current app ctx.
This is necessary as we don't want to share the same application
context across requests.
"""
with app.app_context():
return flask_url_for(*args, **kwargs)
def url_for(endpoint, **kwargs):
# Persist the lens parameter across navigations.
lens = request.args.get('lens')
if report_util.is_valid_lens(lens):
kwargs['lens'] = lens
# Pass through to the built-in method.
return flask_url_for(endpoint, **kwargs)
def url_for(endpoint, **kwargs):
if os.getenv("SANDSTORM"):
kwargs.setdefault("_external", True)
if request.headers.get("X-Forwarded-Proto") == "https":
kwargs.setdefault("_scheme", "https")
else:
kwargs.setdefault("_scheme", "http")
return flask_url_for(endpoint, **kwargs)
def url_for(endpoint, **values):
"""
Generates a URL to the given endpoint.
If the endpoint is for a static resource then an Amazon S3 URL is
generated, otherwise the call is passed on to `flask.url_for`.
Because this function is set as a jinja environment variable when
`FlaskS3.init_app` is invoked, this function replaces
`flask.url_for` in templates automatically. It is unlikely that this
function will need to be directly called from within your
application code, unless you need to refer to static assets outside
of your templates.
"""
app = current_app
if 'S3_BUCKET_NAME' not in app.config:
raise ValueError("S3_BUCKET_NAME not found in app configuration.")
if app.debug and not app.config['USE_S3_DEBUG']:
return flask_url_for(endpoint, **values)
if endpoint == 'static' or endpoint.endswith('.static'):
scheme = 'http'
scheme = app.config['S3_URL_SCHEME'] or 'https'
bucket_path = '%s.%s' % (app.config['S3_BUCKET_NAME'],
app.config['S3_BUCKET_DOMAIN'])
if app.config['S3_CDN_DOMAIN']:
bucket_path = '%s' % app.config['S3_CDN_DOMAIN']
if app.config['S3_PREFIX']:
bucket_path = "/".join((bucket_path, app.config['S3_PREFIX']))
urls = app.url_map.bind(bucket_path, url_scheme=scheme)
try:
mimetype = mimetypes.guess_type(values['filename'])[0]
except KeyError:
mimetype = None
if app.config['USE_GZIP']:
accept_encoding = request.headers.get('Accept-Encoding', '')
if (mimetype in app.config['S3_GZIP_CONTENT_TYPES']
and 'gzip' in accept_encoding.lower()):
values['filename'] += '.gz'
url = urls.build(endpoint, values=values, force_external=True)
if app.config['S3_URL_SCHEME'] is None:
url = re.sub(r'^https://', '//', url)
return url
return flask_url_for(endpoint, **values)
def url_for(*a, **kw):
"""Generate external URLs with HTTPS (if configured)."""
try:
kw['_external'] = True
if get_config('PREFERRED_URL_SCHEME'):
kw['_scheme'] = get_config('PREFERRED_URL_SCHEME')
return flask_url_for(*a, **kw)
except RuntimeError:
return None
def url_for(*a, **kw):
"""Overwrite Flask url_for to force external paths."""
try:
kw['_external'] = False
query = kw.pop('_query', None)
path = flask_url_for(*a, **kw)
return url_external(path, query)
except RuntimeError:
return None
def url_for(*a, **kw):
""" Always generate external URLs. """
try:
kw['_external'] = True
if app.config.get('PREFERRED_URL_SCHEME'):
kw['_scheme'] = app.config.get('PREFERRED_URL_SCHEME')
return flask_url_for(*a, **kw)
except RuntimeError:
return None
def url_for(*a, **kw):
""" Always generate external URLs. """
try:
kw['_external'] = True
if current_app.config.get('PREFERRED_URL_SCHEME'):
kw['_scheme'] = current_app.config.get('PREFERRED_URL_SCHEME')
return flask_url_for(*a, **kw)
except RuntimeError:
return None
def url_for(*args, **kwargs):
'''
Override of flask url_for that correctly sets https or http based on the
SERVER_PROTOCOL config variable.
'''
if kwargs.get('_external', False):
kwargs['_scheme'] = current_app.config.get('SERVER_PROTOCOL', 'https')
return flask_url_for(*args, **kwargs)
def url_for(*args, **kwargs):
'''
Override of flask url_for that correctly sets https or http based on the
SERVER_PROTOCOL config variable.
'''
if kwargs.get('_external', False):
kwargs['_scheme'] = current_app.config.get('SERVER_PROTOCOL', 'https')
return flask_url_for(*args, **kwargs)
def url_for(*a, **kw):
"""Generate external URLs with HTTPS (if configured)."""
try:
kw['_external'] = True
if get_config('PREFERRED_URL_SCHEME'):
kw['_scheme'] = get_config('PREFERRED_URL_SCHEME')
return flask_url_for(*a, **kw)
except RuntimeError:
return None
def url_for(endpoint, **values):
"""
Generates a URL to the given endpoint.
If the endpoint is for a static resource then an Amazon S3 URL is
generated, otherwise the call is passed on to `flask.url_for`.
Because this function is set as a jinja environment variable when
`FlaskS3.init_app` is invoked, this function replaces
`flask.url_for` in templates automatically. It is unlikely that this
function will need to be directly called from within your
application code, unless you need to refer to static assets outside
of your templates.
"""
app = current_app
if app.config.get('TESTING', False) and not app.config.get('S3_OVERRIDE_TESTING', True):
return flask_url_for(endpoint, **values)
if 'S3_BUCKET_NAME' not in app.config:
raise ValueError("S3_BUCKET_NAME not found in app configuration.")
if endpoint == 'static' or endpoint.endswith('.static'):
scheme = 'https'
if app.config['S3_USE_HTTP']:
scheme = 'http'
if app.config['S3_URL_STYLE'] == 'host':
url_format = '%(bucket_name)s.%(bucket_domain)s'
elif app.config['S3_URL_STYLE'] == 'path':
url_format = '%(bucket_domain)s/%(bucket_name)s'
else:
raise ValueError('Invalid S3 URL style: "%s"'
% app.config['S3_URL_STYLE'])
bucket_path = url_format % {
'bucket_name': app.config['S3_BUCKET_NAME'],
'bucket_domain': app.config['S3_BUCKET_DOMAIN'],
}
if app.config['S3_CDN_DOMAIN']:
bucket_path = '%s' % app.config['S3_CDN_DOMAIN']
urls = app.url_map.bind(bucket_path, url_scheme=scheme)
return urls.build(endpoint, values=values, force_external=True)
return flask_url_for(endpoint, **values)
def url_for(*a, **kw):
"""Overwrite Flask url_for to force external paths"""
try:
kw["_external"] = False
query = kw.pop("_query", None)
relative = kw.pop("_relative", False)
path = flask_url_for(*a, **kw)
return url_external(path, query, relative=relative)
except RuntimeError:
return None
def url_for(endpoint: str, **values: dict) -> Any:
"""
Build an URL for an ``endpoint``.
Tries Flask first, then falls back to...
"""
try:
return flask_url_for(endpoint, **values)
except RuntimeError as e:
return endpoint
def url_for(endpoint, **values):
from flask import url_for as flask_url_for
url = flask_url_for(endpoint, **values)
external = values.pop('_external', False)
if external:
return url
if endpoint == 'static':
url = app.config['CDN_URL_PREFIX'] + url
return url
def url_for_app(app, endpoint, **values):
ref_url = url_parse(get('locations')['base_url'])
url = flask_url_for(endpoint,
_scheme=ref_url.scheme,
_external=True,
**values)
url_ = url_parse(url)
new = url_unparse(
(ref_url.scheme, url_.netloc, path_for_app(app, url_.path), url_.query,
url_.fragment))
return new
def url_for(endpoint, **values):
from flask import url_for as flask_url_for
url = flask_url_for(endpoint, **values)
external = values.pop('_external', False)
if external:
return url
if endpoint == 'static':
url = app.config['CDN_URL_PREFIX'] + url
return url
def url_for(endpoint, **values):
app = current_app
if endpoint == 'static' or endpoint.endswith('.static'):
bucket_path = "{}/{}".format(app.config['S3_BUCKET_DOMAIN'], app.config['S3_BUCKET'])
urls = app.url_map.bind(bucket_path)
built_url = urls.build(endpoint, values=values, force_external=True)
scheme, netloc, path, params, query, fragment = urlparse(built_url)
return urlunparse(("", netloc, path, params, query, fragment))
return flask_url_for(endpoint, **values)
def url_for(endpoint, **values):
"""
Generates a URL to the given endpoint.
If the endpoint is for a static resource then a URL to the CDN is
generated, otherwise the call is passed on to `flask.url_for`.
Because this function is set as a jinja environment variable when
`CDN.init_app` is invoked, this function replaces `flask.url_for` in
templates automatically. It is unlikely that this function will need to be
directly called from within your application code, unless you need to refer
to static assets outside of your templates.
"""
app = current_app
if app.debug and not app.config["CDN_DEBUG"]:
return flask_url_for(endpoint, **values)
if endpoint == "static" or endpoint.endswith(".static"):
cdn_https = app.config["CDN_HTTPS"]
scheme = "http"
if cdn_https is True or (cdn_https is None and request.is_secure):
scheme = "https"
static_folder = app.static_folder
if request.blueprint is not None and app.blueprints[request.blueprint].static_folder:
static_folder = app.blueprints[request.blueprint].static_folder
cdn_domain = app.config["CDN_DOMAIN"]
urls = app.url_map.bind(cdn_domain, url_scheme=scheme)
if app.config["CDN_TIMESTAMP"]:
path = os.path.join(static_folder, values["filename"])
values["t"] = int(os.path.getmtime(path))
url = urls.build(endpoint, values=values, force_external=True)
return url.replace(cdn_domain.lower(), cdn_domain)
return flask_url_for(endpoint, **values)
def url_for(endpoint, **values):
appctx = _app_ctx_stack.top
if appctx is None:
raise RuntimeError('Attempted to generate a URL without the '
'application context being pushed. This has to be '
'executed when application context is available.')
app = appctx.app
file_name = values.get('filename')
force_no_cdn = values.pop('_force_no_cdn', False)
if app.config['CDN_DEBUG'] or force_no_cdn or not file_name:
return flask_url_for(endpoint, **values)
values['_external'] = True
url = flask_url_for(endpoint, **values)
pr = urlparse(url)
query = dict(parse_qsl(pr.query))
if app.config['CDN_VERSION']:
query.update({'v': app.config['CDN_VERSION']})
if app.config['CDN_TIMESTAMP'] and file_name:
path = None
if (request.blueprint is not None
and app.blueprints[request.blueprint].has_static_folder):
static_files = app.blueprints[request.blueprint].static_folder
path = os.path.join(static_files, file_name)
if path is None or not os.path.exists(path):
path = os.path.join(app.static_folder, file_name)
query.update({'t': int(os.path.getmtime(path))})
pr_list = list(pr)
if app.config['CDN_HTTPS'] is True:
pr_list[0] = 'https'
pr_list[1] = app.config['CDN_DOMAIN']
pr_list[4] = urlencode(query)
return urlunparse(pr_list)
def _url_for(endpoint: str, **values) -> Union[str, None]:
"""
The same as flask's url_for, except this also supports building external
urls for hosts that are different from app.config.SERVER_NAME. One case
where this is especially useful is for single page apps, where the frontend
is not hosted by the same server as the backend, but the backend still needs
to generate urls to frontend routes
:param endpoint: the name of the endpoint
:param values: the variable arguments of the URL rule
:return: a url path, or None
"""
_external_host = values.pop('_external_host', None)
is_external = bool(_external_host or values.get('_external'))
external_host = _external_host or current_app.config.get('EXTERNAL_SERVER_NAME')
if not is_external or not external_host:
return flask_url_for(endpoint, **values)
if '://' not in external_host:
external_host = f'http://{external_host}'
values.pop('_external')
return external_host.rstrip('/') + flask_url_for(endpoint, **values)
def url_for(endpoint, **values):
"""
Generates a URL to the given endpoint with the method provided
:param endpoint: the endpoint of the URL (name of the function)
:param values: the variable arguments of the URL rule
:param _params: if provided this dictionary is used to add additional parameters at runtime
"""
runtime_parameters = values.pop('_params', None)
if runtime_parameters:
for k, v in runtime_parameters.items():
# Make sure we don't overwrite compile time arguments
if not k in values.keys():
values[k] = v
return flask_url_for(endpoint, **values)
def url_for(*a, **kw):
"""Overwrite Flask url_for to force external paths."""
try:
kw['_external'] = False
query = kw.pop('_query', None)
authorize = kw.pop('_authorize', False)
path = flask_url_for(*a, **kw)
if authorize is True:
token = request.authz.to_token(scope=path)
query = list(ensure_list(query))
query.append(('api_key', token))
return url_external(path, query)
except RuntimeError:
return None
def static_url_for(self, endpoint, **values):
"""
This function uses Flask's url_for under the hood and accepts the
same arguments. The only difference is when a manifest is available
it will look up the filename from the manifest.
:param endpoint: The endpoint of the URL
:type endpoint: str
:param values: Arguments of the URL rule
:return: Static file path.
"""
if not self.has_manifest:
return flask_url_for(endpoint, **values)
new_filename = {}
filename = values.get("filename")
if filename:
new_filename["filename"] = self.manifest.get(filename)
merged_values = {**values, **new_filename}
return flask_url_for(endpoint, **merged_values)
def url_for(*a, **kw):
"""Overwrite Flask url_for to force external paths."""
try:
kw['_external'] = False
query = kw.pop('_query', None)
authorize = kw.pop('_authorize', False)
relative = kw.pop('_relative', False)
path = flask_url_for(*a, **kw)
if authorize is True and hasattr(request, 'authz'):
token = request.authz.to_token(scope=path)
query = list(ensure_list(query))
query.append(('api_key', token))
return url_external(path, query, relative=relative)
except RuntimeError:
return None
def url_for(endpoint, **values):
if endpoint == 'static':
state = get_state()
try:
rev_file = state.manifest_contents[values['filename']]
except KeyError:
pass
else:
values['filename'] = rev_file
if state.serve_root:
endpoint = state.endpoint
else:
# TODO: Handle external domains
values['_external'] = True
return flask_url_for(endpoint, **values)
def url_for(obj, **kw):
"""
Polymorphic variant of Flask's `url_for` function.
Behaves like the original function when the first argument is a string.
When it's an object, it
"""
if isinstance(obj, basestring):
return flask_url_for(obj, **kw)
try:
return current_app.default_view.url_for(obj, **kw)
except KeyError:
if hasattr(obj, "_url"):
return obj._url
elif hasattr(obj, "url"):
return obj.url
raise BuildError(repr(obj), kw, 'GET')
def url_for(endpoint, **values):
# check for language change order
target_lang = values.pop("_lang", g.lang)
# absolute URL?
external = values.pop("_external", False)
# force schema change?
schema = values.pop("_secure", None)
# allows to use "." for current path
if endpoint==".":
endpoint = request.endpoint
path = request.script_root + urllib2.quote(request.path.encode('utf-8'))
query_string = request.url
if u"?" in query_string:
try:
if not isinstance(query_string, unicode):
query_string = query_string.decode("utf-8")
path += query_string[query_string.find(u"?"):]
except:
pass
else:
path = flask_url_for(endpoint, **values)
# check for domain change order
target_domain = values.pop("_domain", _MultidomainBlueprint__endpoint_domain.get(endpoint, None)) or g.domain
# if must change anything overrides this method
if external or not schema is None or (target_domain and target_domain != g.domain) or (target_lang and target_lang!=g.lang):
# Use https if forced or is current schema
schema = "https://" if schema or (schema is None and g.secure_request) else "http://"
if target_lang and target_domain in g.translate_domains and target_lang!=g.langs[0]:
return schema + target_lang + "." + target_domain + get_domain_suffix() + path
else:
return schema + target_domain + get_domain_suffix() + path
return path
def inaccessible_callback(self, name, **kwargs):
return redirect(flask_url_for('account.login', next_url=request.url))
def url_for(endpoint):
if type(request.view_args) == type({}) and 'path' in request.view_args:
return '/%s%s' % (request.view_args['path'], flask_url_for(endpoint))
return flask_url_for(endpoint)
def url_for(endpoint, **kwargs):
kwargs['_external'] = True
return flask_url_for(endpoint, **kwargs)
def url_for(endpoint, **kwargs):
kwargs.setdefault('_external', True)
return flask_url_for(endpoint, **kwargs)
def network_path_url_for(endpoint): try: url = '/%s%s' % (request.source['network']['url_path'], flask_url_for(endpoint)) except: url = flask_url_for(endpoint) return url
def url_for(admin_ui_host, method_name):
return admin_ui_host + flask_url_for(method_name)
