ninja-devx 0.0.1__py3-none-any.whl

ninja_devx/__init__.py

@@ -0,0 +1,273 @@
+"""Typed class-based controllers, permissions, CRUD and DI for Django Ninja.
+
+Attributes are imported lazily (PEP 562), so ``import ninja_devx`` does not require
+configured Django settings (the pytest plugin relies on this).
+"""
+
+from __future__ import annotations
+
+import importlib
+from collections.abc import Mapping
+from importlib.metadata import PackageNotFoundError, version
+from types import MappingProxyType
+from typing import TYPE_CHECKING, Final
+
+if TYPE_CHECKING:
+    from .dependencies.container import (
+        AsyncRequestScopeProvider,
+        AsyncResolver,
+        Container,
+        ContainerLike,
+        Lifetime,
+        RequestScopeProvider,
+        Resolver,
+    )
+    from .dependencies.injection import Inject, Resolve, resolve
+    from .dependencies.instances import Invocation, get_invocation
+    from .exceptions import (
+        AsyncLazyAccessError,
+        BlockingCallWarning,
+        CircularDependencyError,
+        ControllerConfigError,
+        DependencyResolutionError,
+        MixedPathWarning,
+        NinjaDevXError,
+    )
+    from .http.conditional import ETag, PreconditionFailed, PreconditionRequired, conditional
+    from .http.errors import ErrorMap
+    from .idempotency import idempotent
+    from .routing.controller import Controller, ControllerOptions, Scope
+    from .routing.hooks import (
+        AsyncOperationHook,
+        LoggingHook,
+        OperationHook,
+        OperationInfo,
+        get_operation,
+    )
+    from .routing.mounting import Mount, mount
+    from .routing.operations import (
+        OperationOptions,
+        OperationSpec,
+        RouteOptions,
+        api_operation,
+        async_variant,
+        delete,
+        get,
+        patch,
+        post,
+        put,
+    )
+    from .routing.plugins import ControllerPlugin
+    from .routing.use_cases import use_case
+    from .security.auth import (
+        AuthedRequest,
+        aauthenticated_user,
+        acurrent_user,
+        arequest_context,
+        arequest_user,
+        authenticated_user,
+        current_user,
+        request_context,
+        request_user,
+    )
+    from .security.permissions import (
+        AllowAny,
+        Also,
+        BasePermission,
+        DenyAll,
+        DjangoModelPermissions,
+        HasDjangoPermission,
+        IsAuthenticated,
+        IsAuthenticatedOrReadOnly,
+        IsOwner,
+        IsReadOnly,
+        IsStaff,
+        IsSuperuser,
+        as_permission,
+    )
+    from .security.tenancy import MissingTenant, current_tenant
+    from .serialization.schemas import Input, Output, Patch, PatchData, ReadOnly, WriteOnly
+    from .serialization.visibility import FieldVisibility, VisibleTo
+
+_EXPORTS: Final[Mapping[str, str]] = MappingProxyType(
+    {
+        "get_invocation": ".dependencies.instances",
+        "Invocation": ".dependencies.instances",
+        "aauthenticated_user": ".security.auth",
+        "acurrent_user": ".security.auth",
+        "arequest_context": ".security.auth",
+        "arequest_user": ".security.auth",
+        "AuthedRequest": ".security.auth",
+        "authenticated_user": ".security.auth",
+        "current_user": ".security.auth",
+        "request_context": ".security.auth",
+        "request_user": ".security.auth",
+        "conditional": ".http.conditional",
+        "ETag": ".http.conditional",
+        "PreconditionFailed": ".http.conditional",
+        "PreconditionRequired": ".http.conditional",
+        "Controller": ".routing.controller",
+        "ControllerOptions": ".routing.controller",
+        "Scope": ".routing.controller",
+        "AsyncRequestScopeProvider": ".dependencies.container",
+        "AsyncResolver": ".dependencies.container",
+        "Container": ".dependencies.container",
+        "ContainerLike": ".dependencies.container",
+        "Lifetime": ".dependencies.container",
+        "RequestScopeProvider": ".dependencies.container",
+        "Resolver": ".dependencies.container",
+        "ErrorMap": ".http.errors",
+        "AsyncLazyAccessError": ".exceptions",
+        "BlockingCallWarning": ".exceptions",
+        "CircularDependencyError": ".exceptions",
+        "ControllerConfigError": ".exceptions",
+        "DependencyResolutionError": ".exceptions",
+        "MixedPathWarning": ".exceptions",
+        "NinjaDevXError": ".exceptions",
+        "AsyncOperationHook": ".routing.hooks",
+        "get_operation": ".routing.hooks",
+        "LoggingHook": ".routing.hooks",
+        "OperationHook": ".routing.hooks",
+        "OperationInfo": ".routing.hooks",
+        "idempotent": ".idempotency",
+        "Inject": ".dependencies.injection",
+        "Resolve": ".dependencies.injection",
+        "resolve": ".dependencies.injection",
+        "Mount": ".routing.mounting",
+        "mount": ".routing.mounting",
+        "api_operation": ".routing.operations",
+        "async_variant": ".routing.operations",
+        "delete": ".routing.operations",
+        "get": ".routing.operations",
+        "OperationOptions": ".routing.operations",
+        "OperationSpec": ".routing.operations",
+        "patch": ".routing.operations",
+        "post": ".routing.operations",
+        "put": ".routing.operations",
+        "RouteOptions": ".routing.operations",
+        "AllowAny": ".security.permissions",
+        "Also": ".security.permissions",
+        "as_permission": ".security.permissions",
+        "BasePermission": ".security.permissions",
+        "DenyAll": ".security.permissions",
+        "DjangoModelPermissions": ".security.permissions",
+        "HasDjangoPermission": ".security.permissions",
+        "IsAuthenticated": ".security.permissions",
+        "IsAuthenticatedOrReadOnly": ".security.permissions",
+        "IsOwner": ".security.permissions",
+        "IsReadOnly": ".security.permissions",
+        "IsStaff": ".security.permissions",
+        "IsSuperuser": ".security.permissions",
+        "ControllerPlugin": ".routing.plugins",
+        "Input": ".serialization.schemas",
+        "Output": ".serialization.schemas",
+        "Patch": ".serialization.schemas",
+        "PatchData": ".serialization.schemas",
+        "ReadOnly": ".serialization.schemas",
+        "WriteOnly": ".serialization.schemas",
+        "current_tenant": ".security.tenancy",
+        "MissingTenant": ".security.tenancy",
+        "use_case": ".routing.use_cases",
+        "FieldVisibility": ".serialization.visibility",
+        "VisibleTo": ".serialization.visibility",
+    }
+)
+
+__all__ = [
+    "AllowAny",
+    "Also",
+    "AsyncLazyAccessError",
+    "AsyncOperationHook",
+    "AsyncRequestScopeProvider",
+    "AsyncResolver",
+    "AuthedRequest",
+    "BasePermission",
+    "BlockingCallWarning",
+    "CircularDependencyError",
+    "Container",
+    "ContainerLike",
+    "Controller",
+    "ControllerConfigError",
+    "ControllerOptions",
+    "ControllerPlugin",
+    "DenyAll",
+    "DependencyResolutionError",
+    "DjangoModelPermissions",
+    "ETag",
+    "ErrorMap",
+    "FieldVisibility",
+    "HasDjangoPermission",
+    "Inject",
+    "Input",
+    "Invocation",
+    "IsAuthenticated",
+    "IsAuthenticatedOrReadOnly",
+    "IsOwner",
+    "IsReadOnly",
+    "IsStaff",
+    "IsSuperuser",
+    "Lifetime",
+    "LoggingHook",
+    "MissingTenant",
+    "MixedPathWarning",
+    "Mount",
+    "NinjaDevXError",
+    "OperationHook",
+    "OperationInfo",
+    "OperationOptions",
+    "OperationSpec",
+    "Output",
+    "Patch",
+    "PatchData",
+    "PreconditionFailed",
+    "PreconditionRequired",
+    "ReadOnly",
+    "RequestScopeProvider",
+    "Resolve",
+    "Resolver",
+    "RouteOptions",
+    "Scope",
+    "VisibleTo",
+    "WriteOnly",
+    "aauthenticated_user",
+    "acurrent_user",
+    "api_operation",
+    "arequest_context",
+    "arequest_user",
+    "as_permission",
+    "async_variant",
+    "authenticated_user",
+    "conditional",
+    "current_tenant",
+    "current_user",
+    "delete",
+    "get",
+    "get_invocation",
+    "get_operation",
+    "idempotent",
+    "mount",
+    "patch",
+    "post",
+    "put",
+    "request_context",
+    "request_user",
+    "resolve",
+    "use_case",
+]
+
+try:
+    __version__ = version("ninja-devx")
+except PackageNotFoundError:  # pragma: no cover - running from a source tree
+    __version__ = "0.0.1"
+
+
+def __getattr__(name: str) -> object:
+    module = _EXPORTS.get(name)
+    if module is None:
+        raise AttributeError(f"module {__name__!r} has no attribute {name!r}")
+    value: object = getattr(importlib.import_module(module, __name__), name)
+    return value
+
+
+def __dir__() -> list[str]:
+    return sorted(__all__)

ninja_devx/_internal/__init__.py

@@ -0,0 +1 @@
+"""Internal components for ninja-devx."""

ninja_devx/_internal/cache.py

@@ -0,0 +1,16 @@
+"""Class-owned caches that cannot accidentally inherit a parent's resolved values."""
+
+from typing import TypeVar, cast
+
+K = TypeVar("K")
+V = TypeVar("V")
+
+
+def owned_cache(owner: type[object], name: str) -> dict[K, V]:  # pyright: ignore[reportInvalidTypeVarUse]
+    """Keep generated values with their source class, including self-referential types."""
+    attribute = f"__devx_cache_{name}"
+    cache = vars(owner).get(attribute)
+    if cache is None:
+        cache = {}
+        setattr(owner, attribute, cache)
+    return cast("dict[K, V]", cache)

ninja_devx/_internal/compat.py

@@ -0,0 +1,19 @@
+import inspect
+import sys
+from collections.abc import Callable
+
+__all__ = ["signature"]
+
+
+if sys.version_info >= (3, 14):  # pragma: no cover - version specific
+    from annotationlib import Format
+
+    def signature(obj: Callable[..., object]) -> inspect.Signature:
+        """``inspect.signature`` that tolerates annotations referring to undefined names."""
+        return inspect.signature(obj, annotation_format=Format.FORWARDREF)
+
+else:  # pragma: no cover - version specific
+
+    def signature(obj: Callable[..., object]) -> inspect.Signature:
+        """``inspect.signature`` (annotations are never evaluated before Python 3.14)."""
+        return inspect.signature(obj)

ninja_devx/_internal/generics.py

@@ -0,0 +1,130 @@
+"""Resolve generic type parameters of controller classes at registration time.
+
+``class ArticleController(CRUDController[Article, ArticleOut, ArticleIn])`` binds the
+TypeVars used in inherited method annotations and operation options; handlers are
+built with the concrete types so Ninja sees ``payload: ArticleIn``.
+"""
+
+from collections.abc import Mapping
+from types import MappingProxyType
+from typing import Annotated, Generic, TypeVar, cast, get_args, get_origin
+
+from ..exceptions import ControllerConfigError
+from .cache import owned_cache
+
+__all__ = ["LazyAnnotation", "defined_in", "resolve_annotation", "substitute", "type_arguments"]
+
+
+class LazyAnnotation:
+    """``Annotated`` metadata replaced by a concrete annotation when a controller is built.
+
+    ``Annotated[T, marker]`` becomes ``marker.resolve(T, controller)``.
+    """
+
+    def resolve(self, annotation: object, controller: type[object]) -> object:
+        raise NotImplementedError
+
+
+def type_arguments(cls: type[object]) -> Mapping[TypeVar, object]:
+    """Map every TypeVar bound anywhere in ``cls``'s generic ancestry to its argument.
+
+    Cached per class: controllers and services call this on every request.
+    """
+    _type_arguments: dict[type[object], Mapping[TypeVar, object]] = owned_cache(
+        cls, "generics_type_arguments"
+    )
+    cached = _type_arguments.get(cls)
+    if cached is None:
+        computed = _compute_type_arguments(cls)
+        # A class may derive some arguments from others (``AutoCRUDController[Post]``
+        # generates its schemas from the model).
+        derive: object = getattr(cls, "derive_type_arguments", None)
+        if callable(derive):
+            extra = cast("Mapping[TypeVar, object]", derive(MappingProxyType(computed)))
+            computed.update(extra)
+        cached = _type_arguments[cls] = MappingProxyType(computed)
+    return cached
+
+
+def _compute_type_arguments(cls: type[object]) -> dict[TypeVar, object]:
+    mapping: dict[TypeVar, object] = {}
+    # Subclasses come first in the MRO, so their bindings are known before a base
+    # re-parameterizes its own bases with the same TypeVars.
+    for klass in cls.__mro__:
+        bases: tuple[object, ...] = klass.__dict__.get("__orig_bases__", ())
+        for base in bases:
+            origin = get_origin(base)
+            if origin is None or origin is Generic:
+                continue
+            parameters: tuple[object, ...] = getattr(origin, "__parameters__", ())
+            for parameter, argument in zip(parameters, get_args(base), strict=False):
+                if not isinstance(parameter, TypeVar):
+                    continue
+                value = substitute(argument, mapping)
+                if value is parameter:
+                    continue
+                existing = mapping.setdefault(parameter, value)
+                if existing != value and not isinstance(value, TypeVar):
+                    raise ControllerConfigError(
+                        f"{cls.__qualname__}: conflicting arguments for {parameter}: "
+                        f"{existing!r} and {value!r}"
+                    )
+    return mapping
+
+
+def substitute(annotation: object, mapping: Mapping[TypeVar, object]) -> object:
+    """Replace TypeVars in ``annotation`` (``T``, ``list[T]``, ``Annotated[T, ...]``...)."""
+    if isinstance(annotation, TypeVar):
+        return mapping.get(annotation, annotation)
+    parameters: tuple[object, ...] = getattr(annotation, "__parameters__", ())
+    if not parameters or not any(parameter in mapping for parameter in parameters):
+        return annotation
+    arguments = tuple(
+        mapping.get(parameter, parameter) if isinstance(parameter, TypeVar) else parameter
+        for parameter in parameters
+    )
+    try:
+        return annotation[arguments]  # type: ignore[index]  # pyright: ignore[reportIndexIssue, reportUnknownVariableType]
+    except TypeError as exc:
+        raise ControllerConfigError(f"Cannot substitute type arguments in {annotation!r}") from exc
+
+
+def resolve_annotation(
+    annotation: object, mapping: Mapping[TypeVar, object], controller: type[object]
+) -> object:
+    """Substitute TypeVars, then expand ``LazyAnnotation`` markers."""
+    annotation = substitute(annotation, mapping)
+    if get_origin(annotation) is not Annotated:
+        return annotation
+    base, *metadata = get_args(annotation)
+    for index, item in enumerate(metadata):
+        if isinstance(item, LazyAnnotation):
+            resolved = item.resolve(base, controller)
+            rest = [*metadata[:index], *metadata[index + 1 :]]
+            return Annotated[resolved, *rest] if rest else resolved
+    return annotation
+
+
+def find_unbound(annotation: object) -> tuple[TypeVar, ...]:
+    if isinstance(annotation, TypeVar):
+        return (annotation,)
+    parameters: tuple[object, ...] = getattr(annotation, "__parameters__", ())
+    return tuple(parameter for parameter in parameters if isinstance(parameter, TypeVar))
+
+
+def defined_in(
+    cls: type[object], attribute: str, *, through_wrappers: bool = False
+) -> type[object] | None:
+    """The class in ``cls``'s MRO that defines ``attribute``.
+
+    With ``through_wrappers``, classes listing ``attribute`` in their own
+    ``__devx_wraps__`` (mixins that only add behaviour around ``super()``) are skipped.
+    """
+    for klass in cls.__mro__:
+        if attribute not in vars(klass):
+            continue
+        wraps: object = vars(klass).get("__devx_wraps__", ())
+        if through_wrappers and isinstance(wraps, frozenset) and attribute in wraps:
+            continue
+        return klass
+    return None

ninja_devx/_internal/i18n.py

@@ -0,0 +1,14 @@
+"""Translation helpers shared by the package (catalog: ``ninja_devx/locale``)."""
+
+from __future__ import annotations
+
+from django.db.models import Model
+from django.utils.text import capfirst
+from django.utils.translation import gettext as _
+
+__all__ = ["not_found"]
+
+
+def not_found(model: type[Model]) -> str:
+    """``"Article not found"``, with the model's (translated) verbose name."""
+    return _("%(name)s not found") % {"name": capfirst(str(model._meta.verbose_name))}

ninja_devx/_internal/streaming.py

@@ -0,0 +1,154 @@
+"""Preflight and context-preserving cleanup for Ninja 1.x async streaming operations.
+
+Ninja normally starts headers before advancing an async generator. Our operation
+subclass consumes a private readiness marker first. A single producer task owns all
+context managers, including cancellation cleanup; items are pulled only on demand.
+"""
+
+from __future__ import annotations
+
+import asyncio
+import logging
+from collections.abc import AsyncIterator, Callable
+from dataclasses import dataclass
+from typing import cast
+
+from django.http import HttpRequest, HttpResponse, StreamingHttpResponse
+from ninja.operation import AsyncOperation, Operation
+
+from ..exceptions import ControllerConfigError
+
+
+@dataclass(frozen=True, slots=True)
+class StreamReady:
+    response: HttpResponse | None = None
+
+
+@dataclass(frozen=True, slots=True)
+class _Item:
+    value: object = None
+    done: bool = False
+
+
+class PreparedStream:
+    def __init__(
+        self, source: AsyncIterator[object], *, on_cancel: Callable[[], None] | None = None
+    ) -> None:
+        self.source = source
+        self.on_cancel = on_cancel
+        self.loop = asyncio.get_running_loop()
+        self.ready: asyncio.Future[StreamReady] = self.loop.create_future()
+        self.demand: asyncio.Queue[asyncio.Future[_Item]] = asyncio.Queue(maxsize=1)
+        self.task = self.loop.create_task(self._serve())
+        self.task.add_done_callback(self._cleanup_result)
+
+    @staticmethod
+    def _cleanup_result(task: asyncio.Task[None]) -> None:
+        if not task.cancelled() and (error := task.exception()) is not None:
+            logging.getLogger("ninja_devx").error(
+                "Async stream cleanup failed", exc_info=(type(error), error, error.__traceback__)
+            )
+
+    async def _serve(self) -> None:
+        current: asyncio.Future[_Item] | None = None
+        try:
+            marker = await anext(self.source)
+            if not isinstance(marker, StreamReady):
+                raise RuntimeError("Async stream did not provide its preflight marker")
+            self.ready.set_result(marker)
+            if marker.response is not None:
+                return
+            while True:
+                current = await self.demand.get()
+                try:
+                    value = await anext(self.source)
+                except StopAsyncIteration:
+                    if not current.done():
+                        current.set_result(_Item(done=True))
+                    return
+                if not current.done():
+                    current.set_result(_Item(value))
+                current = None
+        except BaseException as exc:
+            waiting: asyncio.Future[StreamReady] | asyncio.Future[_Item] | None = (
+                self.ready if not self.ready.done() else current
+            )
+            if waiting is not None and not waiting.done():
+                if isinstance(exc, asyncio.CancelledError):
+                    waiting.cancel()
+                else:
+                    waiting.set_exception(exc)
+        finally:
+            close = getattr(self.source, "aclose", None)
+            if close is not None:
+                await close()
+
+    def __aiter__(self) -> PreparedStream:
+        return self
+
+    async def __anext__(self) -> object:
+        if self.task.done():
+            raise StopAsyncIteration
+        result: asyncio.Future[_Item] = self.loop.create_future()
+        try:
+            await self.demand.put(result)
+            item = await result
+            if item.done:
+                raise StopAsyncIteration
+            return item.value
+        except asyncio.CancelledError:
+            try:
+                await self.aclose()
+            finally:
+                # Django 4.2's ASGI send path does not close the request when cancelled.
+                # File cleanup is idempotent on newer Django versions as well.
+                if self.on_cancel is not None:
+                    self.on_cancel()
+            raise
+        except BaseException:
+            await self.aclose()
+            raise
+
+    async def aclose(self) -> None:
+        if not self.task.done():
+            self.task.cancel()
+        await asyncio.gather(self.task, return_exceptions=True)
+
+    def close(self) -> None:
+        """Django closes responses synchronously, sometimes from a worker thread."""
+        if not self.task.done() and not self.loop.is_closed():
+            self.loop.call_soon_threadsafe(self.task.cancel)
+
+
+class PreflightAsyncOperation(AsyncOperation):
+    async def _async_stream_response(  # type: ignore[override]  # pyright: ignore[reportIncompatibleMethodOverride]
+        self, request: HttpRequest, generator: object, temporal_response: HttpResponse
+    ) -> HttpResponse | StreamingHttpResponse:
+        stream = PreparedStream(cast("AsyncIterator[object]", generator), on_cancel=request.close)
+        try:
+            ready = await stream.ready
+            if ready.response is not None:
+                await stream.aclose()
+                return ready.response
+            response = await super()._async_stream_response(request, stream, temporal_response)
+        except BaseException:
+            await stream.aclose()
+            raise
+        original_close = response.close
+
+        def close_response() -> None:
+            stream.close()
+            original_close()
+
+        response.close = close_response  # type: ignore[method-assign]
+        return response
+
+
+def enable_preflight(operation: Operation) -> None:
+    """Adapt only our operation; Ninja's clone preserves its concrete class."""
+    if (
+        not isinstance(operation, AsyncOperation)
+        or getattr(operation, "stream_format", None) is None
+    ):
+        raise ControllerConfigError("Async generators require a Ninja streaming response schema")
+    operation.__class__ = PreflightAsyncOperation

ninja_devx/_internal/types.py

@@ -0,0 +1,79 @@
+"""Type aliases describing what Django Ninja accepts, without ``typing.Any``."""
+
+from collections.abc import Callable, Iterable, Mapping, Sequence
+from types import GenericAlias, MappingProxyType, UnionType
+from typing import Final, TypeAlias
+
+from django.http import HttpRequest
+from ninja.constants import NOT_SET_TYPE
+from ninja.security.base import AuthBase
+from ninja.throttling import BaseThrottle
+
+__all__ = [
+    "AuthCallable",
+    "AuthSpec",
+    "JSONValue",
+    "MethodFunction",
+    "ResponseSchema",
+    "ResponseSpec",
+    "ThrottleSpec",
+    "ViewDecorator",
+    "ViewFunction",
+    "did_you_mean",
+    "status_phrase",
+]
+
+JSONValue: TypeAlias = (
+    str | int | float | bool | Sequence["JSONValue"] | Mapping[str, "JSONValue"] | None
+)
+
+AuthCallable: TypeAlias = Callable[[HttpRequest], object]
+"""A callable returning a truthy value (stored as ``request.auth``) when authenticated."""
+
+AuthSpec: TypeAlias = (
+    AuthBase | AuthCallable | Sequence[AuthBase | AuthCallable] | NOT_SET_TYPE | None
+)
+"""``None`` disables authentication, ``NOT_SET`` inherits it."""
+
+ThrottleSpec: TypeAlias = BaseThrottle | Sequence[BaseThrottle] | NOT_SET_TYPE
+
+ResponseSchema: TypeAlias = type[object] | UnionType | GenericAlias | None
+"""A schema class, ``list[Schema]``, ``A | B`` or ``None`` (empty body)."""
+
+ResponseSpec: TypeAlias = (
+    ResponseSchema | Mapping[int | frozenset[int], ResponseSchema] | NOT_SET_TYPE
+)
+"""A single schema or a mapping of status codes (``ninja.responses.codes_4xx``...) to schemas."""
+
+MethodFunction: TypeAlias = Callable[..., object]
+"""An unbound controller method."""
+
+ViewFunction: TypeAlias = Callable[..., object]
+ViewDecorator: TypeAlias = Callable[[ViewFunction], ViewFunction]
+"""A Django Ninja view decorator such as ``ninja.pagination.paginate(...)``."""
+
+
+_PHRASES: Final[Mapping[int, str]] = MappingProxyType(
+    {
+        413: "Content Too Large",
+        422: "Unprocessable Content",
+    }
+)
+
+
+def did_you_mean(name: str, candidates: Iterable[str]) -> str:
+    """`` Did you mean 'title'?`` when a close candidate exists, else an empty string."""
+    import difflib
+
+    matches = difflib.get_close_matches(name, list(candidates), n=1, cutoff=0.6)
+    return f" Did you mean {matches[0]!r}?" if matches else ""
+
+
+def status_phrase(status: int) -> str:
+    """The RFC 9110 reason phrase, the same on every Python version (3.13 renamed some)."""
+    from http import HTTPStatus
+
+    try:
+        return _PHRASES.get(status) or HTTPStatus(status).phrase
+    except ValueError:
+        return "Error"