libentry 1.22.4__py3-none-any.whl → 1.23__py3-none-any.whl

libentry/schema.py

@@ -2,9 +2,10 @@
 
 __author__ = "xi"
 __all__ = [
+    "APISignature",
+    "get_api_signature",
     "SchemaField",
     "Schema",
-    "ParseContext",
     "parse_type",
     "QueryAPIOutput",
     "query_api",
@@ -13,14 +14,73 @@ __all__ = [
 import enum
 from dataclasses import asdict, dataclass, is_dataclass
 from inspect import signature
-from typing import Any, Dict, Iterable, List, Literal, Mapping, MutableMapping, NoReturn, Optional, Sequence, Union, \
-    get_args, \
-    get_origin
+from typing import Any, Dict, Iterable, List, Literal, Mapping, MutableMapping, NoReturn, Optional, Sequence, Type, \
+    Union, get_args, get_origin
 
-from pydantic import BaseModel, Field, create_model
+from pydantic import BaseModel, ConfigDict, Field, RootModel, create_model
 from pydantic_core import PydanticUndefined
 
 
+class APISignature(BaseModel):
+    input_types: List[Any]
+    input_model: Optional[Type[BaseModel]] = None
+    bundled_model: Optional[Type[BaseModel]] = None
+    output_type: Optional[Any] = None
+    output_model: Optional[Type[BaseModel]] = None
+
+
+def get_api_signature(fn, ignores: List[str] = ("self", "cls")) -> APISignature:
+    sig = signature(fn)
+
+    input_types = []
+    fields = {}
+    for name, param in sig.parameters.items():
+        if name in ignores:
+            continue
+
+        annotation = param.annotation
+        if annotation is sig.empty:
+            annotation = Any
+
+        input_types.append(annotation)
+
+        default = param.default
+        field = Field() if default is sig.empty else Field(default=default)
+        fields[name] = (annotation, field)
+
+    input_model = None
+    bundled_model = None
+    if len(input_types) == 1:
+        for annotation in input_types:
+            origin = get_origin(annotation) or annotation
+            if isinstance(origin, type) and issubclass(origin, BaseModel):
+                input_model = origin
+    if input_model is None:
+        name = "".join(word.capitalize() for word in fn.__name__.split("_"))
+        bundled_model = create_model(
+            f"{name}Request*",
+            __config__=ConfigDict(extra="forbid"),
+            **fields
+        )
+
+    output_type = None
+    output_model = None
+    output_annotation = sig.return_annotation
+    if output_annotation is not None and output_annotation is not NoReturn:
+        if output_annotation is sig.empty:
+            output_annotation = Any
+        output_type = output_annotation
+        output_model = RootModel[output_annotation]
+
+    return APISignature(
+        input_types=input_types,
+        input_model=input_model,
+        bundled_model=bundled_model,
+        output_type=output_type,
+        output_model=output_model
+    )
+
+
 class SchemaField(BaseModel):
     name: str = Field()
     type: Union[str, List[str]] = Field("Any")
@@ -75,13 +135,14 @@ def type_parser(fn):
 
 
 @type_parser
-def _parse_basic_types(context: ParseContext):
+def _parse_basic_types(context: ParseContext) -> Optional[str]:
     if context.origin in {int, float, str, bool}:
         return context.origin.__name__
+    return None
 
 
 @type_parser
-def _parse_dict(context: ParseContext):
+def _parse_dict(context: ParseContext) -> Optional[str]:
     if issubclass(context.origin, Mapping):
         dict_args = get_args(context.annotation)
         if dict_args:
@@ -95,10 +156,11 @@ def _parse_dict(context: ParseContext):
             return f"Dict[{key_type},{value_type}]"
         else:
             return "Dict"
+    return None
 
 
 @type_parser
-def _parse_list(context: ParseContext):
+def _parse_list(context: ParseContext) -> Optional[str]:
     if issubclass(context.origin, Sequence):
         list_args = get_args(context.annotation)
         if list_args:
@@ -110,16 +172,18 @@ def _parse_list(context: ParseContext):
             return f"List[{elem_type}]"
         else:
             return "List"
+    return None
 
 
 @type_parser
-def _parse_enum(context: ParseContext):
+def _parse_enum(context: ParseContext) -> Optional[str]:
     if issubclass(context.origin, enum.Enum):
         return f"Enum[{','.join(e.name for e in context.origin)}]"
+    return None
 
 
 @type_parser
-def _parse_base_model(context: ParseContext):
+def _parse_base_model(context: ParseContext) -> Optional[str]:
     origin = context.origin
     if issubclass(origin, BaseModel):
         _module = origin.__module__
@@ -155,10 +219,11 @@ def _parse_base_model(context: ParseContext):
             context.schemas[model_name] = schema
 
         return model_name
+    return None
 
 
 @type_parser
-def _parse_iterable(context: ParseContext):
+def _parse_iterable(context: ParseContext) -> Optional[str]:
     if context.origin.__name__ in {"Iterable", "Generator", "range"} and issubclass(context.origin, Iterable):
         iter_args = get_args(context.annotation)
         if len(iter_args) != 1:
@@ -167,20 +232,23 @@ def _parse_iterable(context: ParseContext):
         if isinstance(iter_type, list):
             raise TypeError("\"Union\" cannot be used as the type of iterable elements.")
         return f"Iter[{iter_type}]"
+    return None
 
 
 @type_parser
-def _parse_none_type(context: ParseContext):
+def _parse_none_type(context: ParseContext) -> Optional[str]:
     origin = context.origin
     if origin.__module__ == "builtins" and origin.__name__ == "NoneType":
         return "NoneType"
+    return None
 
 
 @type_parser
-def _parse_ndarray(context: ParseContext):
+def _parse_ndarray(context: ParseContext) -> Optional[str]:
     origin = context.origin
     if origin.__module__ == "numpy" and origin.__name__ == "ndarray":
         return "numpy.ndarray"
+    return None
 
 
 def generic_parser(fn):
@@ -189,25 +257,28 @@ def generic_parser(fn):
 
 
 @generic_parser
-def _parse_any(context: ParseContext):
+def _parse_any(context: ParseContext) -> Optional[str]:
     if context.origin is Any or str(context.origin) == str(Any):
         return "Any"
+    return None
 
 
 @generic_parser
-def _parse_union(context: ParseContext):
+def _parse_union(context: ParseContext) -> Optional[List[str]]:
     if context.origin is Union or str(context.origin) == str(Union):
         return [
             parse_type(arg, context.schemas)
             for arg in get_args(context.annotation)
         ]
+    return None
 
 
 @generic_parser
-def _parse_literal(context: ParseContext):
+def _parse_literal(context: ParseContext) -> Optional[str]:
     if context.origin is Literal or str(context.origin) == str(Literal):
         enum_args = get_args(context.annotation)
         return f"Enum[{','.join(map(str, enum_args))}]"
+    return None
 
 
 class QueryAPIOutput(BaseModel):
@@ -217,49 +288,33 @@ class QueryAPIOutput(BaseModel):
     bundled_input: bool
 
 
-def query_api(fn) -> QueryAPIOutput:
-    sig = signature(fn)
-
-    fields = {}
-    for name, param in sig.parameters.items():
-        if name in ["self", "cls"]:
-            continue
-
-        annotation = param.annotation
-        if annotation is sig.empty:
-            annotation = Any
-
-        default = param.default
-        field = Field() if default is sig.empty else Field(default)
-        fields[name] = (annotation, field)
-
-    args_model = None
-    if len(fields) == 1:
-        for annotation, _ in fields.values():
-            origin = get_origin(annotation)
-            if origin is None:
-                origin = annotation
-            if isinstance(origin, type) and issubclass(origin, BaseModel):
-                args_model = origin
-    bundle = args_model is None
-    if bundle:
-        name = "".join(word.capitalize() for word in fn.__name__.split("_"))
-        args_model = create_model(f"{name}Request*", **fields)
+def query_api(obj) -> QueryAPIOutput:
+    api_models = obj if isinstance(obj, APISignature) else get_api_signature(obj)
 
     context = {}
+
+    args_model = api_models.input_model or api_models.bundled_model
     input_schema = parse_type(args_model, context)
+
     output_schema = None
-    return_annotation = sig.return_annotation
-    if return_annotation is not None and return_annotation is not NoReturn:
-        if return_annotation is sig.empty:
-            return_annotation = Any
-        output_schema = parse_type(return_annotation, context)
+    if api_models.output_type is not None:
+        output_schema = parse_type(api_models.output_type, context)
     if isinstance(output_schema, list):
         output_schema = output_schema[0]
 
+    # output_schema = None
+    # sig = signature(fn)
+    # return_annotation = sig.return_annotation
+    # if return_annotation is not None and return_annotation is not NoReturn:
+    #     if return_annotation is sig.empty:
+    #         return_annotation = Any
+    #     output_schema = parse_type(return_annotation, context)
+    # if isinstance(output_schema, list):
+    #     output_schema = output_schema[0]
+
     return QueryAPIOutput(
         input_schema=input_schema,
         output_schema=output_schema,
         context=context,
-        bundled_input=bundle,
+        bundled_input=api_models.bundled_model is not None,
     )

libentry/service/flask.py

@@ -380,7 +380,7 @@ def run_service(
     if backlog is None or backlog < num_threads * 2:
         backlog = num_threads * 2
 
-    def ssl_context(config, default_ssl_context_factory):
+    def ssl_context(config, _default_ssl_context_factory):
         import ssl
         context = ssl.create_default_context(ssl.Purpose.CLIENT_AUTH)
         context.load_cert_chain(

{libentry-1.22.4.dist-info → libentry-1.23.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.2
 Name: libentry
-Version: 1.22.4
+Version: 1.23
 Summary: Entries for experimental utilities.
 Home-page: https://github.com/XoriieInpottn/libentry
 Author: xi
@@ -29,6 +29,7 @@ Dynamic: requires-dist
 Dynamic: summary
 
 # libentry
+[![Ask DeepWiki](https://deepwiki.com/badge.svg)](https://deepwiki.com/XoriieInpottn/libentry)
 
 ## Define a Service Class
 1. Define a normal python class.

libentry-1.23.dist-info/RECORD

@@ -0,0 +1,30 @@
+libentry/__init__.py,sha256=ko2YBIIx5H3dD0tedBkialzJGEDczFaP_PZmT1cIlak,148
+libentry/api.py,sha256=lw_XH7GMWxwX7OzN4K5SxBHobjNIT-FNiTcRK60v7Fg,24151
+libentry/argparse.py,sha256=NxzXV-jBN51ReZsNs5aeyOfzwYQ5A5nJ95rWoa-FYCs,10415
+libentry/dataclasses.py,sha256=AQV2PuxplJCwGZ5HKX72U-z-POUhTdy3XtpEK9KNIGQ,4541
+libentry/executor.py,sha256=cTV0WxJi0nU1TP-cOwmeodN8DD6L1691M2HIQsJtGrU,6582
+libentry/experiment.py,sha256=ejgAHDXWIe9x4haUzIFuz1WasLY0_aD1z_vyEVGjTu8,4922
+libentry/json.py,sha256=CubUUu29h7idLaC4d66vKhjBgVHKN1rZOv-Tw2qM17k,1916
+libentry/logging.py,sha256=IiYoCUzm8XTK1fduA-NA0FI2Qz_m81NEPV3d3tEfgdI,1349
+libentry/schema.py,sha256=i-TswY-R7Lw-WY1pFFYBMoEUCPN_tpUMpezlS7nQgIw,10107
+libentry/test_api.py,sha256=Xw7B7sH6g1iCTV5sFzyBF3JAJzeOr9xg0AyezTNsnIk,4452
+libentry/utils.py,sha256=O7P6GadtUIjq0N2IZH7PhHZDUM3NebzcqyDqytet7CM,683
+libentry/mcp/__init__.py,sha256=1oLL20yLB1GL9IbFiZD8OReDqiCpFr-yetIR6x1cNkI,23
+libentry/mcp/api.py,sha256=uoGBYCesMj6umlJpRulKZNS3trm9oG3LUSg1otPDS_8,2362
+libentry/mcp/client.py,sha256=lM_bTF40pbdYdBrMmoOqUDRzlNgjqEKh5d4IVkpI6D8,21512
+libentry/mcp/service.py,sha256=KDpEUhHuyVXjc_J5Z9_aciJbTcEy9dYA44rpdgAAwGE,32322
+libentry/mcp/types.py,sha256=xTQCnKAgeJNss4klJ33MrWHGCzG_LeR3urizO_Z9q9U,12239
+libentry/service/__init__.py,sha256=1oLL20yLB1GL9IbFiZD8OReDqiCpFr-yetIR6x1cNkI,23
+libentry/service/common.py,sha256=OVaW2afgKA6YqstJmtnprBCqQEUZEWotZ6tHavmJJeU,42
+libentry/service/flask.py,sha256=2egCFFhRAfLpmSyibgaJ-3oexI-j27P1bmaPEn-hSlc,13817
+libentry/service/list.py,sha256=ElHWhTgShGOhaxMUEwVbMXos0NQKjHsODboiQ-3AMwE,1397
+libentry/service/running.py,sha256=FrPJoJX6wYxcHIysoatAxhW3LajCCm0Gx6l7__6sULQ,5105
+libentry/service/start.py,sha256=mZT7b9rVULvzy9GTZwxWnciCHgv9dbGN2JbxM60OMn4,1270
+libentry/service/stop.py,sha256=wOpwZgrEJ7QirntfvibGq-XsTC6b3ELhzRW2zezh-0s,1187
+libentry-1.23.dist-info/LICENSE,sha256=xx0jnfkXJvxRnG63LTGOxlggYnIysveWIZ6H3PNdCrQ,11357
+libentry-1.23.dist-info/METADATA,sha256=_2SdH3WYDWIH-bs_FzKN3NHzViQKtYFDf7BKVs19WcM,1133
+libentry-1.23.dist-info/WHEEL,sha256=In9FTNxeP60KnTkGw7wk6mJPYd_dQSjEZmXdBdMCI-8,91
+libentry-1.23.dist-info/entry_points.txt,sha256=1v_nLVDsjvVJp9SWhl4ef2zZrsLTBtFWgrYFgqvQBgc,61
+libentry-1.23.dist-info/top_level.txt,sha256=u2uF6-X5fn2Erf9PYXOg_6tntPqTpyT-yzUZrltEd6I,9
+libentry-1.23.dist-info/zip-safe,sha256=AbpHGcgLb-kRsJGnwFEktk7uzpZOCcBY74-YBdrKVGs,1
+libentry-1.23.dist-info/RECORD,,

libentry/service/flask_mcp.py

@@ -1,337 +0,0 @@
-#!/usr/bin/env python3
-
-__author__ = "xi"
-__all__ = [
-    "MCPMethod",
-]
-
-import asyncio
-import traceback
-from inspect import signature
-from types import GeneratorType
-from typing import Callable, Dict, Iterable, Optional, Type, Union
-
-from flask import Flask, request as flask_request
-from pydantic import BaseModel
-
-from libentry import api, json, logger
-from libentry.api import list_api_info
-from libentry.schema import query_api
-
-try:
-    from gunicorn.app.base import BaseApplication
-except ImportError:
-    class BaseApplication:
-
-        def load(self) -> Flask:
-            pass
-
-        def run(self):
-            flask_server = self.load()
-            assert hasattr(self, "options")
-            bind = getattr(self, "options")["bind"]
-            pos = bind.rfind(":")
-            host = bind[:pos]
-            port = int(bind[pos + 1:])
-            logger.warn("Your system doesn't support gunicorn.")
-            logger.warn("Use Flask directly.")
-            logger.warn("Options like \"num_threads\", \"num_workers\" are ignored.")
-            return flask_server.run(host=host, port=port)
-
-
-class MCPMethod:
-
-    def __init__(self, fn: Callable, method: str = None):
-        self.fn = fn
-        assert hasattr(fn, "__name__")
-        self.__name__ = fn.__name__
-        self.method = self.__name__ if method is None else method
-
-        self.input_schema = None
-        params = signature(fn).parameters
-        if len(params) == 1:
-            for name, value in params.items():
-                annotation = value.annotation
-                if isinstance(annotation, type) and issubclass(annotation, BaseModel):
-                    self.input_schema = annotation
-
-    def __call__(self, request: dict) -> Union[dict, Iterable[dict]]:
-        try:
-            jsonrpc_version = request["jsonrpc"]
-            request_id = request["id"]
-            method = request["method"]
-        except KeyError:
-            raise RuntimeError("Invalid JSON-RPC specification.")
-
-        if not isinstance(request_id, (str, int)):
-            raise RuntimeError(
-                f"Request ID should be an integer or string. "
-                f"Got {type(request_id)}."
-            )
-
-        if method != self.method:
-            raise RuntimeError(
-                f"Method missmatch."
-                f"Expect {self.method}, got {method}."
-            )
-
-        params = request.get("params", {})
-
-        try:
-            if self.input_schema is not None:
-                # Note that "input_schema is not None" means:
-                # (1) The function has only one argument;
-                # (2) The arguments is a BaseModel.
-                # In this case, the request data can be directly validated as a "BaseModel" and
-                # subsequently passed to the function as a single object.
-                pydantic_params = self.input_schema.model_validate(params)
-                result = self.fn(pydantic_params)
-            else:
-                # The function has multiple arguments, and the request data bundle them as a single object.
-                # So, they should be unpacked before pass to the function.
-                result = self.fn(**params)
-        except Exception as e:
-            if isinstance(e, (SystemExit, KeyboardInterrupt)):
-                raise e
-            return {
-                "jsonrpc": jsonrpc_version,
-                "id": request_id,
-                "error": self._make_error(e)
-            }
-
-        if not isinstance(result, (GeneratorType, range)):
-            return {
-                "jsonrpc": jsonrpc_version,
-                "id": request_id,
-                "result": result
-            }
-
-        return ({
-            "jsonrpc": jsonrpc_version,
-            "id": request_id,
-            "result": item
-        } for item in result)
-
-    @staticmethod
-    def _make_error(e):
-        err_cls = e.__class__
-        err_name = err_cls.__name__
-        module = err_cls.__module__
-        if module != "builtins":
-            err_name = f"{module}.{err_name}"
-        return {
-            "code": 1,
-            "message": f"{err_name}: {str(e)}",
-            "data": traceback.format_exc()
-        }
-
-
-class FlaskMethod:
-
-    def __init__(self, method, api_info, app):
-        self.method = MCPMethod(method)
-        self.api_info = api_info
-        self.app = app
-        assert hasattr(method, "__name__")
-        self.__name__ = method.__name__
-
-    CONTENT_TYPE_JSON = "application/json"
-    CONTENT_TYPE_SSE = "text/event-stream"
-
-    def __call__(self):
-        args = flask_request.args
-        data = flask_request.data
-        content_type = flask_request.content_type
-        accepts = flask_request.accept_mimetypes
-
-        json_from_url = {**args}
-        if data:
-            if (not content_type) or content_type == self.CONTENT_TYPE_JSON:
-                json_from_data = json.loads(data)
-            else:
-                return self.app.error(f"Unsupported Content-Type: \"{content_type}\".")
-        else:
-            json_from_data = {}
-
-        conflicts = json_from_url.keys() & json_from_data.keys()
-        if len(conflicts) > 0:
-            return self.app.error(f"Duplicated fields: \"{conflicts}\".")
-
-        input_json = {**json_from_url, **json_from_data}
-        print(input_json)
-
-        try:
-            output_json = self.method(input_json)
-        except Exception as e:
-            return self.app.error(str(e))
-
-        if isinstance(output_json, Dict):
-            if self.CONTENT_TYPE_JSON in accepts:
-                return self.app.ok(json.dumps(output_json), mimetype=self.CONTENT_TYPE_JSON)
-            else:
-                return self.app.error(f"Unsupported Accept: \"{[*accepts]}\".")
-        elif isinstance(output_json, (GeneratorType, range)):
-            if self.CONTENT_TYPE_SSE in accepts:
-                # todo
-                return self.app.ok(json.dumps(output_json), mimetype=self.CONTENT_TYPE_SSE)
-            else:
-                return self.app.error(f"Unsupported Accept: \"{[*accepts]}\".")
-
-
-class FlaskServer(Flask):
-
-    def __init__(self, service):
-        super().__init__(__name__)
-        self.service = service
-
-        logger.info("Initializing Flask application.")
-        self.api_info_list = list_api_info(service)
-        if len(self.api_info_list) == 0:
-            logger.error("No API found, nothing to serve.")
-            return
-
-        for fn, api_info in self.api_info_list:
-            method = api_info.method
-            path = api_info.path
-            if asyncio.iscoroutinefunction(fn):
-                logger.error(f"Async function \"{fn.__name__}\" is not supported.")
-                continue
-            logger.info(f"Serving {method}-API for {path}")
-
-            wrapped_fn = FlaskMethod(fn, api_info, self)
-            if method == "GET":
-                self.get(path)(wrapped_fn)
-            elif method == "POST":
-                self.post(path)(wrapped_fn)
-            else:
-                raise RuntimeError(f"Unsupported method \"{method}\" for ")
-
-        for fn, api_info in list_api_info(self):
-            method = api_info.method
-            path = api_info.path
-
-            if any(api_info.path == a.path for _, a in self.api_info_list):
-                logger.info(f"Use custom implementation of {path}.")
-                continue
-
-            if asyncio.iscoroutinefunction(fn):
-                logger.error(f"Async function \"{fn.__name__}\" is not supported.")
-                continue
-            logger.info(f"Serving {method}-API for {path}")
-
-            wrapped_fn = FlaskMethod(fn, api_info, self)
-            if method == "GET":
-                self.get(path)(wrapped_fn)
-            elif method == "POST":
-                self.post(path)(wrapped_fn)
-            else:
-                raise RuntimeError(f"Unsupported method \"{method}\" for ")
-
-        logger.info("Flask application initialized.")
-
-    @api.get("/")
-    def index(self, name: str = None):
-        if name is None:
-            all_api = []
-            for _, api_info in self.api_info_list:
-                all_api.append({"path": api_info.path})
-            return all_api
-
-        for fn, api_info in self.api_info_list:
-            if api_info.path == "/" + name:
-                return query_api(fn).model_dump()
-
-        return f"No API named \"{name}\""
-
-    @api.get()
-    def live(self):
-        return "OK"
-
-    def ok(self, body: Union[str, Iterable[str]], mimetype: str):
-        return self.response_class(body, status=200, mimetype=mimetype)
-
-    def error(self, body: str, mimetype="text"):
-        return self.response_class(body, status=500, mimetype=mimetype)
-
-
-class GunicornApplication(BaseApplication):
-
-    def __init__(self, service_type, service_config=None, options=None):
-        self.service_type = service_type
-        self.service_config = service_config
-        self.options = options or {}
-        super().__init__()
-
-    def load_config(self):
-        config = {
-            key: value
-            for key, value in self.options.items()
-            if key in self.cfg.settings and value is not None
-        }
-        for key, value in config.items():
-            self.cfg.set(key.lower(), value)
-
-    def load(self):
-        logger.info("Initializing the service.")
-        if isinstance(self.service_type, type) or callable(self.service_type):
-            service = self.service_type(self.service_config) if self.service_config else self.service_type()
-        elif self.service_config is None:
-            logger.warning(
-                "Be careful! It is not recommended to start the server from a service instance. "
-                "Use service_type and service_config instead."
-            )
-            service = self.service_type
-        else:
-            raise TypeError(f"Invalid service type \"{type(self.service_type)}\".")
-        logger.info("Service initialized.")
-
-        return FlaskServer(service)
-
-
-def run_service(
-        service_type: Union[Type, Callable],
-        service_config=None,
-        host: str = "0.0.0.0",
-        port: int = 8888,
-        num_workers: int = 1,
-        num_threads: int = 20,
-        num_connections: Optional[int] = 1000,
-        backlog: Optional[int] = 1000,
-        worker_class: str = "gthread",
-        timeout: int = 60,
-        keyfile: Optional[str] = None,
-        keyfile_password: Optional[str] = None,
-        certfile: Optional[str] = None
-):
-    logger.info("Starting gunicorn server.")
-    if num_connections is None or num_connections < num_threads * 2:
-        num_connections = num_threads * 2
-    if backlog is None or backlog < num_threads * 2:
-        backlog = num_threads * 2
-
-    def ssl_context(config, default_ssl_context_factory):
-        import ssl
-        context = ssl.create_default_context(ssl.Purpose.CLIENT_AUTH)
-        context.load_cert_chain(
-            certfile=config.certfile,
-            keyfile=config.keyfile,
-            password=keyfile_password
-        )
-        context.minimum_version = ssl.TLSVersion.TLSv1_3
-        return context
-
-    options = {
-        "bind": f"{host}:{port}",
-        "workers": num_workers,
-        "threads": num_threads,
-        "timeout": timeout,
-        "worker_connections": num_connections,
-        "backlog": backlog,
-        "keyfile": keyfile,
-        "certfile": certfile,
-        "worker_class": worker_class,
-        "ssl_context": ssl_context
-    }
-    for name, value in options.items():
-        logger.info(f"Option {name}: {value}")
-    GunicornApplication(service_type, service_config, options).run()