geonode-pycsw 3.0.0b2__py3-none-any.whl

pycsw/wsgi.py

@@ -0,0 +1,233 @@
+# -*- coding: utf-8 -*-
+# =================================================================
+#
+# Authors: Adam Hinz <hinz.adam@gmail.com>
+#          Ricardo Garcia Silva <ricardo.garcia.silva@gmail.com>
+#          Tom Kralidis <tomkralidis@gmail.com>
+#
+# Copyright (c) 2015 Adam Hinz
+# Copyright (c) 2017 Ricardo Garcia Silva
+# Copyright (c) 2024 Tom Kralidis
+#
+# Permission is hereby granted, free of charge, to any person
+# obtaining a copy of this software and associated documentation
+# files (the "Software"), to deal in the Software without
+# restriction, including without limitation the rights to use,
+# copy, modify, merge, publish, distribute, sublicense, and/or sell
+# copies of the Software, and to permit persons to whom the
+# Software is furnished to do so, subject to the following
+# conditions:
+#
+# The above copyright notice and this permission notice shall be
+# included in all copies or substantial portions of the Software.
+#
+# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+# EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
+# OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+# NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
+# HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+# WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+# FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+# OTHER DEALINGS IN THE SOFTWARE.
+#
+# =================================================================
+
+# WSGI wrapper for pycsw
+#
+# Apache mod_wsgi configuration
+#
+# ServerName host1
+# WSGIDaemonProcess host1 home=/var/www/pycsw processes=2
+# WSGIProcessGroup host1
+#
+# WSGIScriptAlias /pycsw-wsgi /var/www/pycsw/wsgi.py
+#
+# <Directory /var/www/pycsw>
+#  Order deny,allow
+#  Allow from all
+# </Directory>
+#
+# or invoke this script from the command line:
+#
+# $ python3 ./pycsw/wsgi.py
+#
+# which will publish pycsw to:
+#
+# http://localhost:8000/
+#
+
+import gzip
+from io import BytesIO
+import os
+import sys
+
+from urllib.parse import unquote
+
+from pycsw import server
+
+
+def application(env, start_response):
+    """WSGI wrapper"""
+
+    status, headers, contents = application_dispatcher(env)
+    start_response(status, list(headers.items()))
+    return [contents]
+
+
+def application_dispatcher(env):
+    pycsw_root = get_pycsw_root_path(os.environ, env)
+    configuration_path = get_configuration_path(os.environ, env, pycsw_root)
+    env['local.app_root'] = pycsw_root
+    if 'HTTP_HOST' in env and ':' in env['HTTP_HOST']:
+        env['HTTP_HOST'] = env['HTTP_HOST'].split(':')[0]
+    csw = server.Csw(configuration_path, env)
+    status, contents = csw.dispatch_wsgi()
+    headers = {
+        'Content-Length': str(len(contents)),
+        'Content-Type': str(csw.contenttype)
+    }
+    if "gzip" in env.get("HTTP_ACCEPT_ENCODING", ""):
+        try:
+            compression_level = int(
+                csw.config["server"]["gzip_compresslevel"])
+            contents, compress_headers = compress_response(
+                contents, compression_level)
+            headers.update(compress_headers)
+        except KeyError:
+            print(
+                "The client requested a gzip compressed response. However, "
+                "the server does not specify the 'gzip_compresslevel' option. "
+                "Returning an uncompressed response..."
+            )
+
+    return status, headers, contents
+
+
+def compress_response(response, compression_level):
+    """Compress pycsw's response with gzip
+
+    Parameters
+    ----------
+    response: str
+        The already processed CSW request
+    compression_level: int
+        Level of compression to use in gzip algorithm
+
+    Returns
+    -------
+    bytes
+        The full binary contents of the compressed response
+    dict
+        Extra HTTP headers that are useful for the response
+
+    """
+
+    buf = BytesIO()
+    gzipfile = gzip.GzipFile(mode='wb', fileobj=buf,
+                             compresslevel=compression_level)
+    gzipfile.write(response)
+    gzipfile.close()
+    compressed_response = buf.getvalue()
+    compression_headers = {
+        'Content-Encoding': 'gzip',
+        'Content-Length': str(len(compressed_response)),
+    }
+    return compressed_response, compression_headers
+
+
+def get_pycsw_root_path(process_environment, request_environment=None,
+                        root_path_key="PYCSW_ROOT"):
+    """Get pycsw's root path.
+
+    The root path will be searched in the ``process_environment`` first, then
+    in the ``request_environment``. If it cannot be found then it is determined
+    based on the location on disk.
+
+    Parameters
+    ----------
+    process_environment: dict
+        A mapping with the process environment.
+    request_environment: dict, optional
+        A mapping with the request environment. Typically the WSGI's
+        environment
+    root_path_key: str
+        Name of the key in both the ``process_environment`` and the
+        ``request_environment`` parameters that specifies the path to pycsw's
+        root path.
+
+    Returns
+    -------
+    str
+        Path to pycsw's root path, as read from the supplied configuration.
+
+    """
+
+    req_env = (
+        dict(request_environment) if request_environment is not None else {})
+    app_root = process_environment.get(
+        root_path_key,
+        req_env.get(
+            root_path_key,
+            os.path.dirname(os.path.dirname(os.path.abspath(__file__)))
+        )
+    )
+    return app_root
+
+
+def get_configuration_path(process_environment, request_environment,
+                           pycsw_root, config_path_key="PYCSW_CONFIG"):
+    """Get the path for pycsw configuration file.
+
+    The configuration file path is searched in the following:
+    * The presence of a ``config`` parameter in the request's query string;
+    * A ``PYCSW_CONFIG`` environment variable;
+    * A ``PYCSW_CONFIG`` WSGI variable.
+
+    Parameters
+    ----------
+    process_environment: dict
+        A mapping with the process environment.
+    request_environment: dict
+        A mapping with the request's environment. Typically the WSGI's
+        environment
+    pycsw_root: str
+        pycsw's default root path
+    config_path_key: str, optional
+        Name of the variable that specifies the path to pycsw's configuration
+        file.
+
+    Returns
+    -------
+    str
+        Path where pycsw expects to find its own configuration file
+
+    """
+
+    # scan from config= or PYCSW_CONFIG environment variable
+    query_string = request_environment.get("QUERY_STRING", "").lower()
+
+    for kvp in query_string.split('&'):
+        if "config" in kvp:
+            configuration_path = unquote(kvp.split('=')[1])
+            break
+    else:
+        # did not find any `config` parameter in the request
+        # lets try the process env, request env and fallback to
+        # <pycsw_root>/default.yml
+        configuration_path = process_environment.get(
+            config_path_key,
+            request_environment.get(
+                config_path_key, os.path.join(pycsw_root, "default.yml")
+            )
+        )
+    return configuration_path
+
+
+if __name__ == '__main__':  # run inline using WSGI reference implementation
+    from wsgiref.simple_server import make_server
+    port = 8000
+    if len(sys.argv) > 1:
+        port = int(sys.argv[1])
+    httpd = make_server('', port, application)
+    print(f'Serving on port {port}...')
+    httpd.serve_forever()

pycsw/wsgi_flask.py

@@ -0,0 +1,345 @@
+# =================================================================
+#
+# Authors: Tom Kralidis <tomkralidis@gmail.com>
+#          Angelos Tzotsos <tzotsos@gmail.com>
+#
+# Copyright (c) 2024 Tom Kralidis
+# Copyright (c) 2021 Angelos Tzotsos
+#
+# Permission is hereby granted, free of charge, to any person
+# obtaining a copy of this software and associated documentation
+# files (the "Software"), to deal in the Software without
+# restriction, including without limitation the rights to use,
+# copy, modify, merge, publish, distribute, sublicense, and/or sell
+# copies of the Software, and to permit persons to whom the
+# Software is furnished to do so, subject to the following
+# conditions:
+#
+# The above copyright notice and this permission notice shall be
+# included in all copies or substantial portions of the Software.
+#
+# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+# EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
+# OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+# NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
+# HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+# WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+# FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+# OTHER DEALINGS IN THE SOFTWARE.
+#
+# =================================================================
+
+import os
+import sys
+
+from flask import Flask, Blueprint, make_response, request
+
+from pycsw.ogc.api.records import API
+from pycsw.ogc.api.util import STATIC, yaml_load
+from pycsw.stac.api import STACAPI
+from pycsw.wsgi import application_dispatcher
+
+
+APP = Flask(__name__, static_folder=STATIC, static_url_path='/static')
+APP.url_map.strict_slashes = False
+
+with open(os.getenv('PYCSW_CONFIG'), encoding='utf8') as fh:
+    APP.config['PYCSW_CONFIG'] = yaml_load(fh)
+
+BLUEPRINT = Blueprint('pycsw', __name__, static_folder=STATIC,
+                      static_url_path='/static')
+
+api_ = API(APP.config['PYCSW_CONFIG'])
+with open(os.getenv('PYCSW_CONFIG'), encoding='utf8') as fh:
+    stacapi = STACAPI(yaml_load(fh))
+
+
+def get_api_type(urlpath):
+    """
+    Decorator to detect API type
+
+    :param urlpath: URL path
+
+    :returns: `str` of API typ
+    """
+
+    api_type = 'ogcapi-records'
+
+    if 'stac' in urlpath:
+        api_type = 'stac-api'
+
+    return api_type
+
+
+def get_response(result: tuple):
+    """
+    Creates a Flask Response object and updates matching headers.
+
+    :param result:  The result of the API call.
+                    This should be a tuple of (headers, status, content).
+    :returns:       A Response instance.
+    """
+
+    headers, status, content = result
+
+    response = make_response(content, status)
+
+    if headers:
+        response.headers = headers
+    return response
+
+
+@BLUEPRINT.route('/')
+@BLUEPRINT.route('/stac')
+def landing_page():
+    """
+    OGC API landing page endpoint
+
+    :returns: HTTP response
+    """
+
+    if get_api_type(request.url_rule.rule) == 'stac-api':
+        return get_response(stacapi.landing_page(dict(request.headers), request.args))  # noqa
+    else:
+        return get_response(api_.landing_page(dict(request.headers), request.args))
+
+
+@BLUEPRINT.route('/openapi')
+@BLUEPRINT.route('/stac/openapi')
+def openapi():
+    """
+    OGC API OpenAPI document endpoint
+
+    :returns: HTTP response
+    """
+
+    if get_api_type(request.url_rule.rule) == 'stac-api':
+        return get_response(stacapi.openapi(dict(request.headers), request.args))
+    else:
+        return get_response(api_.openapi(dict(request.headers), request.args))
+
+
+@BLUEPRINT.route('/conformance')
+@BLUEPRINT.route('/stac/conformance')
+def conformance():
+    """
+    OGC API conformance endpoint
+
+    :returns: HTTP response
+    """
+
+    if get_api_type(request.url_rule.rule) == 'stac-api':
+        return get_response(stacapi.conformance(dict(request.headers), request.args))
+    else:
+        return get_response(api_.conformance(dict(request.headers), request.args))
+
+
+@BLUEPRINT.route('/collections', methods=['GET', 'POST'])
+@BLUEPRINT.route('/stac/collections', methods=['GET', 'POST'])
+def collections():
+    """
+    OGC API collections endpoint
+
+    :returns: HTTP response
+    """
+
+    if get_api_type(request.url_rule.rule) == 'stac-api':
+        if request.method == 'POST':
+            data = request.get_json(silent=True)
+            return get_response(stacapi.manage_collection_item(dict(request.headers),
+                                'create', data=data))
+        else:
+            return get_response(stacapi.collections(dict(request.headers),
+                                request.args))
+    else:
+        return get_response(api_.collections(dict(request.headers), request.args))
+
+
+@BLUEPRINT.route('/collections/<collection>', methods=['GET', 'PUT', 'DELETE'])
+@BLUEPRINT.route('/stac/collections/<collection>', methods=['GET', 'PUT', 'DELETE'])
+def collection(collection='metadata:main'):
+    """
+    OGC API collection endpoint
+
+    :param collection: collection name
+
+    :returns: HTTP response
+    """
+
+    if get_api_type(request.url_rule.rule) == 'stac-api':
+        if request.method == 'PUT':
+            return get_response(
+                stacapi.manage_collection_item(
+                    dict(request.headers), 'update', collection,
+                    data=request.get_json(silent=True)))
+        elif request.method == 'DELETE':
+            return get_response(
+                stacapi.manage_collection_item(dict(request.headers),
+                                               'delete', collection))
+        else:
+            return get_response(stacapi.collection(dict(request.headers),
+                                request.args, collection))
+    else:
+        return get_response(api_.collection(dict(request.headers),
+                            request.args, collection))
+
+
+@BLUEPRINT.route('/collections/<collection>/queryables')
+@BLUEPRINT.route('/stac/queryables')
+def queryables(collection='metadata:main'):
+    """
+    OGC API collection queryables endpoint
+
+    :param collection: collection name
+
+    :returns: HTTP response
+    """
+
+    if get_api_type(request.url_rule.rule) == 'stac-api':
+        return get_response(stacapi.queryables(dict(request.headers), request.args,
+                            collection))
+    else:
+        return get_response(api_.queryables(dict(request.headers), request.args,
+                            collection))
+
+
+@BLUEPRINT.route('/collections/<collection>/items', methods=['GET', 'POST'])
+@BLUEPRINT.route('/stac/search', methods=['GET', 'POST'])
+@BLUEPRINT.route('/stac/collections/<collection>/items', methods=['GET', 'POST'])
+def items(collection='metadata:main'):
+    """
+    OGC API collection items endpoint
+    STAC API items search endpoint
+
+    :param collection: collection name
+
+    :returns: HTTP response
+    """
+
+    if all([get_api_type(request.url_rule.rule) == 'ogcapi-records',
+            request.method == 'POST',
+            request.content_type not in [None, 'application/json']]):
+
+        # OGC API Transaction - create
+        data = None
+        if request.content_type == 'application/geo+json':  # JSON grammar
+            data = request.get_json(silent=True)
+        elif 'xml' in request.content_type:  # XML grammar
+            data = request.data
+
+        return get_response(api_.manage_collection_item(dict(request.headers),
+                            'create', data=data))
+    elif request.method == 'POST' and get_api_type(request.url_rule.rule) == 'stac-api':
+        if request.url_rule.rule.endswith('items'):  # STAC API transaction - create
+            data = request.get_json(silent=True)
+            return get_response(stacapi.manage_collection_item(dict(request.headers),
+                                'create', data=data, collection=collection))
+        else:  # STAC API search
+            return get_response(stacapi.items(dict(request.headers),
+                                request.get_json(silent=True), dict(request.args),
+                                collection))
+    elif get_api_type(request.url_rule.rule) == 'stac-api':
+        return get_response(stacapi.items(dict(request.headers),
+                            request.get_json(silent=True), dict(request.args),
+                            collection))
+    else:  # OGC API - Records items search
+        return get_response(api_.items(dict(request.headers),
+                            request.get_json(silent=True), dict(request.args),
+                            collection))
+
+
+@BLUEPRINT.route('/collections/<collection>/items/<path:item>',
+                 methods=['GET', 'PUT', 'DELETE'])
+@BLUEPRINT.route('/stac/collections/<collection>/items/<item>',
+                 methods=['GET', 'PUT', 'DELETE'])
+def item(collection='metadata:main', item=None):
+    """
+    OGC API collection items endpoint
+
+    :param collection: collection name
+    :param item: item identifier
+
+    :returns: HTTP response
+    """
+
+    if request.method == 'PUT':
+        return get_response(
+            api_.manage_collection_item(
+                dict(request.headers), 'update', item,
+                data=request.get_json(silent=True)))
+    elif request.method == 'DELETE':
+        return get_response(
+            api_.manage_collection_item(dict(request.headers), 'delete', item))
+    else:
+        if get_api_type(request.url_rule.rule) == 'stac-api':
+            return get_response(stacapi.item(dict(request.headers), request.args,
+                                collection, item))
+        else:
+            return get_response(api_.item(dict(request.headers), request.args,
+                                collection, item))
+
+
+@BLUEPRINT.route('/csw', methods=['GET', 'POST'])
+def csw():
+    """
+    CSW endpoint
+
+    :returns: HTTP response
+    """
+
+    request.environ['PYCSW_IS_CSW'] = True
+    status, headers, content = application_dispatcher(request.environ)
+
+    return get_response((headers, status, content))
+
+
+@BLUEPRINT.route('/opensearch', methods=['GET'])
+def opensearch():
+    """
+    OpenSearch endpoint
+
+    :returns: HTTP response
+    """
+
+    request.environ['PYCSW_IS_OPENSEARCH'] = True
+    status, headers, content = application_dispatcher(request.environ)
+
+    return get_response((headers, status, content))
+
+
+@BLUEPRINT.route('/oaipmh', methods=['GET'])
+def oaipmh():
+    """
+    OpenSearch endpoint
+
+    :returns: HTTP response
+    """
+
+    request.environ['PYCSW_IS_OAIPMH'] = True
+    status, headers, content = application_dispatcher(request.environ)
+
+    return get_response((headers, status, content))
+
+
+@BLUEPRINT.route('/sru', methods=['GET'])
+def sru():
+    """
+    OpenSearch endpoint
+
+    :returns: HTTP response
+    """
+
+    request.environ['PYCSW_IS_SRU'] = True
+    status, headers, content = application_dispatcher(request.environ)
+
+    return get_response((headers, status, content))
+
+
+APP.register_blueprint(BLUEPRINT)
+
+if __name__ == '__main__':
+    port = 8000
+    if len(sys.argv) > 1:
+        port = int(sys.argv[1])
+    print(f'Serving on port {port}')
+    APP.run(debug=True, host='0.0.0.0', port=port)