py2http 0.1.60__tar.gz → 0.1.61__tar.gz

{py2http-0.1.60 → py2http-0.1.61}/PKG-INFO

@@ -1,15 +1,27 @@
-Metadata-Version: 2.1
+Metadata-Version: 2.4
 Name: py2http
-Version: 0.1.60
+Version: 0.1.61
 Summary: Declarative HTTP service entry point.
 Home-page: https://github.com/i2mint/py2http
-Author: Otosense
 License: MIT
 Keywords: http service,web service
 Platform: any
 Description-Content-Type: text/markdown
-Provides-Extra: testing
 License-File: LICENSE
+Requires-Dist: bottle
+Requires-Dist: PyJWT[crypto]
+Requires-Dist: aiohttp
+Requires-Dist: i2
+Requires-Dist: glom
+Requires-Dist: gunicorn
+Requires-Dist: requests
+Requires-Dist: strand
+Requires-Dist: swagger-ui-py
+Requires-Dist: pycparser
+Requires-Dist: http2py
+Provides-Extra: testing
+Requires-Dist: http2py; extra == "testing"
+Dynamic: license-file
 
 [Documentation here](https://i2mint.github.io/py2http/)
 

{py2http-0.1.60 → py2http-0.1.61}/py2http/__init__.py

@@ -1,9 +1,9 @@
-"""This module provides functionality to easily create HTTP services from Python 
-functions and class methods. It includes features such as method transformation, 
-input mapping, output mapping, error handling, and client generation. 
-The module also allows for customization through various configuration options 
-and provides the ability to generate OpenAPI specifications for the created HTTP 
-services. Additionally, it includes middleware, plugins, and decorators to enhance 
+"""This module provides functionality to easily create HTTP services from Python
+functions and class methods. It includes features such as method transformation,
+input mapping, output mapping, error handling, and client generation.
+The module also allows for customization through various configuration options
+and provides the ability to generate OpenAPI specifications for the created HTTP
+services. Additionally, it includes middleware, plugins, and decorators to enhance
 the functionality of the HTTP services."""
 
 from .middleware import mk_jwt_middleware, mk_superadmin_middleware

{py2http-0.1.60 → py2http-0.1.61}/py2http/bottle_plugins.py

@@ -1,5 +1,4 @@
-"""Plugins for adding middleware functionality to Bottle apps.
-"""
+"""Plugins for adding middleware functionality to Bottle apps."""
 
 from bottle import request, response, abort
 from functools import wraps
@@ -9,7 +8,7 @@ from typing import Iterable
 from warnings import warn
 from py2http.constants import JSON_CONTENT_TYPE
 
-OPTIONS = 'OPTIONS'
+OPTIONS = "OPTIONS"
 
 
 class JWTPlugin:
@@ -21,7 +20,7 @@ class JWTPlugin:
 
     def __init__(
         self,
-        secret: str = '',
+        secret: str = "",
         verify: bool = True,
         mapper: dict = None,
         ignore_methods: Iterable[str] = None,
@@ -39,7 +38,7 @@ class JWTPlugin:
         self._verify = verify
         self._mapper = mapper if mapper else {}
         self._ignore_methods = ignore_methods if ignore_methods else []
-        self._algorithms = algorithms if algorithms else ['HS256']
+        self._algorithms = algorithms if algorithms else ["HS256"]
 
     def __call__(self, handler):
         if self._ignore_methods and handler.method_name in self._ignore_methods:
@@ -49,13 +48,13 @@ class JWTPlugin:
         def wrapped_handler(*args, **kwargs):
             if request.method == OPTIONS:
                 return handler(*args, *kwargs)
-            auth_header = request.headers.get('Authorization', '')
+            auth_header = request.headers.get("Authorization", "")
             token = auth_header[7:]
             try:
                 decoded = jwt.decode(
                     token,
                     self._secret,
-                    options={'verify_signature': self._verify},
+                    options={"verify_signature": self._verify},
                     algorithms=self._algorithms,
                 )
                 for k, v in self._mapper.items():
@@ -69,10 +68,10 @@ class JWTPlugin:
                     response.content_type = JSON_CONTENT_TYPE
                     return json.dumps(
                         {
-                            'error': f'Invalid authentication token "{token}", {str(error)}'
+                            "error": f'Invalid authentication token "{token}", {str(error)}'
                         }
                     )
-                warn(f'Invalid JWT: {token}')
+                warn(f"Invalid JWT: {token}")
                 return handler(*args, **kwargs)
 
         return wrapped_handler
@@ -84,12 +83,12 @@ class ApiKeyAuthPlugin:
 
     def __call__(self, handler):
         def wrapped_handler(*args, **kwargs):
-            auth_header = request.headers.get('Authorization', '')
+            auth_header = request.headers.get("Authorization", "")
             if auth_header == self._api_key:
                 return handler(*args, **kwargs)
             response.status = 401
             response.content_type = JSON_CONTENT_TYPE
-            return json.dumps({'error': 'invalid API key'})
+            return json.dumps({"error": "invalid API key"})
 
         return wrapped_handler
 
@@ -97,18 +96,18 @@ class ApiKeyAuthPlugin:
 # from https://stackoverflow.com/questions/17262170/bottle-py-enabling-cors-for-jquery-ajax-requests
 # TODO: accept lists of headers and methods as init args
 class CorsPlugin:
-    def __init__(self, origins: str = '*'):
+    def __init__(self, origins: str = "*"):
         self._origins = origins
 
     def __call__(self, handler):
         def wrapped_handler(*args, **kwargs):
-            response.headers['Access-Control-Allow-Origin'] = self._origins
-            response.headers[
-                'Access-Control-Allow-Methods'
-            ] = 'GET, POST, PUT, DELETE, OPTIONS'
-            response.headers[
-                'Access-Control-Allow-Headers'
-            ] = 'Origin, Accept, Content-Type, X-Requested-With, Authorization, X-api-key'
+            response.headers["Access-Control-Allow-Origin"] = self._origins
+            response.headers["Access-Control-Allow-Methods"] = (
+                "GET, POST, PUT, DELETE, OPTIONS"
+            )
+            response.headers["Access-Control-Allow-Headers"] = (
+                "Origin, Accept, Content-Type, X-Requested-With, Authorization, X-api-key"
+            )
             if request.method != OPTIONS:
                 return handler(*args, **kwargs)
 

{py2http-0.1.60 → py2http-0.1.61}/py2http/config.py

@@ -1,22 +1,23 @@
-"""The code module provides functions for retrieving configuration values for a 
-function based on a hierarchy of sources, including function properties, 
-configuration dictionaries, and default values. The `get_result` function is used to 
-allow nested configurations by function name, with an example provided in the docstring 
-for illustration. 
+"""The code module provides functions for retrieving configuration values for a
+function based on a hierarchy of sources, including function properties,
+configuration dictionaries, and default values. The `get_result` function is used to
+allow nested configurations by function name, with an example provided in the docstring
+for illustration.
 
-The `mk_config` function is used to get a configuration value for a function by checking 
-the function properties, configuration dictionaries, and default values. It also allows 
-for specifying the expected type of the output, with options to provide additional 
-options such as the function name and expected type. 
+The `mk_config` function is used to get a configuration value for a function by checking
+the function properties, configuration dictionaries, and default values. It also allows
+for specifying the expected type of the output, with options to provide additional
+options such as the function name and expected type.
 
-Overall, the module helps manage and retrieve configuration values for functions, 
+Overall, the module helps manage and retrieve configuration values for functions,
 ensuring they are appropriately set and validated based on the function's requirements.
 """
+
 from typing import Callable
 
-AIOHTTP = 'aiohttp'
-BOTTLE = 'bottle'
-FLASK = 'flask'
+AIOHTTP = "aiohttp"
+BOTTLE = "bottle"
+FLASK = "flask"
 
 
 def get_result(configs, func, funcname, key, options):
@@ -41,9 +42,9 @@ def get_result(configs, func, funcname, key, options):
         dict_value = result.get(funcname, None)
         if dict_value:
             result = dict_value
-        elif '$else' in result:
-            result = result['$else']
-        elif options.get('type', None) is not dict:
+        elif "$else" in result:
+            result = result["$else"]
+        elif options.get("type", None) is not dict:
             result = None
     return result
 
@@ -66,12 +67,12 @@ def mk_config(key, func, configs, defaults, **options):
         * *type*
           The expected type of the output (use Callable for functions)
     """
-    funcname = options.get('funcname', getattr(func, '__name__', None))
+    funcname = options.get("funcname", getattr(func, "__name__", None))
 
     result = get_result(configs, func, funcname, key, options)
 
     if result:
-        expected_type = options.get('type', None)  # align names expected_type <-> type
+        expected_type = options.get("type", None)  # align names expected_type <-> type
         if not expected_type:
             assert key in defaults, f'Missing default value for key "{key}"'
             default_value = defaults.get(key)
@@ -81,7 +82,7 @@ def mk_config(key, func, configs, defaults, **options):
                 expected_type = type(default_value)
         assert expected_type == type(None) or isinstance(
             result, expected_type
-        ), f'Config {key} does not match type {expected_type}.'
+        ), f"Config {key} does not match type {expected_type}."
     else:
         result = defaults.get(key, None)
     return result

{py2http-0.1.60 → py2http-0.1.61}/py2http/constants.py

@@ -1,6 +1,7 @@
 """This module provides functionality for dispatching Python functions as HTTP services. It allows users to create a basic HTTP server from a list of functions or instance methods, customize input and output mapping, handle errors, generate client code from an OpenAPI specification, and configure various aspects of the server setup. The module includes features for transforming class methods, mapping input and output data, handling errors, and generating client code. It also supports configuration options for the HTTP framework, input and output mappers, error handlers, openAPI specifications, logging, middleware, plugins, CORS, SSL certificates, and more."""
-JSON_CONTENT_TYPE = 'application/json'
-BINARY_CONTENT_TYPE = 'application/octet-stream'
-FORM_CONTENT_TYPE = 'multipart/form-data'
-RAW_CONTENT_TYPE = 'text/plain'
-HTML_CONTENT_TYPE = 'text/html'
+
+JSON_CONTENT_TYPE = "application/json"
+BINARY_CONTENT_TYPE = "application/octet-stream"
+FORM_CONTENT_TYPE = "multipart/form-data"
+RAW_CONTENT_TYPE = "text/plain"
+HTML_CONTENT_TYPE = "text/html"

{py2http-0.1.60 → py2http-0.1.61}/py2http/decorators.py

@@ -30,7 +30,11 @@ from i2.signatures import (
 )
 from i2.errors import ModuleNotFoundIgnore
 
-from py2http.schema_tools import mk_input_schema_from_func, validate_input
+from py2http.schema_tools import (
+    mk_input_schema_from_func,
+    param_default,
+    validate_input,
+)
 from py2http.config import AIOHTTP, BOTTLE
 from py2http.constants import (
     JSON_CONTENT_TYPE,
@@ -246,7 +250,7 @@ class DecoParam:
 from typing import Optional
 import re
 
-token_p = re.compile(r'\w+')
+token_p = re.compile(r"\w+")
 
 
 # TODO: Research how to keep the params in the order they were declared.
@@ -338,7 +342,7 @@ class ParamsSpecifier:
     def __init__(
         self,
         _annotations: Optional[dict] = None,
-        _names: str = '',
+        _names: str = "",
         _dflt_default=None,
         _kind=Parameter.KEYWORD_ONLY,
         **name_and_dflts,
@@ -352,35 +356,35 @@ class ParamsSpecifier:
         self._dflt_default = _dflt_default
         self._kind = _kind
 
-        if hasattr(self, '__annotations__'):
+        if hasattr(self, "__annotations__"):
             self.__annotations__.update(_annotations)
         else:
             self.__annotations__ = _annotations
 
         reserved = {
-            '_annotations',
-            '_names',
-            '_dflt_default',
-            'from_func',
-            '_extract_params',
-            '_to_signature',
-            '_kind',
-            'to_parameter_obj_list',
+            "_annotations",
+            "_names",
+            "_dflt_default",
+            "from_func",
+            "_extract_params",
+            "_to_signature",
+            "_kind",
+            "to_parameter_obj_list",
         }
         _name_and_dflts = {
             k: v
             for k, v in self.__class__.__dict__.items()
-            if not k.startswith('__') and k not in reserved
+            if not k.startswith("__") and k not in reserved
         }
         _name_and_dflts.update(name_and_dflts or {})
         self._name_and_dflts = _name_and_dflts
 
-        annots = set(getattr(self, '__annotations__', {}))
-        annots |= set(getattr(self.__class__, '__annotations__', {}))
+        annots = set(getattr(self, "__annotations__", {}))
+        annots |= set(getattr(self.__class__, "__annotations__", {}))
 
         _reserved = reserved.intersection(set(_name_and_dflts) | set(annots))
         if _reserved:
-            raise ValueError(f'Sorry, {_reserved} are reserved names')
+            raise ValueError(f"Sorry, {_reserved} are reserved names")
 
     @classmethod
     def from_func(cls, func, _dflt_default=None):
@@ -388,23 +392,21 @@ class ParamsSpecifier:
         _annotations = {
             x.name: x.annotation for x in params if x.annotation is not Parameter.empty
         }
-        _name_and_dflts = dict()
-        for x in params:
-            dflt = x.default
-            if dflt is Parameter.empty:
-                dflt = _dflt_default
-            _name_and_dflts.update({x.name: dflt})
-        _name_and_dflts = {
-            x.name: x.default if x.default is not Parameter.empty else _dflt_default
-            for x in params
-        }
+
+        def dflt_of(param):
+            dflt = param_default(param)  # i2's NotSet sentinel counts as "no default"
+            return _dflt_default if dflt is Parameter.empty else dflt
+
+        _name_and_dflts = {x.name: dflt_of(x) for x in params}
         return cls(
-            _annotations=_annotations, _dflt_default=_dflt_default, **_name_and_dflts,
+            _annotations=_annotations,
+            _dflt_default=_dflt_default,
+            **_name_and_dflts,
         )
 
     def _extract_params(self):
         _name_and_dflts = self._name_and_dflts
-        annots = getattr(self, '__annotations__', {})
+        annots = getattr(self, "__annotations__", {})
         for name in set(annots) - set(_name_and_dflts):  # annots_not_in_attrs
             yield dict(
                 name=name,
@@ -428,7 +430,7 @@ class ParamsSpecifier:
         return list(self._extract_params())
 
     def __repr__(self):
-        return f'{self()}'
+        return f"{self()}"
 
 
 class Decora(Decorator):
@@ -539,7 +541,7 @@ class Decora(Decorator):
     def __init_subclass__(cls, **kwargs):
         super().__init_subclass__(**kwargs)
         if (
-            '__new__' not in cls.__dict__
+            "__new__" not in cls.__dict__
         ):  # if __new__ hasn't been defined in the subclass...
             params = []
             # cls_annots = getattr(cls, '__annotations__', {})
@@ -554,8 +556,8 @@ class Decora(Decorator):
             for p in params:
                 setattr(cls, p.name, p.default)
             params = [
-                Parameter('self', PK),
-                Parameter('func', PK, default=None),
+                Parameter("self", PK),
+                Parameter("func", PK, default=None),
             ] + params
             cls._injected_deco_params = [p.name for p in params]
 
@@ -564,8 +566,8 @@ class Decora(Decorator):
                     cls._injected_deco_params
                 ):
                     raise TypeError(
-                        'TypeError: __new__() got unexpected keyword arguments: '
-                        f'{kwargs.keys() - cls._injected_deco_params}'
+                        "TypeError: __new__() got unexpected keyword arguments: "
+                        f"{kwargs.keys() - cls._injected_deco_params}"
                     )
                 if func is None:
                     return partial(cls, **kwargs)
@@ -624,7 +626,8 @@ def replace_with_params(target=None, /, *, source=None, inplace=False):
                         target
                     )  # make a copy of the function so we don't
                 target.__signature__ = Signature(
-                    new_params, return_annotation=signature(target).return_annotation,
+                    new_params,
+                    return_annotation=signature(target).return_annotation,
                 )
                 return target
             else:
@@ -694,7 +697,7 @@ def methodizer(func=None, *, instance_params=()):
             kwargs.update(kwargs_from_self)
             return func(**kwargs)
 
-        set_signature_of_func(method, ['self'] + list(method_argnames))
+        set_signature_of_func(method, ["self"] + list(method_argnames))
 
         method.__name__ = func.__name__
 
@@ -706,14 +709,14 @@ from warnings import warn
 
 def _handle_exisisting_method_name(cls, method, if_method_exists):
     if hasattr(cls, method.__name__):
-        msg = f'{cls} already has a method named {method.__name__}'
-        if if_method_exists == 'raise':
+        msg = f"{cls} already has a method named {method.__name__}"
+        if if_method_exists == "raise":
             raise ValueError(msg)
-        elif if_method_exists == 'warn':
-            warn(msg + ' ... Will overwrite anyway.')
-        elif if_method_exists != 'ignore':
+        elif if_method_exists == "warn":
+            warn(msg + " ... Will overwrite anyway.")
+        elif if_method_exists != "ignore":
             raise ValueError(
-                f'if_method_exists value not recognized: {if_method_exists}'
+                f"if_method_exists value not recognized: {if_method_exists}"
             )
 
 
@@ -721,7 +724,7 @@ def _handle_exisisting_method_name(cls, method, if_method_exists):
 #   - signatures have different orders every time (need to use ordered containers)
 #   - Values not computed correctly
 def inject_methodized_funcs(
-    cls=None, *, funcs=(), instance_params=None, if_method_exists='raise'
+    cls=None, *, funcs=(), instance_params=None, if_method_exists="raise"
 ):
     """
 
@@ -762,7 +765,7 @@ def inject_methodized_funcs(
     # C.g(y, x)
     # C.h(kwargs, c, x)
     """
-    raise NotImplementedError('Not working yet: Come back to it!')
+    raise NotImplementedError("Not working yet: Come back to it!")
     if cls is None:
         return partial(
             inject_methodized_funcs,
@@ -787,7 +790,7 @@ def flatten_callables(*callables, func_name=None):
     """
     Flatten a pipeline of calls into one function.
     """
-    raise NotImplementedError('Meant to be a generalization of mk_flat')
+    raise NotImplementedError("Meant to be a generalization of mk_flat")
     for call in callables:
         pass
 
@@ -813,7 +816,7 @@ def _instantiate(cls, *, cache_id, **kwargs):
 
 # TODO: signature of flat function doesn't reflect actual call restrictions
 # TODO: Change default func_name to be dynamically, taking method as default
-def mk_flat(cls, method, *, func_name: str = 'flat_func', cls_cache_key: str = None):
+def mk_flat(cls, method, *, func_name: str = "flat_func", cls_cache_key: str = None):
     """
     Flatten a simple cls->instance->method call pipeline into one function.
 
@@ -889,7 +892,7 @@ def mk_flat(cls, method, *, func_name: str = 'flat_func', cls_cache_key: str = N
     if cls_cache_key:
         param = dict(name=cls_cache_key, kind=KO, default=None)
         sig_flat = sig_flat.add_params([param])
-    sig_flat = sig_flat.remove_names(['self'])
+    sig_flat = sig_flat.remove_names(["self"])
     sig_flat = sig_flat.replace(return_annotation=sig_method.return_annotation)
 
     def flat_func(**kwargs):
@@ -950,7 +953,7 @@ def flatten_methods(methods: dict, decorator=None, validate_name_unicity=True):
     if validate_name_unicity:
         nb_function_names = len({x.__name__: x for x in functions})
         if nb_function_names != len(functions):
-            raise ValueError(f'Some function names are duplicated in {methods}')
+            raise ValueError(f"Some function names are duplicated in {methods}")
     return functions
 
 
@@ -987,10 +990,10 @@ def add_attrs(**attrs):
     return add_attrs_to_func
 
 
-http_get = add_attrs(http_method='get')
-http_post = add_attrs(http_method='post')
-http_put = add_attrs(http_method='put')
-http_delete = add_attrs(http_method='delete')
+http_get = add_attrs(http_method="get")
+http_post = add_attrs(http_method="post")
+http_put = add_attrs(http_method="put")
+http_delete = add_attrs(http_method="delete")
 
 
 def route(route_name):
@@ -998,7 +1001,7 @@ def route(route_name):
 
 
 def _validate_and_invoke_mapper(func, inputs):
-    request_schema = getattr(func, 'request_schema', None)
+    request_schema = getattr(func, "request_schema", None)
     if request_schema:
         validate_input(inputs, request_schema)
     return func(**inputs)
@@ -1012,10 +1015,8 @@ def _handle_req(func, content_type):
     @wraps(func)
     def input_mapper(req):
         if content_type not in req.content_type:
-            raise RuntimeError(
-                f"The incoming request's content is of type \
-{req.content_type}, when {content_type} is expected."
-            )
+            raise RuntimeError(f"The incoming request's content is of type \
+{req.content_type}, when {content_type} is expected.")
         inputs = _get_inputs_from_request(req, content_type)
         return _validate_and_invoke_mapper(func, inputs)
 
@@ -1082,7 +1083,8 @@ class ProposalJsonRespEncoder(JSONEncoder):
     # Note: Subclass and replace _pre_process_obj to get different preprocessing
     # Note: To get control from init, definte init to set _pre_process_obj
     _pre_process_obj = partial(
-        _json_reponse_preproc, serializer_for_type=_mk_default_serializer_for_type(),
+        _json_reponse_preproc,
+        serializer_for_type=_mk_default_serializer_for_type(),
     )
 
     def default(self, o):
@@ -1091,7 +1093,7 @@ class ProposalJsonRespEncoder(JSONEncoder):
 
 
 def send_json_resp(func):
-    framework = os.getenv('PY2HTTP_FRAMEWORK', BOTTLE)
+    framework = os.getenv("PY2HTTP_FRAMEWORK", BOTTLE)
     if framework == AIOHTTP:
 
         async def output_mapper(output, **input_kwargs):
@@ -1118,7 +1120,7 @@ def send_binary_resp(func):
         return pickle.dumps(mapped_output)
 
     output_mapper.content_type = BINARY_CONTENT_TYPE
-    output_mapper.response_schema = {'type': 'binary'}
+    output_mapper.response_schema = {"type": "binary"}
     return output_mapper
 
 
@@ -1169,25 +1171,25 @@ def mk_input_mapper(input_map):
 
 
 def _get_inputs_from_request(request, content_type):
-    defaults = getattr(request, 'defaults', {})
-    if request.method == 'POST':
+    defaults = getattr(request, "defaults", {})
+    if request.method == "POST":
         if content_type == JSON_CONTENT_TYPE:
             inputs = request.json
         elif content_type == RAW_CONTENT_TYPE:
-            data = request.body.read().decode('utf-8')
+            data = request.body.read().decode("utf-8")
             inputs = json.loads(data)
         elif content_type == BINARY_CONTENT_TYPE:
             data = request.body.read()
             inputs = pickle.loads(data)
         elif content_type == FORM_CONTENT_TYPE:
             fields = json.loads(
-                request.files.pop('__fields').file.read().decode('utf-8')
+                request.files.pop("__fields").file.read().decode("utf-8")
             )
             binaries = {k: v.file.read() for k, v in request.files.items()}
             inputs = dict(fields, **binaries)
         return dict(defaults, **inputs)
     else:
-        raise NotImplementedError('Only POST is supported for now')
+        raise NotImplementedError("Only POST is supported for now")
 
 
 def mk_handlers(methods: Iterable, *, decorator=None, cls_cache_key=None):
@@ -1200,7 +1202,7 @@ def mk_handlers(methods: Iterable, *, decorator=None, cls_cache_key=None):
         if inspect.isfunction(meth):
             cls = getattr(
                 inspect.getmodule(meth),
-                meth.__qualname__.split('.<locals>', 1)[0].rsplit('.', 1)[0],
+                meth.__qualname__.split(".<locals>", 1)[0].rsplit(".", 1)[0],
                 None,
             )
             if isinstance(cls, type):
@@ -1215,7 +1217,7 @@ def mk_handlers(methods: Iterable, *, decorator=None, cls_cache_key=None):
     handlers = []
     for item in methods:
         has_mappers = isinstance(item, dict)
-        method = item['endpoint'] if has_mappers else item
+        method = item["endpoint"] if has_mappers else item
         cls = get_class_that_defined_method(method)
         endpoint = decorator(
             mk_flat(cls, method, func_name=method.__name__, cls_cache_key=cls_cache_key)