ophyd-async 0.5.2__py3-none-any.whl → 0.6.0__py3-none-any.whl

ophyd_async/core/_signal.py

@@ -2,22 +2,10 @@ from __future__ import annotations
 
 import asyncio
 import functools
-from typing import (
-    Any,
-    AsyncGenerator,
-    Callable,
-    Dict,
-    Generic,
-    Mapping,
-    Optional,
-    Tuple,
-    Type,
-    TypeVar,
-    Union,
-)
+from collections.abc import AsyncGenerator, Callable, Mapping
+from typing import Any, Generic, TypeVar, cast
 
 from bluesky.protocols import (
-    DataKey,
     Locatable,
     Location,
     Movable,
@@ -25,6 +13,7 @@ from bluesky.protocols import (
     Status,
     Subscribable,
 )
+from event_model import DataKey
 
 from ._device import Device
 from ._mock_signal_backend import MockSignalBackend
@@ -32,7 +21,7 @@ from ._protocol import AsyncConfigurable, AsyncReadable, AsyncStageable
 from ._signal_backend import SignalBackend
 from ._soft_signal_backend import SignalMetadata, SoftSignalBackend
 from ._status import AsyncStatus
-from ._utils import DEFAULT_TIMEOUT, CalculatableTimeout, CalculateTimeout, Callback, T
+from ._utils import CALCULATE_TIMEOUT, DEFAULT_TIMEOUT, CalculatableTimeout, Callback, T
 
 S = TypeVar("S")
 
@@ -45,13 +34,26 @@ def _add_timeout(func):
     return wrapper
 
 
+def _fail(*args, **kwargs):
+    raise RuntimeError("Signal has not been supplied a backend yet")
+
+
+class DisconnectedBackend(SignalBackend):
+    source = connect = put = get_datakey = get_reading = get_value = get_setpoint = (
+        set_callback
+    ) = _fail
+
+
+DISCONNECTED_BACKEND = DisconnectedBackend()
+
+
 class Signal(Device, Generic[T]):
     """A Device with the concept of a value, with R, RW, W and X flavours"""
 
     def __init__(
         self,
-        backend: Optional[SignalBackend[T]] = None,
-        timeout: Optional[float] = DEFAULT_TIMEOUT,
+        backend: SignalBackend[T] = DISCONNECTED_BACKEND,
+        timeout: float | None = DEFAULT_TIMEOUT,
         name: str = "",
     ) -> None:
         self._timeout = timeout
@@ -63,10 +65,13 @@ class Signal(Device, Generic[T]):
         mock=False,
         timeout=DEFAULT_TIMEOUT,
         force_reconnect: bool = False,
-        backend: Optional[SignalBackend[T]] = None,
+        backend: SignalBackend[T] | None = None,
     ):
         if backend:
-            if self._backend and backend is not self._backend:
+            if (
+                self._backend is not DISCONNECTED_BACKEND
+                and backend is not self._backend
+            ):
                 raise ValueError("Backend at connection different from previous one.")
 
             self._backend = backend
@@ -114,10 +119,10 @@ class _SignalCache(Generic[T]):
     def __init__(self, backend: SignalBackend[T], signal: Signal):
         self._signal = signal
         self._staged = False
-        self._listeners: Dict[Callback, bool] = {}
+        self._listeners: dict[Callback, bool] = {}
         self._valid = asyncio.Event()
-        self._reading: Optional[Reading] = None
-        self._value: Optional[T] = None
+        self._reading: Reading | None = None
+        self._value: T | None = None
 
         self.backend = backend
         signal.log.debug(f"Making subscription on source {signal.source}")
@@ -171,11 +176,9 @@ class _SignalCache(Generic[T]):
 class SignalR(Signal[T], AsyncReadable, AsyncStageable, Subscribable):
     """Signal that can be read from and monitored"""
 
-    _cache: Optional[_SignalCache] = None
+    _cache: _SignalCache | None = None
 
-    def _backend_or_cache(
-        self, cached: Optional[bool]
-    ) -> Union[_SignalCache, SignalBackend]:
+    def _backend_or_cache(self, cached: bool | None) -> _SignalCache | SignalBackend:
         # If cached is None then calculate it based on whether we already have a cache
         if cached is None:
             cached = self._cache is not None
@@ -196,17 +199,17 @@ class SignalR(Signal[T], AsyncReadable, AsyncStageable, Subscribable):
             self._cache = None
 
     @_add_timeout
-    async def read(self, cached: Optional[bool] = None) -> Dict[str, Reading]:
+    async def read(self, cached: bool | None = None) -> dict[str, Reading]:
         """Return a single item dict with the reading in it"""
         return {self.name: await self._backend_or_cache(cached).get_reading()}
 
     @_add_timeout
-    async def describe(self) -> Dict[str, DataKey]:
+    async def describe(self) -> dict[str, DataKey]:
         """Return a single item dict with the descriptor in it"""
         return {self.name: await self._backend.get_datakey(self.source)}
 
     @_add_timeout
-    async def get_value(self, cached: Optional[bool] = None) -> T:
+    async def get_value(self, cached: bool | None = None) -> T:
         """The current value"""
         value = await self._backend_or_cache(cached).get_value()
         self.log.debug(f"get_value() on source {self.source} returned {value}")
@@ -216,7 +219,7 @@ class SignalR(Signal[T], AsyncReadable, AsyncStageable, Subscribable):
         """Subscribe to updates in value of a device"""
         self._get_cache().subscribe(function, want_value=True)
 
-    def subscribe(self, function: Callback[Dict[str, Reading]]) -> None:
+    def subscribe(self, function: Callback[dict[str, Reading]]) -> None:
         """Subscribe to updates in the reading"""
         self._get_cache().subscribe(function, want_value=False)
 
@@ -239,10 +242,10 @@ class SignalW(Signal[T], Movable):
     """Signal that can be set"""
 
     def set(
-        self, value: T, wait=True, timeout: CalculatableTimeout = CalculateTimeout
+        self, value: T, wait=True, timeout: CalculatableTimeout = CALCULATE_TIMEOUT
     ) -> AsyncStatus:
         """Set the value and return a status saying when it's done"""
-        if timeout is CalculateTimeout:
+        if timeout is CALCULATE_TIMEOUT:
             timeout = self._timeout
 
         async def do_set():
@@ -270,18 +273,18 @@ class SignalX(Signal):
     """Signal that puts the default value"""
 
     def trigger(
-        self, wait=True, timeout: CalculatableTimeout = CalculateTimeout
+        self, wait=True, timeout: CalculatableTimeout = CALCULATE_TIMEOUT
     ) -> AsyncStatus:
         """Trigger the action and return a status saying when it's done"""
-        if timeout is CalculateTimeout:
+        if timeout is CALCULATE_TIMEOUT:
             timeout = self._timeout
         coro = self._backend.put(None, wait=wait, timeout=timeout)
         return AsyncStatus(coro)
 
 
 def soft_signal_rw(
-    datatype: Optional[Type[T]] = None,
-    initial_value: Optional[T] = None,
+    datatype: type[T] | None = None,
+    initial_value: T | None = None,
     name: str = "",
     units: str | None = None,
     precision: int | None = None,
@@ -298,12 +301,12 @@ def soft_signal_rw(
 
 
 def soft_signal_r_and_setter(
-    datatype: Optional[Type[T]] = None,
-    initial_value: Optional[T] = None,
+    datatype: type[T] | None = None,
+    initial_value: T | None = None,
     name: str = "",
     units: str | None = None,
     precision: int | None = None,
-) -> Tuple[SignalR[T], Callable[[T], None]]:
+) -> tuple[SignalR[T], Callable[[T], None]]:
     """Returns a tuple of a read-only Signal and a callable through
     which the signal can be internally modified within the device.
     May pass metadata, which are propagated into describe.
@@ -316,9 +319,7 @@ def soft_signal_r_and_setter(
     return (signal, backend.set_value)
 
 
-def _generate_assert_error_msg(
-    name: str, expected_result: str, actual_result: str
-) -> str:
+def _generate_assert_error_msg(name: str, expected_result, actual_result) -> str:
     WARNING = "\033[93m"
     FAIL = "\033[91m"
     ENDC = "\033[0m"
@@ -484,14 +485,14 @@ async def observe_value(
                 else:
                     break
             else:
-                yield item
+                yield cast(T, item)
     finally:
         signal.clear_sub(q.put_nowait)
 
 
 class _ValueChecker(Generic[T]):
     def __init__(self, matcher: Callable[[T], bool], matcher_name: str):
-        self._last_value: Optional[T] = None
+        self._last_value: T | None = None
         self._matcher = matcher
         self._matcher_name = matcher_name
 
@@ -501,11 +502,11 @@ class _ValueChecker(Generic[T]):
             if self._matcher(value):
                 return
 
-    async def wait_for_value(self, signal: SignalR[T], timeout: Optional[float]):
+    async def wait_for_value(self, signal: SignalR[T], timeout: float | None):
         try:
             await asyncio.wait_for(self._wait_for_value(signal), timeout)
         except asyncio.TimeoutError as e:
-            raise TimeoutError(
+            raise asyncio.TimeoutError(
                 f"{signal.name} didn't match {self._matcher_name} in {timeout}s, "
                 f"last value {self._last_value!r}"
             ) from e
@@ -513,8 +514,8 @@ class _ValueChecker(Generic[T]):
 
 async def wait_for_value(
     signal: SignalR[T],
-    match: Union[T, Callable[[T], bool]],
-    timeout: Optional[float],
+    match: T | Callable[[T], bool],
+    timeout: float | None,
 ):
     """Wait for a signal to have a matching value.
 
@@ -540,7 +541,7 @@ async def wait_for_value(
         wait_for_value(device.num_captured, lambda v: v > 45, timeout=1)
     """
     if callable(match):
-        checker = _ValueChecker(match, match.__name__)
+        checker = _ValueChecker(match, match.__name__)  # type: ignore
     else:
         checker = _ValueChecker(lambda v: v == match, repr(match))
     await checker.wait_for_value(signal, timeout)
@@ -552,7 +553,7 @@ async def set_and_wait_for_other_value(
     read_signal: SignalR[S],
     read_value: S,
     timeout: float = DEFAULT_TIMEOUT,
-    set_timeout: Optional[float] = None,
+    set_timeout: float | None = None,
 ) -> AsyncStatus:
     """Set a signal and monitor another signal until it has the specified value.
 
@@ -610,7 +611,7 @@ async def set_and_wait_for_value(
     signal: SignalRW[T],
     value: T,
     timeout: float = DEFAULT_TIMEOUT,
-    status_timeout: Optional[float] = None,
+    status_timeout: float | None = None,
 ) -> AsyncStatus:
     """Set a signal and monitor it until it has that value.
 

ophyd_async/core/_signal_backend.py

@@ -1,7 +1,15 @@
 from abc import abstractmethod
-from typing import TYPE_CHECKING, ClassVar, Generic, Literal, Optional, Tuple, Type
+from typing import (
+    TYPE_CHECKING,
+    Any,
+    ClassVar,
+    Generic,
+    Literal,
+)
+
+from bluesky.protocols import Reading
+from event_model import DataKey
 
-from ._protocol import DataKey, Reading
 from ._utils import DEFAULT_TIMEOUT, ReadingValueCallback, T
 
 
@@ -9,7 +17,12 @@ class SignalBackend(Generic[T]):
     """A read/write/monitor backend for a Signals"""
 
     #: Datatype of the signal value
-    datatype: Optional[Type[T]] = None
+    datatype: type[T] | None = None
+
+    @classmethod
+    @abstractmethod
+    def datatype_allowed(cls, dtype: Any) -> bool:
+        """Check if a given datatype is acceptable for this signal backend."""
 
     #: Like ca://PV_PREFIX:SIGNAL
     @abstractmethod
@@ -22,7 +35,7 @@ class SignalBackend(Generic[T]):
         """Connect to underlying hardware"""
 
     @abstractmethod
-    async def put(self, value: Optional[T], wait=True, timeout=None):
+    async def put(self, value: T | None, wait=True, timeout=None):
         """Put a value to the PV, if wait then wait for completion for up to timeout"""
 
     @abstractmethod
@@ -42,14 +55,14 @@ class SignalBackend(Generic[T]):
         """The point that a signal was requested to move to."""
 
     @abstractmethod
-    def set_callback(self, callback: Optional[ReadingValueCallback[T]]) -> None:
+    def set_callback(self, callback: ReadingValueCallback[T] | None) -> None:
         """Observe changes to the current value, timestamp and severity"""
 
 
 class _RuntimeSubsetEnumMeta(type):
     def __str__(cls):
         if hasattr(cls, "choices"):
-            return f"SubsetEnum{list(cls.choices)}"
+            return f"SubsetEnum{list(cls.choices)}"  # type: ignore
         return "SubsetEnum"
 
     def __getitem__(cls, _choices):
@@ -72,7 +85,7 @@ class _RuntimeSubsetEnumMeta(type):
 
 
 class RuntimeSubsetEnum(metaclass=_RuntimeSubsetEnumMeta):
-    choices: ClassVar[Tuple[str, ...]]
+    choices: ClassVar[tuple[str, ...]]
 
     def __init__(self):
         raise RuntimeError("SubsetEnum cannot be instantiated")

ophyd_async/core/_soft_signal_backend.py

@@ -4,16 +4,28 @@ import inspect
 import time
 from collections import abc
 from enum import Enum
-from typing import Dict, Generic, Optional, Tuple, Type, Union, cast, get_origin
+from typing import Generic, cast, get_origin
 
 import numpy as np
-from bluesky.protocols import DataKey, Dtype, Reading
+from bluesky.protocols import Reading
+from event_model import DataKey
+from event_model.documents.event_descriptor import Dtype
+from pydantic import BaseModel
 from typing_extensions import TypedDict
 
-from ._signal_backend import RuntimeSubsetEnum, SignalBackend
-from ._utils import DEFAULT_TIMEOUT, ReadingValueCallback, T, get_dtype
-
-primitive_dtypes: Dict[type, Dtype] = {
+from ._signal_backend import (
+    RuntimeSubsetEnum,
+    SignalBackend,
+)
+from ._utils import (
+    DEFAULT_TIMEOUT,
+    ReadingValueCallback,
+    T,
+    get_dtype,
+    is_pydantic_model,
+)
+
+primitive_dtypes: dict[type, Dtype] = {
     str: "string",
     int: "integer",
     float: "number",
@@ -22,8 +34,8 @@ primitive_dtypes: Dict[type, Dtype] = {
 
 
 class SignalMetadata(TypedDict):
-    units: str | None = None
-    precision: int | None = None
+    units: str | None
+    precision: int | None
 
 
 class SoftConverter(Generic[T]):
@@ -41,7 +53,7 @@ class SoftConverter(Generic[T]):
         )
 
     def get_datakey(self, source: str, value, **metadata) -> DataKey:
-        dk = {"source": source, "shape": [], **metadata}
+        dk: DataKey = {"source": source, "shape": [], **metadata}  # type: ignore
         dtype = type(value)
         if np.issubdtype(dtype, np.integer):
             dtype = int
@@ -51,13 +63,14 @@ class SoftConverter(Generic[T]):
             dtype in primitive_dtypes
         ), f"invalid converter for value of type {type(value)}"
         dk["dtype"] = primitive_dtypes[dtype]
+        # type ignore until https://github.com/bluesky/event-model/issues/308
         try:
-            dk["dtype_numpy"] = np.dtype(dtype).descr[0][1]
+            dk["dtype_numpy"] = np.dtype(dtype).descr[0][1]  # type: ignore
         except TypeError:
-            dk["dtype_numpy"] = ""
+            dk["dtype_numpy"] = ""  # type: ignore
         return dk
 
-    def make_initial_value(self, datatype: Optional[Type[T]]) -> T:
+    def make_initial_value(self, datatype: type[T] | None) -> T:
         if datatype is None:
             return cast(T, None)
 
@@ -76,12 +89,12 @@ class SoftArrayConverter(SoftConverter):
         return {
             "source": source,
             "dtype": "array",
-            "dtype_numpy": dtype_numpy,
+            "dtype_numpy": dtype_numpy,  # type: ignore
             "shape": [len(value)],
             **metadata,
         }
 
-    def make_initial_value(self, datatype: Optional[Type[T]]) -> T:
+    def make_initial_value(self, datatype: type[T] | None) -> T:
         if datatype is None:
             return cast(T, None)
 
@@ -92,28 +105,29 @@ class SoftArrayConverter(SoftConverter):
 
 
 class SoftEnumConverter(SoftConverter):
-    choices: Tuple[str, ...]
+    choices: tuple[str, ...]
 
-    def __init__(self, datatype: Union[RuntimeSubsetEnum, Enum]):
-        if issubclass(datatype, Enum):
+    def __init__(self, datatype: RuntimeSubsetEnum | type[Enum]):
+        if issubclass(datatype, Enum):  # type: ignore
             self.choices = tuple(v.value for v in datatype)
         else:
             self.choices = datatype.choices
 
-    def write_value(self, value: Union[Enum, str]) -> str:
-        return value
+    def write_value(self, value: Enum | str) -> str:
+        return value  # type: ignore
 
     def get_datakey(self, source: str, value, **metadata) -> DataKey:
         return {
             "source": source,
             "dtype": "string",
-            "dtype_numpy": "|S40",
+            # type ignore until https://github.com/bluesky/event-model/issues/308
+            "dtype_numpy": "|S40",  # type: ignore
             "shape": [],
             "choices": self.choices,
             **metadata,
         }
 
-    def make_initial_value(self, datatype: Optional[Type[T]]) -> T:
+    def make_initial_value(self, datatype: type[T] | None) -> T:
         if datatype is None:
             return cast(T, None)
 
@@ -122,6 +136,16 @@ class SoftEnumConverter(SoftConverter):
         return cast(T, self.choices[0])
 
 
+class SoftPydanticModelConverter(SoftConverter):
+    def __init__(self, datatype: type[BaseModel]):
+        self.datatype = datatype
+
+    def write_value(self, value):
+        if isinstance(value, dict):
+            return self.datatype(**value)
+        return value
+
+
 def make_converter(datatype):
     is_array = get_dtype(datatype) is not None
     is_sequence = get_origin(datatype) == abc.Sequence
@@ -132,7 +156,9 @@ def make_converter(datatype):
     if is_array or is_sequence:
         return SoftArrayConverter()
     if is_enum:
-        return SoftEnumConverter(datatype)
+        return SoftEnumConverter(datatype)  # type: ignore
+    if is_pydantic_model(datatype):
+        return SoftPydanticModelConverter(datatype)  # type: ignore
 
     return SoftConverter()
 
@@ -141,15 +167,19 @@ class SoftSignalBackend(SignalBackend[T]):
     """An backend to a soft Signal, for test signals see ``MockSignalBackend``."""
 
     _value: T
-    _initial_value: Optional[T]
+    _initial_value: T | None
     _timestamp: float
     _severity: int
 
+    @classmethod
+    def datatype_allowed(cls, dtype: type) -> bool:
+        return True  # Any value allowed in a soft signal
+
     def __init__(
         self,
-        datatype: Optional[Type[T]],
-        initial_value: Optional[T] = None,
-        metadata: SignalMetadata = None,
+        datatype: type[T] | None,
+        initial_value: T | None = None,
+        metadata: SignalMetadata = None,  # type: ignore
     ) -> None:
         self.datatype = datatype
         self._initial_value = initial_value
@@ -158,11 +188,11 @@ class SoftSignalBackend(SignalBackend[T]):
         if self._initial_value is None:
             self._initial_value = self.converter.make_initial_value(self.datatype)
         else:
-            self._initial_value = self.converter.write_value(self._initial_value)
+            self._initial_value = self.converter.write_value(self._initial_value)  # type: ignore
 
-        self.callback: Optional[ReadingValueCallback[T]] = None
+        self.callback: ReadingValueCallback[T] | None = None
         self._severity = 0
-        self.set_value(self._initial_value)
+        self.set_value(self._initial_value)  # type: ignore
 
     def source(self, name: str) -> str:
         return f"soft://{name}"
@@ -171,14 +201,14 @@ class SoftSignalBackend(SignalBackend[T]):
         """Connection isn't required for soft signals."""
         pass
 
-    async def put(self, value: Optional[T], wait=True, timeout=None):
+    async def put(self, value: T | None, wait=True, timeout=None):
         write_value = (
             self.converter.write_value(value)
             if value is not None
             else self._initial_value
         )
 
-        self.set_value(write_value)
+        self.set_value(write_value)  # type: ignore
 
     def set_value(self, value: T):
         """Method to bypass asynchronous logic."""
@@ -204,7 +234,7 @@ class SoftSignalBackend(SignalBackend[T]):
         """For a soft signal, the setpoint and readback values are the same."""
         return await self.get_value()
 
-    def set_callback(self, callback: Optional[ReadingValueCallback[T]]) -> None:
+    def set_callback(self, callback: ReadingValueCallback[T] | None) -> None:
         if callback:
             assert not self.callback, "Cannot set a callback when one is already set"
             reading: Reading = self.converter.reading(

ophyd_async/core/_status.py

@@ -3,14 +3,10 @@
 import asyncio
 import functools
 import time
+from collections.abc import AsyncIterator, Callable, Coroutine
 from dataclasses import asdict, replace
 from typing import (
-    AsyncIterator,
-    Awaitable,
-    Callable,
     Generic,
-    Optional,
-    Type,
     TypeVar,
     cast,
 )
@@ -27,7 +23,7 @@ WAS = TypeVar("WAS", bound="WatchableAsyncStatus")
 class AsyncStatusBase(Status):
     """Convert asyncio awaitable to bluesky Status interface"""
 
-    def __init__(self, awaitable: Awaitable):
+    def __init__(self, awaitable: Coroutine | asyncio.Task):
         if isinstance(awaitable, asyncio.Task):
             self.task = awaitable
         else:
@@ -86,8 +82,10 @@ class AsyncStatusBase(Status):
 
 
 class AsyncStatus(AsyncStatusBase):
+    """Convert asyncio awaitable to bluesky Status interface"""
+
     @classmethod
-    def wrap(cls: Type[AS], f: Callable[P, Awaitable]) -> Callable[P, AS]:
+    def wrap(cls: type[AS], f: Callable[P, Coroutine]) -> Callable[P, AS]:
         """Wrap an async function in an AsyncStatus."""
 
         @functools.wraps(f)
@@ -131,7 +129,7 @@ class WatchableAsyncStatus(AsyncStatusBase, Generic[T]):
 
     @classmethod
     def wrap(
-        cls: Type[WAS],
+        cls: type[WAS],
         f: Callable[P, AsyncIterator[WatcherUpdate[T]]],
     ) -> Callable[P, WAS]:
         """Wrap an AsyncIterator in a WatchableAsyncStatus."""
@@ -144,7 +142,7 @@ class WatchableAsyncStatus(AsyncStatusBase, Generic[T]):
 
 
 @AsyncStatus.wrap
-async def completed_status(exception: Optional[Exception] = None):
+async def completed_status(exception: Exception | None = None):
     if exception:
         raise exception
     return None

ophyd_async/core/_table.py

@@ -0,0 +1,63 @@
+from typing import TypeVar
+
+import numpy as np
+from pydantic import BaseModel, ConfigDict, model_validator
+
+TableSubclass = TypeVar("TableSubclass", bound="Table")
+
+
+class Table(BaseModel):
+    """An abstraction of a Table of str to numpy array."""
+
+    model_config = ConfigDict(validate_assignment=True, strict=False)
+
+    @staticmethod
+    def row(cls: type[TableSubclass], **kwargs) -> TableSubclass:  # type: ignore
+        arrayified_kwargs = {
+            field_name: np.concatenate(
+                (
+                    (default_arr := field_value.default_factory()),  # type: ignore
+                    np.array([kwargs[field_name]], dtype=default_arr.dtype),
+                )
+            )
+            for field_name, field_value in cls.model_fields.items()
+        }
+        return cls(**arrayified_kwargs)
+
+    def __add__(self, right: TableSubclass) -> TableSubclass:
+        """Concatenate the arrays in field values."""
+
+        assert type(right) is type(self), (
+            f"{right} is not a `Table`, or is not the same "
+            f"type of `Table` as {self}."
+        )
+
+        return type(right)(
+            **{
+                field_name: np.concatenate(
+                    (getattr(self, field_name), getattr(right, field_name))
+                )
+                for field_name in self.model_fields
+            }
+        )
+
+    @model_validator(mode="after")
+    def validate_arrays(self) -> "Table":
+        first_length = len(next(iter(self))[1])
+        assert all(
+            len(field_value) == first_length for _, field_value in self
+        ), "Rows should all be of equal size."
+
+        if not all(
+            np.issubdtype(
+                self.model_fields[field_name].default_factory().dtype,  # type: ignore
+                field_value.dtype,
+            )
+            for field_name, field_value in self
+        ):
+            raise ValueError(
+                f"Cannot construct a `{type(self).__name__}`, "
+                "some rows have incorrect types."
+            )
+
+        return self