reliqua 0.0.6__py3-none-any.whl

reliqua/__init__.py

@@ -0,0 +1,27 @@
+"""
+MIT License.
+
+Copyright (c) 2017 Terrence Meiczinger
+
+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.
+"""
+
+from .app import Application, load_config
+
+__all__ = ["Application", "load_config"]

reliqua/api.py

@@ -0,0 +1,196 @@
+"""
+MIT License.
+
+Copyright (c) 2017 Terrence Meiczinger
+
+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 glob
+import importlib
+import inspect
+import os
+import re
+import sys
+import uuid
+
+import falcon
+from falcon_cors import CORS
+
+from .auth import AuthMiddleware
+from .docs import Docs
+from .media_handlers import JSONHandler, TextHandler, YAMLHandler
+from .openapi import OpenApi
+from .resources.base import Resource
+from .sphinx_parser import SphinxParser
+from .swagger import Swagger
+
+
+class Api(falcon.App):
+    """Add auto route and documentation."""
+
+    def __init__(
+        self,
+        resource_path=None,
+        middleware=None,
+        config=None,
+        resource_attributes=None,
+        info=None,
+        openapi=None,
+        **_kwargs,
+    ):
+        """
+        Create an API instance.
+
+        :param str resource_path:             Path to the resource modules
+        :param list middleware:               Middleware
+        :param dict config:                   API configuration parameters
+        :param dict resource_attributes:      Parameters added as resource attributes
+        :param dict info:                     Application information
+        :param dict openapi:                  OpenAPI configuration options
+
+        :return:                               api instance
+        """
+        info = info or {}
+        openapi = openapi or {}
+
+        openapi_path = openapi["path"]
+        self.url = openapi["api_url"]
+
+        self.openapi = openapi
+        self.info = info
+
+        self.openapi["spec"] = f"{openapi_path}/openapi.json"
+        self.openapi["static"] = f"{openapi_path}/static"
+        self.resources = []
+        self.auth = [x for x in middleware if isinstance(x, AuthMiddleware)]
+        self.config = config or {}
+        self.resource_attributes = resource_attributes or {}
+
+        path = os.path.dirname(sys.modules[__name__].__file__)
+        self.openapi["file_path"] = f"{path}/swagger"
+        self.openapi["spec_url"] = f"{self.url}{self.openapi['spec']}"
+        self.openapi["static_url"] = f"{self.url}{self.openapi['static']}"
+
+        middleware = middleware or []
+        cors = CORS(allow_all_origins=True, allow_all_methods=True, allow_all_headers=True)
+        middleware.append(cors.middleware)
+
+        super().__init__(middleware=middleware)
+
+        if not resource_path:
+            resource_path = path + "/resources"
+
+        self.req_options.auto_parse_form_urlencoded = True
+        self.resource_path = resource_path
+
+        self._add_handlers()
+        self._load_resources()
+        self._parse_docstrings()
+        self._add_routes()
+        self._add_docs()
+
+    def _add_handlers(self):
+        extra_handlers = {
+            "application/yaml": YAMLHandler(),
+            "text/html; charset=utf-8": TextHandler(),
+            "text/plain; charset=utf-8": TextHandler(),
+            "application/json": JSONHandler(),
+        }
+
+        self.req_options.media_handlers.update(extra_handlers)
+        self.resp_options.media_handlers.update(extra_handlers)
+
+    def _load_resources(self):
+        resources = []
+        path = f"{self.resource_path}/*.py"
+        print(f"searching {path}")
+        files = glob.glob(path)
+
+        for file in files:
+            print(f"loading {file}")
+            classes = self._get_classes(file)
+            resources.extend(classes)
+
+        # add config to resource
+        self.resources = [x(app_config=self.config, **self.resource_attributes) for x in resources]
+
+    def _is_route_method(self, name, suffix):
+        if not name.startswith("on_"):
+            return None
+
+        if suffix:
+            return name.endswith(suffix)
+
+        return re.search(r"^on_([a-z]+)$", name)
+
+    def _parse_methods(self, resource, route, methods):
+        parser = SphinxParser()
+        for name in methods:
+            operation_id = f"{resource.__class__.__name__}.{name}"
+            action = re.search(r"on_(delete|get|patch|post|put)", name).group(1)
+            method = getattr(resource, name)
+            resource.__data__[route][action] = parser.parse(method, operation_id=operation_id)
+
+    def _parse_resource(self, resource):
+        for route, data in resource.__routes__.items():
+            resource.__data__[route] = {}
+            suffix = data.get("suffix", None)
+            methods = [x for x in dir(resource) if self._is_route_method(x, suffix)]
+            self._parse_methods(resource, route, methods)
+
+    def _parse_docstrings(self):
+        for resource in self.resources:
+            resource.__data__ = {}
+            self._parse_resource(resource)
+
+    def _get_classes(self, filename):
+        classes = []
+        module_name = str(uuid.uuid3(uuid.NAMESPACE_OID, filename))
+        spec = importlib.util.spec_from_file_location(module_name, filename)
+        module = importlib.util.module_from_spec(spec)
+        spec.loader.exec_module(module)
+
+        for _, c in inspect.getmembers(module, inspect.isclass):
+            if issubclass(c, Resource) and hasattr(c, "__routes__"):
+                classes.append(c)
+
+        return classes
+
+    def _add_routes(self):
+        for resource in self.resources:
+            routes = resource.__routes__
+            for route, kwargs in routes.items():
+                self.add_route(route, resource, **kwargs)
+
+    def _add_docs(self):
+        swagger = Swagger(
+            self.openapi["static_url"],
+            self.openapi["spec_url"],
+            sort=self.openapi["sort"],
+            highlight=self.openapi["highlight"],
+        )
+        openapi = OpenApi(**self.info, auth=self.auth)
+        openapi.process_resources(self.resources)
+        schema = openapi.schema()
+        print(f"adding static route {self.openapi['docs_endpoint']} {self.openapi['file_path']}")
+        self.add_static_route(self.openapi["static"], self.openapi["file_path"])
+        self.add_route(self.openapi["docs_endpoint"], swagger)
+        print(f"adding openapi file {self.openapi['spec']}")
+        self.add_route(self.openapi["spec"], Docs(schema))

reliqua/app.py

@@ -0,0 +1,169 @@
+"""
+Reliqua Framework.
+
+Copyright 2016-2024.
+"""
+
+import configparser
+
+from gunicorn.app.base import BaseApplication
+
+from .api import Api
+from .middleware import ProcessParams
+
+GUNICORN_DEFAULTS = {
+    "bind": "127.0.0.1:8000",  # Address and port to listen for requests [host:port]
+    "workers": 1,  # Number of worker processes
+    "loglevel": "critical",  # Log level (debug, error, info, critical)
+    "accesslog": "-",  # Access log path ("-" for stream, None to disable)
+    "errorlog": "-",  # Error log path ("-" for stream, None to disable)
+    "worker_class": "gthread",  # Type of worker processes
+    "timeout": 30,  # Inactive worker timeout (worker killed)
+    "keepalive": 2,  # Keep alive period for a request
+}
+
+OPENAPI_DEFAULTS = {
+    "api_url": None,  # API URL used by OpenAI UI (if different from bind, for example, behind a proxy)
+    "ui_url": None,  # OpenAPI UI index url
+    "highlight": True,  # Enable OpenAPI syntax highlighting
+    "sort": "alpha",  # OpenAPI endpoint/tag sort order
+    "path": "/openapi",  # OpenAPI endpoint path (JSON and static files)
+    "docs_endpoint": "/docs",  # Documentation endpoint
+}
+
+INFO_DEFAULTS = {
+    "title": "Application Title",  # Application title
+    "version": "1.0.0",  # Application version
+    "description": "",  # Application description
+    "license": "",  # License
+    "license_url": "",  # License URL
+    "contact_name": "",  # Contact name
+}
+
+
+def update_dict(a, b):
+    """
+    Update dictionary A with values from dictionary B.
+
+    Update the diction A with values from dictionary B. Remove
+    keys from A that are not in B.
+
+    :param dict a:    Dictionary A
+    :param dict b:    Dictionary B
+    """
+    # Create a new dictionary with keys from A that are also in B
+    updated_dict = {key: a[key] for key in a if key in b}
+
+    # Add keys from B that are not in A
+    for key in b:
+        if key not in updated_dict:
+            updated_dict[key] = b[key]
+
+    return updated_dict
+
+
+def load_config(config_file):
+    """
+    Load configuration file.
+
+    :param str config_file:    Configuration file
+    :return dict:              Options dictionary
+    """
+    params = {}
+
+    try:
+        section = "config"
+        config = configparser.ConfigParser()
+        config.read(config_file)
+
+        for option in config.options(section):
+            params[option] = config.get(section, option)
+    except TypeError:
+        pass
+
+    return params
+
+
+class Application(BaseApplication):
+    """Create a standalone API application."""
+
+    def __init__(
+        self,
+        resource_path=None,
+        middleware=None,
+        config=None,
+        resource_attributes=None,
+        info=None,
+        openapi=None,
+        gunicorn=None,
+        **_kwargs,
+    ):
+        """
+        Create Application instance.
+
+        :param str resource_path:         Path to the API resource modules
+        :param list middleware:           Middleware
+        :param dict config:               Application resource parameters (passed to resources as config attribute)
+        :param dict resource_attributes:  Parameters added as resource attributes
+        :param str info:                  Application information
+        :param str openapi:               OpenAPI configuration options
+        :param dict gunicorn:             Gunicorn configuration options
+
+        :return:                          Application instance
+        """
+        middleware = middleware or []
+        gunicorn = gunicorn or {}
+        openapi = openapi or {}
+        info = info or {}
+
+        resource_path = resource_path or ""
+        resource_attributes = resource_attributes or {}
+
+        self.gunicorn_options = update_dict(gunicorn, GUNICORN_DEFAULTS)
+        openapi = update_dict(openapi, OPENAPI_DEFAULTS)
+        info = update_dict(info, INFO_DEFAULTS)
+
+        middleware.append(ProcessParams())
+
+        # trim slashes from proxy URL if specified; otherwise set default proxy url
+        bind = self.gunicorn_options["bind"]
+        openapi["api_url"] = openapi["api_url"].rstrip("/") if openapi["api_url"] else f"http://{bind}"
+
+        self.application = Api(
+            resource_path=resource_path,
+            middleware=middleware,
+            config=config,
+            resource_attributes=resource_attributes,
+            openapi=openapi,
+            info=info,
+        )
+
+        super().__init__()
+
+    def init(self, _parser, _opts, _args):
+        """
+        Init method.
+
+        This is not invoked, since the load_config method
+        is also overridden.
+        """
+        return
+
+    def load_config(self):
+        """
+        Load configuration.
+
+        Default config loader. This load settings from a config file
+        with a 'config' section. This method should be overloaded
+        if a custom loader is required.
+        """
+        for key, value in self.gunicorn_options.items():
+            self.cfg.set(key.lower(), value)
+
+    def load(self):
+        """
+        Load the application.
+
+        Base class.
+        """
+        return self.application