stupidhuman-func 0.2.0__py3-none-any.whl

azure_func/__init__.py

@@ -0,0 +1,5 @@
+from .app import AzureFunctionApp
+from .service_handler import ServiceHandler
+from .openai import stream_chat
+
+__all__ = ["AzureFunctionApp", "ServiceHandler", "stream_chat"]

azure_func/app.py

@@ -0,0 +1,48 @@
+import azure.functions as func
+
+from .decorator import make_http_handler
+
+
+class AzureFunctionApp:
+    """
+    Thin wrapper around ``azure.functions.FunctionApp`` that adds a
+    ``@app.route()`` decorator for turning plain Python functions into
+    Azure HTTP-triggered functions.
+
+    Usage::
+
+        app = AzureFunctionApp()
+
+        @app.route()
+        def full_name(fname, lname):
+            return fname + " " + lname
+
+        # The underlying FunctionApp is available as app.func_app
+    """
+
+    def __init__(self, http_auth_level=func.AuthLevel.ANONYMOUS, **kwargs):
+        self.func_app = func.FunctionApp(http_auth_level=http_auth_level, **kwargs)
+
+    # Proxy attribute access so callers can do ``app.func_app`` things directly
+    def __getattr__(self, name):
+        return getattr(self.func_app, name)
+
+    def route(self, route: str = None, methods: list = None):
+        """
+        Decorator that registers the wrapped function as an Azure HTTP trigger.
+
+        Args:
+            route:   URL path segment. Defaults to the function's own name.
+            methods: HTTP methods to accept. Defaults to ``["GET", "POST"]``.
+
+        The decorated function is returned unchanged so it can still be
+        called directly in tests or other Python code.
+        """
+        if methods is None:
+            methods = ["GET", "POST"]
+
+        def decorator(fn):
+            route_name = route or fn.__name__
+            return make_http_handler(fn, self.func_app, route_name, methods)
+
+        return decorator

azure_func/decorator.py

@@ -0,0 +1,234 @@
+import inspect
+import json
+import logging
+import mimetypes
+import os
+
+from .scope import extract_scopes, TOOL_PROP_ATTR
+
+
+async def _extract_params_async(req, params):
+    """
+    Extract and coerce parameters from a FastAPI-compatible Request.
+
+    Resolution order: query string → route params → JSON body.
+    Parameters annotated with ``bytes`` receive the raw request body directly.
+    Returns (kwargs dict, error response dict or None).
+    """
+    # Read raw body once if any parameter wants bytes.
+    needs_raw = any(
+        p.annotation is bytes
+        for p in params.values()
+        if p.annotation is not inspect.Parameter.empty
+    )
+    raw_body = (await req.body()) if needs_raw else None
+
+    try:
+        if "application/json" in req.headers.get("content-type", ""):
+            body = await req.json()
+            if not isinstance(body, dict):
+                body = {}
+        else:
+            body = {}
+    except Exception:
+        body = {}
+
+    kwargs = {}
+    errors = []
+
+    for name, param in params.items():
+        annotation = param.annotation
+
+        if annotation is bytes:
+            kwargs[name] = raw_body if raw_body is not None else b""
+            continue
+
+        value = req.query_params.get(name)
+        if value is None:
+            value = req.path_params.get(name)
+        if value is None:
+            value = body.get(name)
+
+        if value is None:
+            if param.default is not inspect.Parameter.empty:
+                kwargs[name] = param.default
+                continue
+            else:
+                errors.append(name)
+                continue
+
+        # Type coercion driven by annotation
+        if annotation is not inspect.Parameter.empty and annotation is not str:
+            try:
+                if annotation is bool:
+                    value = value.lower() not in ("0", "false", "no", "")
+                else:
+                    value = annotation(value)
+            except (ValueError, TypeError) as exc:
+                return None, {
+                    "error": f"Invalid value for '{name}': expected {annotation.__name__}, got {value!r}",
+                    "detail": str(exc),
+                }
+
+        kwargs[name] = value
+
+    if errors:
+        return None, {"error": f"Missing required parameter(s): {', '.join(errors)}"}
+
+    return kwargs, None
+
+
+def make_queue_handler(fn, app, queue_name, connection):
+    """Register fn as an Azure Queue trigger and return the original fn."""
+    import azure.functions as func
+
+    def queue_trigger(msg: func.QueueMessage) -> None:
+        try:
+            fn(msg)
+        except Exception:
+            logging.exception("Unhandled error in queue handler %s", fn.__name__)
+            raise
+
+    queue_trigger.__name__ = fn.__name__
+    app.queue_trigger(arg_name="msg", queue_name=queue_name, connection=connection)(queue_trigger)
+    return fn
+
+
+def make_static_handler(handler_name, folder, app):
+    """Register a catch-all GET route that serves files from folder."""
+    from azurefunctions.extensions.http.fastapi import Request, Response
+
+    base = os.path.abspath(folder)
+
+    async def static_handler(req: Request):
+        filepath = req.path_params.get("filepath", "")
+
+        # Prevent path traversal
+        target = os.path.abspath(os.path.join(base, filepath))
+        if not target.startswith(base + os.sep) and target != base:
+            return Response(status_code=404)
+
+        if not os.path.isfile(target):
+            return Response(status_code=404)
+
+        mime_type, _ = mimetypes.guess_type(target)
+        mime_type = mime_type or "application/octet-stream"
+
+        with open(target, "rb") as f:
+            return Response(content=f.read(), media_type=mime_type, status_code=200)
+
+    static_handler.__name__ = handler_name
+    app.route(route="{*filepath}", methods=["GET"])(static_handler)
+
+
+def make_mcp_handler(fn, app):
+    """Register fn as an Azure MCP tool trigger and return the original fn."""
+    sig = inspect.signature(fn)
+    params = sig.parameters
+    param_names = list(params.keys())
+
+    # The Azure Functions runtime inspects the handler's parameter names to map
+    # MCP arguments. Using **kwargs or a single 'kwargs' parameter causes the
+    # runtime to pass all args under a single key named 'kwargs'. We must
+    # generate a handler whose signature exactly matches fn's parameters.
+    param_str = ", ".join(param_names)
+    call_str = ", ".join(f"{name}={name}" for name in param_names)
+    globs = {"fn": fn}
+    exec(
+        f"def mcp_handler({param_str}):\n    return fn({call_str})",
+        globs,
+    )
+    mcp_handler = globs["mcp_handler"]
+
+    mcp_handler.__name__ = fn.__name__
+    mcp_handler.__doc__ = fn.__doc__
+
+    # Copy type annotations so the SDK builds the correct JSON Schema types.
+    mcp_handler.__annotations__ = {
+        name: params[name].annotation
+        for name in param_names
+        if params[name].annotation is not inspect.Parameter.empty
+    }
+
+    # Attach property metadata for each parameter, then register the tool.
+    # mcp_tool_property adds metadata in-place; mcp_tool() does the registration.
+    descriptions = getattr(fn, TOOL_PROP_ATTR, {})
+    for name in params:
+        kw = {"arg_name": name}
+        if name in descriptions:
+            kw["description"] = descriptions[name]
+        app.mcp_tool_property(**kw)(mcp_handler)
+    app.mcp_tool()(mcp_handler)
+
+    return fn
+
+
+def make_stream_handler(fn, app, route_name, methods, media_type, required_scopes=None):
+    """Register fn as a streaming HTTP-triggered function and return the original fn."""
+    from azurefunctions.extensions.http.fastapi import Request, StreamingResponse
+
+    sig = inspect.signature(fn)
+    params = sig.parameters
+
+    async def stream_trigger(req: Request) -> StreamingResponse:
+        if required_scopes:
+            token_scopes = extract_scopes(req.headers.get("Authorization", ""))
+            missing = [s for s in required_scopes if s not in token_scopes]
+            if missing:
+                async def _forbidden():
+                    yield json.dumps(
+                        {"error": "Insufficient scope", "required": missing},
+                        ensure_ascii=False,
+                    )
+                return StreamingResponse(_forbidden(), status_code=403, media_type="application/json")
+
+        kwargs, err = await _extract_params_async(req, params)
+        if err is not None:
+            async def _bad_request():
+                yield json.dumps(err, ensure_ascii=False)
+            return StreamingResponse(_bad_request(), status_code=400, media_type="application/json")
+
+        return StreamingResponse(fn(**kwargs), media_type=media_type)
+
+    stream_trigger.__name__ = fn.__name__
+    app.route(route=route_name, methods=methods)(stream_trigger)
+    return fn
+
+
+def make_http_handler(fn, app, route_name, methods, required_scopes=None):
+    """Register fn as an Azure HTTP-triggered function and return the original fn."""
+    from azurefunctions.extensions.http.fastapi import Request, Response
+
+    sig = inspect.signature(fn)
+    params = sig.parameters
+
+    def _json(data, status_code):
+        return Response(
+            content=json.dumps(data, ensure_ascii=False),
+            status_code=status_code,
+            media_type="application/json",
+        )
+
+    async def http_trigger(req: Request):
+        if required_scopes:
+            token_scopes = extract_scopes(req.headers.get("Authorization", ""))
+            missing = [s for s in required_scopes if s not in token_scopes]
+            if missing:
+                return _json({"error": "Insufficient scope", "required": missing}, 403)
+
+        kwargs, err = await _extract_params_async(req, params)
+        if err is not None:
+            return _json(err, 400)
+
+        try:
+            result = fn(**kwargs)
+        except Exception as exc:
+            logging.exception("Unhandled error in %s", fn.__name__)
+            return _json({"error": "Internal server error", "detail": str(exc)}, 500)
+
+        return _json({"result": result}, 200)
+
+    http_trigger.__name__ = fn.__name__
+    app.route(route=route_name, methods=methods)(http_trigger)
+
+    return fn

azure_func/mcp_server.py

@@ -0,0 +1,183 @@
+import asyncio
+import inspect
+import json
+import logging
+
+from .scope import attach_tool_property_description, TOOL_PROP_ATTR
+
+_JSON_SCHEMA_TYPE = {
+    str: "string",
+    int: "integer",
+    float: "number",
+    bool: "boolean",
+    list: "array",
+    dict: "object",
+}
+
+
+def _build_input_schema(params, descriptions=None):
+    properties = {}
+    required = []
+    for name, param in params.items():
+        prop = {}
+        annotation = param.annotation
+        if annotation is not inspect.Parameter.empty and annotation in _JSON_SCHEMA_TYPE:
+            prop["type"] = _JSON_SCHEMA_TYPE[annotation]
+        if descriptions and name in descriptions:
+            prop["description"] = descriptions[name]
+        if param.default is inspect.Parameter.empty:
+            required.append(name)
+        properties[name] = prop
+    return {"type": "object", "properties": properties, "required": required}
+
+
+def _coerce_args(arguments, params):
+    result = {}
+    missing = []
+    for name, param in params.items():
+        if name not in arguments:
+            if param.default is not inspect.Parameter.empty:
+                result[name] = param.default
+            else:
+                missing.append(name)
+            continue
+        value = arguments[name]
+        annotation = param.annotation
+        if annotation is not inspect.Parameter.empty and not isinstance(value, annotation):
+            try:
+                value = annotation(value)
+            except (ValueError, TypeError):
+                pass
+        result[name] = value
+    if missing:
+        raise ValueError(f"Missing required argument(s): {', '.join(missing)}")
+    return result
+
+
+class McpToolServer:
+    """
+    A self-contained MCP tool server exposed as a single POST route.
+
+    Create via ``sh.mcp_server(name, route)`` and register tools with
+    the ``@server.tool()`` decorator::
+
+        search = sh.mcp_server("search", route="mcp/search")
+
+        @search.tool()
+        def find_products(query: str, customer_id: str) -> list:
+            \"\"\"Search products for a customer.\"\"\"
+            ...
+
+    Handles ``initialize``, ``tools/list``, and ``tools/call`` JSON-RPC 2.0.
+    """
+
+    def __init__(self, name: str, route: str, func_app):
+        self._name = name
+        self._tools = {}
+        self._register_endpoint(route, func_app)
+
+    def tool(self):
+        """Register the decorated function as a tool on this MCP server."""
+        def decorator(fn):
+            sig = inspect.signature(fn)
+            descriptions = getattr(fn, TOOL_PROP_ATTR, {})
+            self._tools[fn.__name__] = {
+                "fn": fn,
+                "description": (fn.__doc__ or "").strip(),
+                "params": sig.parameters,
+                "schema": _build_input_schema(sig.parameters, descriptions),
+            }
+            return fn
+        return decorator
+
+    def tool_property(self, arg_name: str, description: str):
+        """
+        Attach a description to a tool parameter.
+
+        Must be applied below ``@server.tool()`` (closer to the function).
+        Cumulative — stack multiple calls for different parameters::
+
+            @invoices.tool()
+            @invoices.tool_property("invoice_id", "The invoice's unique identifier")
+            @invoices.tool_property("include_lines", "Include line items in the response")
+            def get_invoice(invoice_id: str, include_lines: bool = True) -> dict:
+                \"\"\"Retrieve an invoice by ID.\"\"\"
+                ...
+        """
+        return attach_tool_property_description(arg_name, description)
+
+    def _register_endpoint(self, route, func_app):
+        from azurefunctions.extensions.http.fastapi import Request, Response
+
+        tools = self._tools
+        name = self._name
+
+        def _ok(rpc_id, result):
+            return Response(
+                content=json.dumps({"jsonrpc": "2.0", "id": rpc_id, "result": result}, ensure_ascii=False),
+                status_code=200,
+                media_type="application/json",
+            )
+
+        def _err(rpc_id, code, message):
+            return Response(
+                content=json.dumps({"jsonrpc": "2.0", "id": rpc_id, "error": {"code": code, "message": message}}, ensure_ascii=False),
+                status_code=200,
+                media_type="application/json",
+            )
+
+        async def mcp_endpoint(req: Request):
+            try:
+                body = await req.json()
+            except Exception:
+                return _err(None, -32700, "Parse error")
+
+            rpc_id = body.get("id")
+            method = body.get("method", "")
+            params = body.get("params") or {}
+
+            if method == "initialize":
+                return _ok(rpc_id, {
+                    "protocolVersion": "2024-11-05",
+                    "capabilities": {"tools": {}},
+                    "serverInfo": {"name": name, "version": "1.0.0"},
+                })
+
+            if method == "notifications/initialized":
+                return Response(content="", status_code=204, media_type="application/json")
+
+            if method == "tools/list":
+                return _ok(rpc_id, {
+                    "tools": [
+                        {"name": n, "description": t["description"], "inputSchema": t["schema"]}
+                        for n, t in tools.items()
+                    ]
+                })
+
+            if method == "tools/call":
+                tool_name = params.get("name")
+                arguments = params.get("arguments") or {}
+
+                if tool_name not in tools:
+                    return _err(rpc_id, -32601, f"Unknown tool: {tool_name!r}")
+
+                t = tools[tool_name]
+                try:
+                    kwargs = _coerce_args(arguments, t["params"])
+                    result = t["fn"](**kwargs)
+                    if asyncio.iscoroutine(result):
+                        result = await result
+                except Exception as exc:
+                    logging.exception("Error in MCP tool %s", tool_name)
+                    return _ok(rpc_id, {
+                        "content": [{"type": "text", "text": str(exc)}],
+                        "isError": True,
+                    })
+
+                text = result if isinstance(result, str) else json.dumps(result, ensure_ascii=False)
+                return _ok(rpc_id, {"content": [{"type": "text", "text": text}]})
+
+            return _err(rpc_id, -32601, f"Method not found: {method!r}")
+
+        mcp_endpoint.__name__ = f"mcp_{name}"
+        func_app.route(route=route, methods=["POST"])(mcp_endpoint)

azure_func/openai.py

@@ -0,0 +1,117 @@
+import os
+import json
+import httpx
+
+OPENAI_API_URL = "https://api.openai.com/v1"
+
+_TIMEOUT = httpx.Timeout(connect=5.0, read=60.0, write=10.0, pool=5.0)
+
+
+async def _stream_request(client: httpx.AsyncClient, payload: dict):
+    """Yield parsed SSE event dicts from a single /responses request."""
+    async with client.stream(
+        "POST",
+        f"{OPENAI_API_URL}/responses",
+        headers={
+            "Content-Type": "application/json",
+            "Authorization": f"Bearer {os.getenv('OPENAI_API_KEY')}",
+        },
+        json=payload,
+    ) as response:
+        if response.status_code != 200:
+            yield {"type": "error", "_status": response.status_code}
+            return
+
+        buffer = ""
+        async for chunk in response.aiter_text():
+            buffer += chunk
+            while "\n\n" in buffer:
+                block, buffer = buffer.split("\n\n", 1)
+                for line in block.splitlines():
+                    if not line.startswith("data: "):
+                        continue
+                    raw = line[6:]
+                    if raw == "[DONE]":
+                        continue
+                    try:
+                        yield json.loads(raw)
+                    except json.JSONDecodeError:
+                        continue
+
+
+async def stream_chat(messages: list, model: str, tools: list | None = None, system_prompt: str = ""):
+    """
+    Stream an OpenAI Responses API call as SSE chunks.
+
+    Yields SSE-formatted strings for the caller to forward to the HTTP client.
+    Yields a final  data: {"type": "done", "content": "<full text>"}  event that
+    the caller can use to persist the assistant turn (e.g. to a database).
+    That event should NOT be forwarded to the browser.
+    """
+    assistant_content = ""
+    if tools is None:
+        tools = []
+
+    async with httpx.AsyncClient(timeout=_TIMEOUT) as client:
+        previous_response_id = None
+        had_mcp_call = False
+
+        while True:
+            if previous_response_id:
+                # Continuation: model ended after a tool call without presenting results
+                payload = {
+                    "model": model,
+                    "instructions": system_prompt,
+                    "previous_response_id": previous_response_id,
+                    "stream": True,
+                    "tools": tools,
+                }
+            else:
+                payload = {
+                    "model": model,
+                    "instructions": system_prompt,
+                    "input": [{"role": m["role"], "content": m["content"]} for m in messages],
+                    "stream": True,
+                    "tools": tools,
+                }
+
+            got_text = False
+            had_mcp_call = False
+            current_response_id = None
+
+            async for data in _stream_request(client, payload):
+                event_type = data.get("type")
+
+                if event_type == "error":
+                    status = data.get("_status")
+                    yield f"data: {json.dumps({'type': 'error', 'content': f'OpenAI error {status}'})}\n\n"
+                    return
+
+                elif event_type == "response.created":
+                    current_response_id = data.get("response", {}).get("id")
+
+                elif event_type == "response.output_text.delta":
+                    delta = data.get("delta", "")
+                    assistant_content += delta
+                    got_text = True
+                    yield f"data: {json.dumps({'type': 'content', 'content': delta})}\n\n"
+
+                elif event_type == "response.output_item.added":
+                    item = data.get("item", {})
+                    if item.get("type") == "mcp_call":
+                        had_mcp_call = True
+                        yield f"data: {json.dumps({'type': 'tool_call', 'name': item.get('name', item.get('server_label', 'tool'))})}\n\n"
+
+                elif event_type == "response.mcp_call.completed":
+                    yield f"data: {json.dumps({'type': 'tool_done'})}\n\n"
+
+            # If the response ended after an MCP call but produced no text,
+            # continue with previous_response_id so the model presents the results.
+            if had_mcp_call and not got_text and current_response_id:
+                previous_response_id = current_response_id
+            else:
+                break
+
+    # Terminal event — not forwarded to the client, used by the caller to
+    # persist the assistant turn without re-parsing the SSE stream.
+    yield f"data: {json.dumps({'type': 'done', 'content': assistant_content})}\n\n"

azure_func/scope.py

@@ -0,0 +1,66 @@
+"""JWT scope extraction and scope-metadata decorator."""
+import base64
+import json
+import re
+
+# Attribute name used to carry required-scope metadata on a function
+SCOPE_ATTR = "_required_scopes"
+TOOL_PROP_ATTR = "_tool_property_descriptions"
+
+
+def _decode_jwt_payload(token: str) -> dict:
+    """Base64-decode the payload part of a JWT (no signature verification)."""
+    try:
+        parts = token.split(".")
+        if len(parts) != 3:
+            return {}
+        payload = parts[1]
+        # Restore stripped padding
+        payload += "=" * (-len(payload) % 4)
+        return json.loads(base64.urlsafe_b64decode(payload))
+    except Exception:
+        return {}
+
+
+def extract_scopes(authorization_header: str) -> set:
+    """
+    Return the set of scopes found in a Bearer JWT Authorization header.
+
+    Handles:
+    - Azure AD ``scp`` claim (space-separated string)
+    - Standard OAuth2 ``scope`` claim (space-separated string or list)
+    """
+    if not authorization_header:
+        return set()
+    match = re.match(r"^Bearer\s+(.+)$", authorization_header, re.IGNORECASE)
+    if not match:
+        return set()
+    payload = _decode_jwt_payload(match.group(1))
+    raw = payload.get("scp") or payload.get("scope") or ""
+    if isinstance(raw, list):
+        return set(raw)
+    return set(raw.split())
+
+
+def attach_tool_property_description(arg_name: str, description: str):
+    """Attach a parameter description for an MCP tool property."""
+    def decorator(fn):
+        existing = getattr(fn, TOOL_PROP_ATTR, {})
+        existing[arg_name] = description
+        fn._tool_property_descriptions = existing
+        return fn
+    return decorator
+
+
+def require_scopes(*scopes: str):
+    """
+    Attach required-scope metadata to a function.
+
+    Decorators are cumulative — stacking ``@sh.scope()`` calls accumulates all
+    listed scopes.
+    """
+    def decorator(fn):
+        existing = getattr(fn, SCOPE_ATTR, [])
+        fn._required_scopes = list(existing) + list(scopes)
+        return fn
+    return decorator

azure_func/service_handler.py

@@ -0,0 +1,251 @@
+import azure.functions as func
+
+from .decorator import make_http_handler, make_mcp_handler, make_queue_handler, make_static_handler, make_stream_handler
+from .mcp_server import McpToolServer
+from .scope import require_scopes, SCOPE_ATTR, attach_tool_property_description
+
+
+class ServiceHandler:
+    """
+    Service registry that turns plain Python functions into Azure HTTP triggers.
+
+    Usage::
+
+        sh = ServiceHandler()
+
+        @sh.service()
+        @sh.scope('read:data')
+        def my_func(fname, lname):
+            return fname + " " + lname
+
+        # Pass sh.func_app to Azure as the FunctionApp entry point
+    """
+
+    def __init__(self, http_auth_level=func.AuthLevel.ANONYMOUS, **kwargs):
+        self.func_app = func.FunctionApp(http_auth_level=http_auth_level, **kwargs)
+
+    def __getattr__(self, name):
+        return getattr(self.func_app, name)
+
+    # ------------------------------------------------------------------
+    # Decorators
+    # ------------------------------------------------------------------
+
+    def service(self, route: str = None, methods: list = None):
+        """
+        Register the decorated function as an Azure HTTP trigger.
+
+        Args:
+            route:   URL path segment. Defaults to the function's own name.
+            methods: HTTP methods to accept. Defaults to ``["GET", "POST"]``.
+
+        Any ``@sh.scope()`` metadata already attached to the function is
+        read here and incorporated into the generated handler.
+        """
+        if methods is None:
+            methods = ["GET", "POST"]
+
+        def decorator(fn):
+            route_name = route or fn.__name__
+            required_scopes = getattr(fn, SCOPE_ATTR, [])
+            return make_http_handler(
+                fn, self.func_app, route_name, methods,
+                required_scopes=required_scopes,
+            )
+
+        return decorator
+
+    def anonymous(self, route: str = None, methods: list = None):
+        """
+        Register the decorated function as an Azure HTTP trigger with no
+        authentication or scope requirements.
+
+        Args:
+            route:   URL path segment. Defaults to the function's own name.
+            methods: HTTP methods to accept. Defaults to ``["GET", "POST"]``.
+
+        Use this instead of ``@sh.service()`` to make the intent explicit that
+        the endpoint is publicly accessible, even when other endpoints on the
+        same handler use ``@sh.scope()``.
+        """
+        if methods is None:
+            methods = ["GET", "POST"]
+
+        def decorator(fn):
+            route_name = route or fn.__name__
+            return make_http_handler(fn, self.func_app, route_name, methods)
+
+        return decorator
+
+    def queue(self, queue_name: str, connection: str = "AzureWebJobsStorage"):
+        """
+        Register the decorated function as an Azure Queue trigger.
+
+        Args:
+            queue_name: Name of the storage queue to listen on.
+            connection: App setting name for the storage connection string.
+                        Defaults to ``"AzureWebJobsStorage"``.
+
+        The decorated function receives a single ``func.QueueMessage`` argument::
+
+            @sh.queue("my-queue")
+            def process_message(msg: func.QueueMessage):
+                data = msg.get_json()
+                ...
+        """
+        def decorator(fn):
+            return make_queue_handler(fn, self.func_app, queue_name, connection)
+        return decorator
+
+    def stream(self, route: str = None, methods: list = None, media_type: str = "text/event-stream"):
+        """
+        Register the decorated async generator function as a streaming HTTP trigger.
+
+        Args:
+            route:      URL path segment. Defaults to the function's own name.
+            methods:    HTTP methods to accept. Defaults to ``["GET", "POST"]``.
+            media_type: Content-Type for the streamed response.
+                        Defaults to ``"text/event-stream"`` (Server-Sent Events).
+
+        Any ``@sh.scope()`` metadata is enforced identically to ``@sh.service()``.
+
+        The decorated function must be an ``async`` generator (uses ``yield``)::
+
+            @sh.stream()
+            async def token_stream(prompt: str):
+                \"\"\"Stream tokens for a prompt.\"\"\"
+                for token in generate(prompt):
+                    yield token
+        """
+        if methods is None:
+            methods = ["GET", "POST"]
+
+        def decorator(fn):
+            route_name = route or fn.__name__
+            required_scopes = getattr(fn, SCOPE_ATTR, [])
+            return make_stream_handler(
+                fn, self.func_app, route_name, methods, media_type,
+                required_scopes=required_scopes,
+            )
+
+        return decorator
+
+    def static(self, folder: str):
+        """
+        Serve static files from ``folder`` at the root URL path.
+
+        Registers a catch-all GET route ``{*filepath}`` that maps request paths
+        directly to files inside ``folder``. Path traversal is blocked.
+
+        Args:
+            folder: Path to the directory to serve (relative to the working
+                    directory of the function app, or absolute).
+
+        Usage::
+
+            @sh.static('public')
+            def serve_static():
+                pass
+
+            # GET /style.css      →  ./public/style.css
+            # GET /js/app.js      →  ./public/js/app.js
+        """
+        def decorator(fn):
+            make_static_handler(fn.__name__, folder, self.func_app)
+            return fn
+
+        return decorator
+
+    def tool(self):
+        """
+        Register the decorated function as an Azure MCP tool trigger.
+
+        The function name becomes the tool name and the docstring becomes the
+        tool description. Each parameter is registered as an MCP tool property.
+
+        Note: MCP tools are authenticated via the Azure ``mcp_extension`` system
+        key at the host level. ``@sh.scope()`` is not supported for tools.
+
+        Usage::
+
+            @sh.tool()
+            def get_item(item_id: int) -> str:
+                \"\"\"Get an item by ID.\"\"\"
+                return str(item_id)
+        """
+        def decorator(fn):
+            return make_mcp_handler(fn, self.func_app)
+
+        return decorator
+
+    def tool_property(self, arg_name: str, description: str):
+        """
+        Attach a description to an MCP tool parameter.
+
+        Must be applied below ``@sh.tool()`` (closer to the function definition).
+        Cumulative — multiple calls attach descriptions to different parameters.
+
+        Usage::
+
+            @sh.tool()
+            @sh.tool_property("item_id", "The ID of the item to retrieve.")
+            def get_item(item_id: int) -> str:
+                \"\"\"Get an item by ID.\"\"\"
+                return str(item_id)
+        """
+        return attach_tool_property_description(arg_name, description)
+
+    def mcp_server(self, name: str, route: str = None) -> McpToolServer:
+        """
+        Create a named MCP tool server exposed as a single POST route.
+
+        Args:
+            name:  Server name, used in the ``serverInfo`` response.
+            route: URL path. Defaults to ``mcp/<name>``.
+
+        Returns an :class:`McpToolServer` whose ``@server.tool()`` decorator
+        registers tools on that server only. Multiple servers can coexist in
+        the same Function App at different routes::
+
+            sales    = sh.mcp_server("sales",    route="mcp/sales")
+            invoices = sh.mcp_server("invoices", route="mcp/invoices")
+
+            @sales.tool()
+            def lookup_customer(customer_id: str) -> dict:
+                \"\"\"Look up a customer account.\"\"\"
+                ...
+
+            @invoices.tool()
+            def get_invoice(invoice_id: str) -> dict:
+                \"\"\"Retrieve an invoice by ID.\"\"\"
+                ...
+
+        Each server handles ``initialize``, ``tools/list``, and
+        ``tools/call`` over JSON-RPC 2.0 POST.
+        """
+        route_name = route or f"mcp/{name}"
+        return McpToolServer(name, route_name, self.func_app)
+
+    def scope(self, *scopes: str):
+        """
+        Attach required OAuth2/JWT scope(s) to the function.
+
+        The scope is checked against the ``Authorization: Bearer <jwt>``
+        header on every request. Missing or insufficient scope returns 403.
+
+        Decorators are cumulative::
+
+            @sh.service()
+            @sh.scope('read:items')
+            @sh.scope('write:items')   # both required
+            def update_item(id, value):
+                ...
+
+        Multiple scopes may also be listed in a single call::
+
+            @sh.service()
+            @sh.scope('read:items', 'write:items')
+            def update_item(id, value):
+                ...
+        """
+        return require_scopes(*scopes)

stupidhuman_func-0.2.0.dist-info/METADATA

@@ -0,0 +1,11 @@
+Metadata-Version: 2.4
+Name: stupidhuman-func
+Version: 0.2.0
+Summary: Decorator library for turning plain Python functions into Azure HTTP-triggered Functions
+Requires-Python: >=3.8
+Requires-Dist: azure-functions>=1.24.0
+Requires-Dist: azurefunctions-extensions-http-fastapi
+Requires-Dist: httpx>=0.24.0
+Provides-Extra: dev
+Requires-Dist: pytest>=7.0; extra == "dev"
+Dynamic: requires-python

stupidhuman_func-0.2.0.dist-info/RECORD

@@ -0,0 +1,11 @@
+azure_func/__init__.py,sha256=3MXoG61qo97dZwCMVdSkP7icDcpFVbQ8bUrBfrI0VrM,175
+azure_func/app.py,sha256=uLQuvcYsGk7j_f1VzIVEFcy6QVZYfNJKVY4pPDePNww,1528
+azure_func/decorator.py,sha256=88zTIBNjh3PhkOROy47_hK7ODXVsZkcjjvQMe85ksu8,8208
+azure_func/mcp_server.py,sha256=6a_jv1BN9WM_J8IegN38q4qnZLsEWHW8OM1ITgsmuzk,6569
+azure_func/openai.py,sha256=RoXR3A1Iu1zd5U4QdNrrAXeAkdm5FvxwjSozlFLcB00,4600
+azure_func/scope.py,sha256=mp7DLG5vWV-QQ2r6zCQdQYv_aZ37JUYRnuGFxo8souw,2030
+azure_func/service_handler.py,sha256=ACxBMYyX7app1mSBourf0l5xsVdwMXvkGM4-SNNQibo,8814
+stupidhuman_func-0.2.0.dist-info/METADATA,sha256=9tKcWlGN4xtjcuctjT8mHs_b7wx2j4j91vCOsahfTVg,391
+stupidhuman_func-0.2.0.dist-info/WHEEL,sha256=aeYiig01lYGDzBgS8HxWXOg3uV61G9ijOsup-k9o1sk,91
+stupidhuman_func-0.2.0.dist-info/top_level.txt,sha256=qGfL6OWfhL5OlS1EbdHRsWebaebdf9wkWNV59txHuRc,11
+stupidhuman_func-0.2.0.dist-info/RECORD,,

stupidhuman_func-0.2.0.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (82.0.1)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

stupidhuman_func-0.2.0.dist-info/top_level.txt

@@ -0,0 +1 @@
+azure_func