py2http 0.1.67__tar.gz → 0.1.68__tar.gz

{py2http-0.1.67 → py2http-0.1.68}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: py2http
-Version: 0.1.67
+Version: 0.1.68
 Summary: Declarative HTTP service entry point.
 Home-page: https://github.com/i2mint/py2http
 License: MIT

{py2http-0.1.67 → py2http-0.1.68}/py2http/service.py

@@ -56,7 +56,7 @@ from py2http.schema_tools import (
     mk_input_schema_from_func,
     mk_output_schema_from_func,
 )
-from py2http.util import TypeAsserter
+from py2http.util import TypeAsserter, call_with_inputs
 from py2http.constants import JSON_CONTENT_TYPE
 
 # Instance endpoints (``handler['endpoint']`` is an object) are one object every client
@@ -518,7 +518,7 @@ def mk_route(func, **configs):
         try:
             inputs = input_mapper(req)
             input_args, input_kwargs = get_input_args_and_kwargs(inputs)
-            raw_result = func(*input_args, **input_kwargs)
+            raw_result = call_with_inputs(func, input_args, input_kwargs)
             return output_mapper(raw_result, **inputs)
         finally:
             current_request.reset(token)
@@ -536,7 +536,7 @@ def mk_route(func, **configs):
         if isawaitable(inputs):  # Pattern: pass-on async property
             inputs = await inputs
         input_args, input_kwargs = get_input_args_and_kwargs(inputs)
-        raw_result = func(*input_args, **input_kwargs)
+        raw_result = call_with_inputs(func, input_args, input_kwargs)
         if isawaitable(raw_result):  # Pattern: pass-on async property
             raw_result = await raw_result
         final_result = output_mapper(raw_result, **inputs)
@@ -1237,7 +1237,7 @@ def _class_endpoint_dispatcher(cls, handler, name, is_dispatchable):
         if _obj_id is None:
             if _attr_name is not None:
                 raise InputError("_attr_name must be None when _obj_id is None")
-            new_obj = cls(**kwargs)
+            new_obj = call_with_inputs(cls, kwargs=kwargs)
             new_id = str(uuid4())
             store.put(who, new_id, new_obj)
             check_size(who, new_id, new_obj)
@@ -1262,5 +1262,5 @@ def _get_attr_value(obj, attr_name, is_dispatchable, /, **kwargs):
         )
     attr = getattr(obj, attr_name)
     if callable(attr):
-        return attr(**kwargs)
+        return call_with_inputs(attr, kwargs=kwargs)
     return attr

py2http-0.1.68/py2http/tests/test_positional_only.py

@@ -0,0 +1,150 @@
+"""Positional-only parameters (``dict.__getitem__``, ``def f(x, /)``) can be called over
+JSON, which supplies arguments by name (i2mint/py2http#13, #14)."""
+
+import io
+import json
+from wsgiref.util import setup_testing_defaults
+
+import pytest
+from i2.errors import InputError
+
+from py2http import mk_app
+from py2http.util import call_with_inputs
+
+
+def test_call_with_inputs_passes_positional_only_by_name():
+    assert call_with_inputs(lambda x, /, y: (x, y), kwargs={"y": 2, "x": 1}) == (1, 2)
+
+
+def test_call_with_inputs_leaves_ordinary_calls_alone():
+    assert call_with_inputs(lambda x, y=0: (x, y), (1,), {"y": 2}) == (1, 2)
+    assert call_with_inputs(lambda *a, **k: (a, k), (1,), {"z": 2}) == ((1,), {"z": 2})
+
+
+def test_explicit_positional_args_come_first():
+    assert call_with_inputs(lambda x, y, /: (x, y), (1,), {"y": 2}) == (1, 2)
+
+
+def test_optional_positional_only():
+    def f(a, b=5, c=6, /):
+        return a, b, c
+
+    assert call_with_inputs(f, kwargs={"a": 1}) == (1, 5, 6)
+    assert call_with_inputs(f, kwargs={"a": 1, "c": 9}) == (1, 5, 9)
+
+
+def test_missing_required_positional_only_is_an_input_error():
+    with pytest.raises(InputError, match="'y'"):
+        call_with_inputs(lambda x, y, /: None, kwargs={"x": 1})
+
+
+def test_callable_without_a_signature_gets_kwargs_as_before(monkeypatch):
+    import py2http.util
+
+    def no_signature(func):
+        raise ValueError("no signature found")
+
+    monkeypatch.setattr(py2http.util, "signature", no_signature)
+    assert call_with_inputs(lambda **kw: kw, kwargs={"x": 1}) == {"x": 1}
+
+
+def test_container_methods_without_a_readable_signature(monkeypatch):
+    """Python 3.10 can't read ``dict.__getitem__``'s or ``dict.pop``'s signature."""
+    import py2http.util
+
+    def no_signature(func):
+        raise ValueError("no signature found")
+
+    monkeypatch.setattr(py2http.util, "signature", no_signature)
+    d = {"a": 1, "b": 2}
+    assert call_with_inputs(d.__getitem__, kwargs={"key": "a"}) == 1
+    assert call_with_inputs([5, 6].__getitem__, kwargs={"index": 1}) == 6
+    assert call_with_inputs(d.pop, kwargs={"key": "a"}) == 1
+    assert call_with_inputs(d.pop, kwargs={"key": "zz", "default": 0}) == 0
+    assert d == {"b": 2}
+
+
+def _post(app, path, payload):
+    body = json.dumps(payload).encode()
+    environ = {
+        "REQUEST_METHOD": "POST",
+        "PATH_INFO": path,
+        "CONTENT_TYPE": "application/json",
+        "CONTENT_LENGTH": str(len(body)),
+        "wsgi.input": io.BytesIO(body),
+    }
+    setup_testing_defaults(environ)
+    statuses = []
+    out = b"".join(app(environ, lambda status, headers, *a: statuses.append(status)))
+    return statuses[0], json.loads(out)
+
+
+def test_dict_dunders_over_http():
+    store = {"some_key": "some_value"}
+    app = mk_app(
+        [
+            dict(
+                endpoint=store,
+                name="backend_store",
+                attr_names=["__getitem__", "__setitem__"],
+                obj_owner=lambda req: "anyone",
+            )
+        ]
+    )
+    status, value = _post(
+        app, "/backend_store", {"_attr_name": "__getitem__", "key": "some_key"}
+    )
+    assert status.startswith("200") and value == "some_value"
+    payload = {"_attr_name": "__setitem__", "key": "k", "value": 1}
+    assert _post(app, "/backend_store", payload)[0].startswith("200")
+    assert store["k"] == 1
+    status, _ = _post(app, "/backend_store", {"_attr_name": "__getitem__"})
+    assert status.startswith("400")  # missing 'key': a client error
+
+
+def test_plain_function_with_positional_only_over_http():
+    def add(x, y, /):
+        return x + y
+
+    app = mk_app([add])
+    assert _post(app, "/add", {"x": 1, "y": 2}) == ("200 OK", 3)
+
+
+def test_optional_positional_only_stays_a_keyword_when_there_is_var_keyword():
+    # Counter.update(iterable=None, /, **kwds): ``iterable`` is a keyword here
+    from collections import Counter, UserDict
+
+    assert call_with_inputs(lambda a=0, /, **kw: (a, kw), kwargs={"a": 1}) == (
+        0,
+        {"a": 1},
+    )
+    c = Counter()
+    call_with_inputs(c.update, kwargs={"iterable": 3})
+    assert c == Counter(iterable=3)
+    d = UserDict()
+    call_with_inputs(d.update, kwargs={"other": 1})
+    assert dict(d) == {"other": 1}
+
+
+def test_required_positional_only_is_bound_even_with_var_keyword():
+    assert call_with_inputs(lambda a, /, **kw: (a, kw), kwargs={"a": 1, "b": 2}) == (
+        1,
+        {"b": 2},
+    )
+
+
+def test_class_endpoint_with_positional_only_constructor():
+    from py2http.service import _get_func_to_dispatch_handler, shared_objects
+
+    class Box:
+        def __init__(self, content, /):
+            self.content = content
+
+        def get(self):
+            return self.content
+
+    func = _get_func_to_dispatch_handler(
+        dict(endpoint=Box, name="box", attr_names=["get"], obj_owner=shared_objects)
+    )
+    obj_id = func(content=7)
+    assert func(_obj_id=obj_id, _attr_name="get") == 7

{py2http-0.1.67 → py2http-0.1.68}/py2http/util.py

@@ -12,7 +12,8 @@ Overall, this module provides a collection of useful tools for handling lazy pro
 """
 
 from typing import Optional, Callable, Union, Iterable, Any
-from inspect import Parameter, signature
+from collections.abc import MutableMapping, Sequence
+from inspect import Parameter, Signature, signature
 from multiprocessing.context import Process
 from multiprocessing import Queue, active_children
 from time import sleep, time
@@ -22,6 +23,7 @@ from contextlib import contextmanager
 from strand import run_process
 
 from glom import Spec  # NOTE: Third-party
+from i2.errors import InputError
 
 
 class lazyprop:
@@ -488,3 +490,80 @@ def obj_to_path(obj):
         return obj.__globals__[root_name], tuple(attr_path)
     else:
         return obj
+
+
+_MISSING = object()
+_REQUIRED = object()
+
+
+def _positional_only_sig(*names: str, optional: Iterable[str] = ()) -> Signature:
+    return Signature(
+        Parameter(
+            name,
+            Parameter.POSITIONAL_ONLY,
+            default=None if name in optional else Parameter.empty,
+        )
+        for name in names
+    )
+
+
+def _signature_or_none(func: Callable) -> Optional[Signature]:
+    """The signature of ``func``; for the few built-in container methods the Python
+    versions we support (3.10) can't read one, the one they have in later versions."""
+    try:
+        return signature(func)
+    except (ValueError, TypeError):
+        pass
+    owner = getattr(func, "__self__", None)
+    if getattr(func, "__name__", None) == "__getitem__":
+        return _positional_only_sig("index" if isinstance(owner, Sequence) else "key")
+    if getattr(func, "__name__", None) == "pop" and isinstance(owner, MutableMapping):
+        return _positional_only_sig("key", "default", optional=["default"])
+    return None
+
+
+def call_with_inputs(func: Callable, args: Iterable = (), kwargs: dict = None):
+    """Call ``func(*args, **kwargs)``, passing the entries of ``kwargs`` that name
+    positional-only parameters of ``func`` positionally, which JSON (a mapping) can
+    only supply by name (i2mint/py2http#14).
+
+    >>> call_with_inputs({"a": 1}.__getitem__, kwargs={"key": "a"})
+    1
+    >>> d = {}
+    >>> call_with_inputs(d.__setitem__, kwargs={"key": "k", "value": 2}), d
+    (None, {'k': 2})
+    >>> call_with_inputs(lambda x, /, y=0: (x, y), kwargs={"x": 1, "y": 2})
+    (1, 2)
+
+    A positional-only argument that is neither required to be given nor given takes its
+    default; a missing required one is an ``InputError`` (a client error), not a
+    ``TypeError``. A callable whose signature can't be read gets ``**kwargs`` as is.
+
+    Python lets a function with ``**kwargs`` receive a keyword that is also the name of
+    a positional-only parameter (``Counter.update(iterable=3)``): such an optional
+    parameter is left in ``kwargs``; only required ones are bound by name.
+    """
+    args, kwargs = list(args), dict(kwargs or {})
+    sig = _signature_or_none(func)
+    if sig is None:
+        return func(*args, **kwargs)
+    params = list(sig.parameters.values())
+    takes_any_keyword = any(p.kind is Parameter.VAR_KEYWORD for p in params)
+    values = []
+    for param in params[len(args) :]:
+        if param.kind is not Parameter.POSITIONAL_ONLY:
+            break
+        required = param.default is param.empty
+        if param.name in kwargs and (required or not takes_any_keyword):
+            values.append(kwargs.pop(param.name))
+        else:
+            values.append(_REQUIRED if required else _MISSING)
+    while values and values[-1] is _MISSING:  # trailing optionals: leave to the callee
+        values.pop()
+    for i, value in enumerate(values):
+        param = params[len(args) + i]
+        if value is _REQUIRED:
+            raise InputError(f"Missing argument: {param.name!r}")
+        if value is _MISSING:  # an optional one before a given one: its default
+            values[i] = param.default
+    return func(*args, *values, **kwargs)

{py2http-0.1.67 → py2http-0.1.68}/py2http.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: py2http
-Version: 0.1.67
+Version: 0.1.68
 Summary: Declarative HTTP service entry point.
 Home-page: https://github.com/i2mint/py2http
 License: MIT

{py2http-0.1.67 → py2http-0.1.68}/py2http.egg-info/SOURCES.txt

@@ -42,4 +42,5 @@ py2http/tests/test_jwt_middleware.py
 py2http/tests/test_not_set_defaults.py
 py2http/tests/test_obj_ownership.py
 py2http/tests/test_p2h2p.py
+py2http/tests/test_positional_only.py
 py2http/tests/utils_for_testing.py

{py2http-0.1.67 → py2http-0.1.68}/setup.cfg

@@ -1,6 +1,6 @@
 [metadata]
 name = py2http
-version = 0.1.67
+version = 0.1.68
 url = https://github.com/i2mint/py2http
 root_url = https://github.com/i2mint
 platforms = any