class Foo(Namespace):
nested: Nested
@middleware(1)
async def middleware_1(self, handler, request):
response = await handler(request)
response.meta.setdefault("middlewares",
[]).append("Foo.middleware_1")
return response
@middleware(2)
async def middleware_2(self, handler, request):
response = await handler(request)
response.meta.setdefault("middlewares",
[]).append("Foo.middleware_2")
return response
@handler(schema=validx.Dict({"x": validx.Int(), "y": validx.Int()}))
async def sum(self, x, y, injection=None):
return x + y, injection
@handler(schema=validx.Dict({"x": validx.Int(), "y": validx.Int()}))
async def incorrect_div(self, x, y, injection=None):
return x / y, injection
@handler(
schema=validx.Dict({
"x": validx.Int(),
"y": validx.Int()
}),
raises=DivisionByZero,
)
async def div(self, x, y, injection=None):
try:
return x / y, injection
except ZeroDivisionError:
raise DivisionByZero()
validate_out=v.List(
v.Dict(
{
"id": v.Str(),
"label": v.Str(),
"state": v.Str(
options=[
"completed",
"running",
"pending",
"unscheduled",
"exception",
]
),
"tags": v.Dict(extra=(v.Str(), v.Str())),
"tier": v.Int(),
"duration": v.Int(),
"result": v.Str(
options=[
"passed",
"failed",
"exception",
"canceled",
"superseded",
]
),
},
optional=["duration", "result", "tier"],
)
),
),
import validx as v
city_schema: v.Validator = v.Dict(
{
"location": v.Tuple(v.Float(min=-90, max=90), v.Float(min=-180,
max=180)),
"name": v.Str(),
"alt_names": v.List(v.Str(), unique=True),
"population": v.Dict({
"city": v.Int(min=0),
"metro": v.Int(min=0)
}),
},
extra=(v.Str(), v.Any()),
)
from mozci import data
from mozci.data.base import DataHandler, DataSource
from mozci.data.contract import Contract
from mozci.errors import (
ContractNotFilled,
ContractNotFound,
InvalidSource,
SourcesNotFound,
)
FAKE_CONTRACTS = (
Contract(
name="foo",
description="test",
validate_in=v.Dict({"label": v.Str()}),
validate_out=v.Dict({"count": v.Int()}),
),
Contract(
name="bar",
description="test",
validate_in=v.Dict({"desc": v.Str()}),
validate_out=v.Dict({"amount": v.Int()}),
),
Contract(
name="baz",
description="test",
validate_in=v.Dict({"id": v.Str()}),
validate_out=v.Dict({"sum": v.Int()}),
),
Contract(
name="incomplete",
validate_out=v.List(
v.Dict(
{
"id": v.Str(),
"label": v.Str(),
"state": v.Str(
options=[
"completed",
"running",
"pending",
"unscheduled",
"exception",
]
),
"tags": v.Dict(extra=(v.Str(), v.Str())),
"tier": v.Int(),
"duration": v.Int(),
"result": v.Str(
options=[
"passed",
"failed",
"exception",
"canceled",
"superseded",
]
),
},
optional=["duration", "result", "tier"],
)
),
),
class Request:
schema: ClassVar[validx.Validator] = validx.Dict(
{
"id":
validx.Int(),
"method":
validx.Str(encoding="ascii"),
"params":
validx.Dict(extra=(validx.Str(), validx.Any())),
"meta":
validx.Dict(
{
"version":
validx.Tuple(
validx.Int(min=0), validx.Int(min=0), nullable=True),
},
optional=("version", ),
extra=(validx.Str(), validx.Any()),
),
},
defaults={
"params": {},
"meta": {}
},
)
id: int
method: str
meta: Dict[str, Any]
params: Dict[str, Any]
middlewares: List[Middleware]
injections: Dict[str, Any]
handler: Optional[Callable[..., Awaitable[Any]]]
handler_info: Dict[str, Any]
def __init__(
self,
id: int,
method: str,
meta: Dict[str, Any] = None,
params: Dict[str, Any] = None,
) -> None:
self.id = id
self.method = method
self.meta = meta if meta is not None else {}
self.params = params if params is not None else {}
self.middlewares = []
self.injections = {}
self.handler = None
self.handler_info = {}
@classmethod
def load(cls, payload: Dict[str, Any]) -> "Request":
try:
return cls(**cls.schema(payload))
except validx.exc.ValidationError as e:
raise RPCInvalidRequest(reason=cls.format_schema_error(e))
@classmethod
def format_schema_error(
cls, error: validx.exc.ValidationError) -> Dict[str, str]:
return dict(validx.exc.format_error(error))
@cached_property
def handler_signature(self) -> inspect.Signature:
assert self.handler is not None
return inspect.signature(self.handler)
def response(
self,
result: Any = None,
meta: Dict[str, Any] = None,
error: BaseError = None,
warnings: List[BaseWarning] = None,
) -> Response:
return Response(id=self.id,
meta=meta,
result=result,
error=error,
warnings=warnings)
"id":
v.Str(),
"label":
v.Str(),
"state":
v.Str(options=[
"completed",
"running",
"pending",
"unscheduled",
"exception",
]),
"tags":
v.Dict(extra=(v.Str(), v.Str())),
"tier":
v.Int(),
"duration":
v.Int(),
"result":
v.Str(options=[
"passed",
"failed",
"exception",
"canceled",
"superseded",
]),
},
optional=["duration", "result", "tier"],
)),
),
Contract(
"id":
v.Str(),
"label":
v.Str(),
"state":
v.Str(options=[
"completed",
"running",
"pending",
"unscheduled",
"exception",
]),
"tags":
v.Dict(extra=(v.Str(), v.Str())),
"tier":
v.Int(),
"duration":
v.Int(),
"result":
v.Str(options=[
"passed",
"failed",
"exception",
"canceled",
"superseded",
]),
},
optional=["duration", "result", "tier"],
)),
),
Contract(