wred-pydantic 0.1.0__tar.gz

wred_pydantic-0.1.0/.gitignore

@@ -0,0 +1,9 @@
+__pycache__/
+*.pyc
+.venv/
+.pytest_cache/
+.ruff_cache/
+dist/
+*.egg-info/
+.coverage
+.tox/

wred_pydantic-0.1.0/LICENSE

@@ -0,0 +1,29 @@
+BSD 3-Clause License
+
+Copyright (c) 2026, Harrison Erd
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+1. Redistributions of source code must retain the above copyright notice, this
+   list of conditions and the following disclaimer.
+
+2. Redistributions in binary form must reproduce the above copyright notice,
+   this list of conditions and the following disclaimer in the documentation
+   and/or other materials provided with the distribution.
+
+3. Neither the name of the copyright holder nor the names of its contributors
+   may be used to endorse or promote products derived from this software
+   without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
+FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
+OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

wred_pydantic-0.1.0/PKG-INFO

@@ -0,0 +1,94 @@
+Metadata-Version: 2.4
+Name: wred-pydantic
+Version: 0.1.0
+Summary: Optional pydantic integration for Wred
+Requires-Python: >=3.11
+Description-Content-Type: text/markdown
+License-Expression: BSD-3-Clause
+License-File: LICENSE
+Requires-Dist: wred>=0.13,<0.15
+Requires-Dist: pydantic>=2.8,<3
+Requires-Dist: pytest>=8 ; extra == "test"
+Requires-Dist: pytest-asyncio>=0.24 ; extra == "test"
+Requires-Dist: httpx>=0.27 ; extra == "test"
+Provides-Extra: test
+
+# wred-pydantic
+
+Explicit Pydantic v2 input validation and response conversion for Wred 0.13–0.14.
+Python 3.11+. No dependency injection or annotation inference.
+
+```sh
+pip install .
+```
+
+```python
+from pydantic import BaseModel, Field
+from wred import App
+from wred_pydantic import body, query, path, response
+
+
+class Product(BaseModel):
+    name: str = Field(min_length=1)
+
+
+app = App()
+
+
+@app.route("/products", methods=["POST"])
+@body(Product)
+@response(Product, status=201)
+async def create(request, body):
+    return body, [("content-type", "application/json")], 201
+```
+
+- `body(Model, argument='body', max_bytes=1048576)` validates raw JSON bytes and
+  injects a keyword argument. Bodies over the limit return 413. Set `max_bytes=None`
+  to disable the limit, or supply a nonnegative byte count.
+- `query(Model, argument='query')` validates Wred's query mapping. Duplicate query keys
+  retain the last value; array query syntax is not inferred.
+- `path(Model, argument='path')` validates route kwargs and injects a model while
+  forwarding the original route kwargs. Handlers must accept both.
+- `response(Model, status=200, by_alias=True)` validates and serializes successful
+  handler returns. Serialization aliases are used in both JSON and schema; set
+  `by_alias=False` to use field names in both.
+  `Model` may also be a supported type such as `list[Product]`. `status` describes
+  OpenAPI metadata; the decorator does not change the returned HTTP status.
+
+Invalid input returns 422 with `detail` and `errors` containing locations and types,
+without raw inputs or custom validator messages. Model settings control coercion,
+strictness, aliases, and extra fields. Invalid server responses raise Pydantic's
+`ValidationError`; they are not converted to client errors. Tuples retain headers
+and status. Non-2xx responses, 204/205 responses, and callable ASGI responses pass
+through without validation. Successful payloads are validated regardless of the
+metadata `status` value.
+
+Use `@app.route` outermost, then input decorators, then response conversion.
+Place exception mapping outside response conversion to handle response validation
+failures. Injected argument names cannot collide with
+route parameters. Schema metadata is consumed by `wred-openapi` without a dependency
+on that package. Do not register duplicate metadata for the same input source.
+
+Run `pip install -e '.[test]'` and `pytest` inside this repository.
+
+The body limit counts actual streamed bytes, including requests without a
+Content-Length header, and stops reading when exceeded. Cached bodies are also
+checked, but middleware that reads the body first has already allocated that
+memory. Configure body limits and read timeouts at the server or reverse proxy
+as well. The decorator cannot prevent the ASGI server from buffering a large
+individual chunk before delivering it.
+
+Constrain collection lengths, string lengths, and nesting in your models, and
+paginate large responses. Validation and serialization run synchronously in the
+async worker; expensive custom validators and large payloads delay other requests
+on that worker. The body limit is not a CPU or response-size limit. Model instances
+follow Pydantic's revalidation policy; use `revalidate_instances='always'` if your
+application returns models that may have been mutated after construction.
+
+Run `tox` for the Python 3.12 compatibility matrix (Wred 0.13/0.14 and Pydantic
+2.8.0/latest 2.x). Run `python benchmarks/validation.py` after installing this
+package to compare plain Wred with request and response validation for 1, 100,
+and 10,000 items. It reports in-process ASGI latency, excluding networking and
+application I/O. Measure throughput, memory, and tail latency under your expected
+concurrency before sizing a production deployment.
+

wred_pydantic-0.1.0/README.md

@@ -0,0 +1,78 @@
+# wred-pydantic
+
+Explicit Pydantic v2 input validation and response conversion for Wred 0.13–0.14.
+Python 3.11+. No dependency injection or annotation inference.
+
+```sh
+pip install .
+```
+
+```python
+from pydantic import BaseModel, Field
+from wred import App
+from wred_pydantic import body, query, path, response
+
+
+class Product(BaseModel):
+    name: str = Field(min_length=1)
+
+
+app = App()
+
+
+@app.route("/products", methods=["POST"])
+@body(Product)
+@response(Product, status=201)
+async def create(request, body):
+    return body, [("content-type", "application/json")], 201
+```
+
+- `body(Model, argument='body', max_bytes=1048576)` validates raw JSON bytes and
+  injects a keyword argument. Bodies over the limit return 413. Set `max_bytes=None`
+  to disable the limit, or supply a nonnegative byte count.
+- `query(Model, argument='query')` validates Wred's query mapping. Duplicate query keys
+  retain the last value; array query syntax is not inferred.
+- `path(Model, argument='path')` validates route kwargs and injects a model while
+  forwarding the original route kwargs. Handlers must accept both.
+- `response(Model, status=200, by_alias=True)` validates and serializes successful
+  handler returns. Serialization aliases are used in both JSON and schema; set
+  `by_alias=False` to use field names in both.
+  `Model` may also be a supported type such as `list[Product]`. `status` describes
+  OpenAPI metadata; the decorator does not change the returned HTTP status.
+
+Invalid input returns 422 with `detail` and `errors` containing locations and types,
+without raw inputs or custom validator messages. Model settings control coercion,
+strictness, aliases, and extra fields. Invalid server responses raise Pydantic's
+`ValidationError`; they are not converted to client errors. Tuples retain headers
+and status. Non-2xx responses, 204/205 responses, and callable ASGI responses pass
+through without validation. Successful payloads are validated regardless of the
+metadata `status` value.
+
+Use `@app.route` outermost, then input decorators, then response conversion.
+Place exception mapping outside response conversion to handle response validation
+failures. Injected argument names cannot collide with
+route parameters. Schema metadata is consumed by `wred-openapi` without a dependency
+on that package. Do not register duplicate metadata for the same input source.
+
+Run `pip install -e '.[test]'` and `pytest` inside this repository.
+
+The body limit counts actual streamed bytes, including requests without a
+Content-Length header, and stops reading when exceeded. Cached bodies are also
+checked, but middleware that reads the body first has already allocated that
+memory. Configure body limits and read timeouts at the server or reverse proxy
+as well. The decorator cannot prevent the ASGI server from buffering a large
+individual chunk before delivering it.
+
+Constrain collection lengths, string lengths, and nesting in your models, and
+paginate large responses. Validation and serialization run synchronously in the
+async worker; expensive custom validators and large payloads delay other requests
+on that worker. The body limit is not a CPU or response-size limit. Model instances
+follow Pydantic's revalidation policy; use `revalidate_instances='always'` if your
+application returns models that may have been mutated after construction.
+
+Run `tox` for the Python 3.12 compatibility matrix (Wred 0.13/0.14 and Pydantic
+2.8.0/latest 2.x). Run `python benchmarks/validation.py` after installing this
+package to compare plain Wred with request and response validation for 1, 100,
+and 10,000 items. It reports in-process ASGI latency, excluding networking and
+application I/O. Measure throughput, memory, and tail latency under your expected
+concurrency before sizing a production deployment.

wred_pydantic-0.1.0/benchmarks/validation.py

@@ -0,0 +1,80 @@
+"""In-process ASGI cost comparison; no network or production throughput claims.
+
+Run: python benchmarks/validation.py
+"""
+
+import asyncio
+import json
+import statistics
+import time
+
+import pydantic
+import wred
+from pydantic import BaseModel
+
+from wred_pydantic import body, response
+
+
+class Item(BaseModel):
+    id: int
+    name: str
+    price: float
+
+
+def application(validated):
+    app = wred.App()
+    if validated:
+
+        @body(list[Item])
+        @response(list[Item])
+        async def handler(request, body):
+            return body
+    else:
+
+        async def handler(request):
+            return await request.json()
+
+    app.route("/", methods=["POST"])(handler)
+    return app
+
+
+async def measure(app, payload, iterations):
+    scope = {"type": "http", "method": "POST", "path": "/"}
+
+    async def receive():
+        return {"type": "http.request", "body": payload, "more_body": False}
+
+    async def send(message):
+        if message["type"] == "http.response.start":
+            assert message["status"] == 200
+
+    for _ in range(20):
+        await app(scope, receive, send)
+    samples = []
+    for _ in range(iterations):
+        start = time.perf_counter_ns()
+        await app(scope, receive, send)
+        samples.append((time.perf_counter_ns() - start) / 1000)
+    return statistics.median(samples), sorted(samples)[int(len(samples) * 0.95)]
+
+
+async def main():
+    print(f"Wred {wred.__version__}; Pydantic {pydantic.__version__}")
+    print("items bytes mode median_us p95_us")
+    for count, iterations in [(1, 5000), (100, 1000), (10000, 100)]:
+        payload = json.dumps(
+            [{"id": i, "name": "example product", "price": 12.50} for i in range(count)]
+        ).encode()
+        for validated in (False, True):
+            median, p95 = await measure(application(validated), payload, iterations)
+            print(
+                count,
+                len(payload),
+                "validated" if validated else "plain",
+                f"{median:.1f}",
+                f"{p95:.1f}",
+            )
+
+
+if __name__ == "__main__":
+    asyncio.run(main())

wred_pydantic-0.1.0/pyproject.toml

@@ -0,0 +1,20 @@
+[build-system]
+requires = ["flit_core>=3.12,<4"]
+build-backend = "flit_core.buildapi"
+
+[project]
+name = "wred-pydantic"
+version = "0.1.0"
+description = "Optional pydantic integration for Wred"
+readme = "README.md"
+requires-python = ">=3.11"
+license = "BSD-3-Clause"
+license-files = ["LICENSE"]
+dependencies = ["wred>=0.13,<0.15", "pydantic>=2.8,<3"]
+
+[project.optional-dependencies]
+test = ["pytest>=8", "pytest-asyncio>=0.24", "httpx>=0.27"]
+
+[tool.pytest.ini_options]
+asyncio_mode = "auto"
+asyncio_default_fixture_loop_scope = "function"

wred_pydantic-0.1.0/tests/test_validation.py

@@ -0,0 +1,211 @@
+import asyncio
+from datetime import UTC, datetime
+
+import httpx
+import pytest
+from pydantic import BaseModel, ConfigDict, Field, ValidationError
+from wred import App
+
+from wred_pydantic import body, path, query, response
+
+
+class Input(BaseModel):
+    name: str = Field(min_length=1, alias="label")
+
+
+class Query(BaseModel):
+    count: int = Field(ge=1)
+
+
+class Path(BaseModel):
+    model_config = ConfigDict(extra="forbid")
+    item_id: int
+
+
+class Output(BaseModel):
+    at: datetime
+    names: list[str]
+
+
+async def test_nested_composition_and_errors():
+    app = App()
+
+    @app.route("/items/{item_id}", methods=["POST"])
+    @body(Input)
+    @query(Query)
+    @path(Path)
+    @response(Output, status=201)
+    async def handler(request, item_id, body, query, path):
+        assert path.item_id == int(item_id)
+        return (
+            {
+                "at": datetime(2026, 1, 1, tzinfo=UTC),
+                "names": [body.name] * query.count,
+            },
+            [("content-type", "application/json"), ("x-test", "ok")],
+            201,
+        )
+
+    async with httpx.AsyncClient(
+        transport=httpx.ASGITransport(app), base_url="http://test"
+    ) as client:
+        result = await client.post("/items/3?count=2", json={"label": "hello"})
+        assert result.status_code == 201 and result.headers["x-test"] == "ok"
+        assert result.json() == {
+            "at": "2026-01-01T00:00:00Z",
+            "names": ["hello", "hello"],
+        }
+        for url, data in [
+            ("/items/3?count=0", {"label": "secret"}),
+            ("/items/no?count=1", {"label": "secret"}),
+            ("/items/3?count=1", {"label": ""}),
+        ]:
+            result = await client.post(url, json=data)
+            assert result.status_code == 422 and "secret" not in result.text
+        assert (await client.post("/items/3?count=1", content=b"{")).status_code == 422
+
+
+async def test_response_failure_is_not_client_error_and_asgi_untouched():
+    @response(Output)
+    async def broken(request):
+        return {"names": []}
+
+    with pytest.raises(ValidationError):
+        await broken(None)
+
+    async def asgi(scope, receive, send):
+        pass
+
+    @response(Output)
+    async def streaming(request):
+        return asgi
+
+    assert await streaming(None) is asgi
+
+
+@pytest.mark.parametrize("by_alias, key", [(True, "displayName"), (False, "name")])
+async def test_response_alias_matches_schema(by_alias, key):
+    class Aliased(BaseModel):
+        name: str = Field(serialization_alias="displayName")
+
+    app = App()
+
+    @app.route("/")
+    @response(Aliased, by_alias=by_alias)
+    async def handler(request):
+        return {"name": "hello"}
+
+    async with httpx.AsyncClient(
+        transport=httpx.ASGITransport(app), base_url="http://test"
+    ) as client:
+        result = await client.get("/")
+    assert result.json() == {key: "hello"}
+    schema = handler.__wred_openapi__["responses"]["200"]["content"][
+        "application/json"
+    ]["schema"]
+    assert set(schema["properties"]) == set(result.json())
+
+
+@pytest.mark.parametrize("status", [302, 400, 404, 422, 500, 204, 205])
+async def test_response_preserves_errors_redirects_and_empty_statuses(status):
+    app = App()
+    payload = b"" if status in (204, 205) else {"detail": "not a success model"}
+
+    @app.route("/")
+    @response(Output)
+    async def handler(request):
+        return payload, [("x-test", "preserved")], status
+
+    async with httpx.AsyncClient(
+        transport=httpx.ASGITransport(app), base_url="http://test"
+    ) as client:
+        result = await client.get("/")
+    assert result.status_code == status
+    assert result.headers["x-test"] == "preserved"
+    if status in (204, 205):
+        assert result.content == b""
+    else:
+        assert result.json() == payload
+
+
+@pytest.mark.parametrize("size, expected", [(16, 200), (17, 413)])
+async def test_body_limit_counts_streamed_bytes_and_stops_reading(size, expected):
+    app = App()
+    consumed = []
+    called = []
+
+    @app.route("/", methods=["POST"])
+    @body(str, max_bytes=16)
+    async def handler(request, body):
+        called.append(body)
+        return {"value": body}
+
+    async def chunks():
+        for chunk in (b'"', b"a" * (size - 2), b'"', b" " * 100):
+            consumed.append(chunk)
+            yield chunk
+            if expected == 200 and len(consumed) == 3:
+                return
+
+    async with httpx.AsyncClient(
+        transport=httpx.ASGITransport(app), base_url="http://test"
+    ) as client:
+        result = await client.post("/", content=chunks())
+    assert result.status_code == expected
+    assert len(consumed) == 3
+    assert bool(called) == (expected == 200)
+
+
+async def test_concurrent_requests_keep_original_path_arguments_isolated():
+    app = App()
+    arrived = 0
+    ready = asyncio.Event()
+
+    def pause(handler):
+        async def wrapped(request, **kwargs):
+            nonlocal arrived
+            arrived += 1
+            if arrived == 2:
+                ready.set()
+            await asyncio.wait_for(ready.wait(), timeout=2)
+            return await handler(request, **kwargs)
+
+        return wrapped
+
+    @app.route("/{item_id}", methods=["POST"])
+    @body(Input)
+    @pause
+    @path(Path)
+    async def handler(request, item_id, body, path):
+        return {"id": path.item_id, "name": body.name}
+
+    async with httpx.AsyncClient(
+        transport=httpx.ASGITransport(app), base_url="http://test"
+    ) as client:
+        results = await asyncio.gather(
+            *[client.post(f"/{i}", json={"label": str(i)}) for i in (1, 2)]
+        )
+    assert [r.json() for r in results] == [
+        {"id": 1, "name": "1"},
+        {"id": 2, "name": "2"},
+    ]
+
+
+@pytest.mark.parametrize("limit, expected", [(3, 413), (None, 200)])
+async def test_body_limit_applies_to_cached_body_and_can_be_disabled(limit, expected):
+    app = App()
+
+    @body(str, max_bytes=limit)
+    async def validated(request, body):
+        return {"value": body}
+
+    @app.route("/", methods=["POST"])
+    async def handler(request):
+        await request.body()
+        return await validated(request)
+
+    async with httpx.AsyncClient(
+        transport=httpx.ASGITransport(app), base_url="http://test"
+    ) as client:
+        result = await client.post("/", json="hello")
+    assert result.status_code == expected

wred_pydantic-0.1.0/tox.ini

@@ -0,0 +1,12 @@
+[tox]
+env_list = py312-wred{013,014}-pydantic{min,latest}
+
+[testenv]
+package = wheel
+extras = test
+deps =
+    wred013: wred==0.13
+    wred014: wred==0.14
+    pydanticmin: pydantic==2.8.0
+    pydanticlatest: pydantic>=2.8,<3
+commands = python -m pytest -q

wred_pydantic-0.1.0/wred_pydantic/__init__.py

@@ -0,0 +1,180 @@
+"""Explicit Pydantic v2 validation and serialization for Wred."""
+
+from contextvars import ContextVar
+from functools import wraps
+
+from pydantic import TypeAdapter, ValidationError
+
+__version__ = "0.1.0"
+
+# Task-local: nested input decorators share only the original route arguments.
+_route_context = ContextVar("wred_pydantic_route", default=None)
+
+
+class _BodyTooLarge(Exception):
+    pass
+
+
+async def _read_body(request, max_bytes):
+    if max_bytes is None:
+        return await request.body()
+    receive = request.receive
+    size = 0
+
+    async def limited_receive():
+        nonlocal size
+        message = await receive()
+        size += len(message.get("body", b""))
+        if size > max_bytes:
+            raise _BodyTooLarge
+        return message
+
+    request.receive = limited_receive
+    try:
+        data = await request.body()
+    finally:
+        request.receive = receive
+    # Also enforce the limit if middleware already cached the body.
+    if len(data) > max_bytes:
+        raise _BodyTooLarge
+    return data
+
+
+def _metadata(handler, **entries):
+    metadata = dict(getattr(handler, "__wred_openapi__", {}))
+    for key, value in entries.items():
+        if key == "responses":
+            merged = dict(metadata.get(key, {}))
+            for status, definition in value.items():
+                if status in merged and merged[status] != definition:
+                    raise ValueError(f"Conflicting response metadata: {status}")
+                merged[status] = definition
+            metadata[key] = merged
+        else:
+            if key in metadata and metadata[key] != value:
+                raise ValueError(f"Conflicting {key} metadata")
+            metadata[key] = value
+    handler.__wred_openapi__ = metadata
+
+
+def _validate(model, source, argument, max_bytes=None):
+    adapter = TypeAdapter(model)
+    if not argument or not argument.isidentifier() or argument == "request":
+        raise ValueError("Use a named argument other than request")
+
+    def decorate(handler):
+        @wraps(handler)
+        async def wrapped(request, *args, **kwargs):
+            if argument in kwargs:
+                raise TypeError(
+                    f"Validated argument conflicts with path parameter: {argument}"
+                )
+            context = _route_context.get()
+            route_kwargs = (
+                context[1] if context is not None and context[0] is request else kwargs
+            )
+            try:
+                if source == "body":
+                    value = adapter.validate_json(await _read_body(request, max_bytes))
+                else:
+                    value = adapter.validate_python(
+                        request.query if source == "query" else route_kwargs
+                    )
+            except _BodyTooLarge:
+                return (
+                    {"detail": "Request body too large"},
+                    [("content-type", "application/json")],
+                    413,
+                )
+            except ValidationError as exc:
+                errors = [
+                    {"loc": list(e["loc"]), "type": e["type"]}
+                    for e in exc.errors(
+                        include_input=False, include_context=False, include_url=False
+                    )
+                ]
+                return (
+                    {"detail": "Invalid request", "errors": errors},
+                    [("content-type", "application/json")],
+                    422,
+                )
+            except (UnicodeError, ValueError):
+                if source != "query":
+                    raise
+                return (
+                    {"detail": "Invalid query encoding"},
+                    [("content-type", "application/json")],
+                    422,
+                )
+            token = _route_context.set((request, route_kwargs))
+            try:
+                return await handler(request, *args, **kwargs, **{argument: value})
+            finally:
+                _route_context.reset(token)
+
+        _metadata(wrapped, **{source: adapter.json_schema()})
+        return wrapped
+
+    return decorate
+
+
+def body(model, *, argument="body", max_bytes=1024 * 1024):
+    """Validate raw JSON bytes and inject a model as a keyword argument."""
+    if max_bytes is not None and (type(max_bytes) is not int or max_bytes < 0):
+        raise ValueError("max_bytes must be a nonnegative integer or None")
+    return _validate(model, "body", argument, max_bytes)
+
+
+def query(model, *, argument="query"):
+    """Validate Wred's query mapping (repeated keys retain their last value)."""
+    return _validate(model, "query", argument)
+
+
+def path(model, *, argument="path"):
+    """Validate route kwargs, preserving the original kwargs too."""
+    return _validate(model, "path", argument)
+
+
+def response(model, *, status=200, by_alias=True):
+    """Validate and JSON-normalize a response body, preserving tuples and ASGI."""
+    adapter = TypeAdapter(model)
+
+    def decorate(handler):
+        @wraps(handler)
+        async def wrapped(request, *args, **kwargs):
+            result = await handler(request, *args, **kwargs)
+            if callable(result):
+                return result
+            if isinstance(result, tuple):
+                payload, _headers, actual_status = result
+                if not 200 <= actual_status < 300 or actual_status in (204, 205):
+                    return result
+            else:
+                payload = result
+            normalized = adapter.dump_python(
+                adapter.validate_python(payload), mode="json", by_alias=by_alias
+            )
+            return (
+                (normalized, result[1], result[2])
+                if isinstance(result, tuple)
+                else normalized
+            )
+
+        _metadata(
+            wrapped,
+            responses={
+                str(status): {
+                    "description": "Successful response",
+                    "content": {
+                        "application/json": {
+                            "schema": adapter.json_schema(
+                                mode="serialization", by_alias=by_alias
+                            )
+                        }
+                    },
+                }
+            },
+        )
+        return wrapped
+
+    return decorate