omlish 0.0.0.dev423__py3-none-any.whl → 0.0.0.dev484__py3-none-any.whl

omlish/marshal/objects/dataclasses.py

@@ -11,13 +11,14 @@ from ... import dataclasses as dc
 from ... import lang
 from ... import reflect as rfl
 from ...lite import marshal as lm
-from ..base.contexts import MarshalContext
-from ..base.contexts import UnmarshalContext
+from ..base.contexts import MarshalFactoryContext
+from ..base.contexts import UnmarshalFactoryContext
+from ..base.errors import UnhandledTypeError
 from ..base.options import Option
 from ..base.types import Marshaler
+from ..base.types import MarshalerFactory
 from ..base.types import Unmarshaler
-from ..factories.simple import SimpleMarshalerFactory
-from ..factories.simple import SimpleUnmarshalerFactory
+from ..base.types import UnmarshalerFactory
 from ..naming import Naming
 from ..naming import translate_name
 from .marshal import ObjectMarshaler
@@ -159,19 +160,37 @@ def get_dataclass_field_infos(
     return FieldInfos(ret)
 
 
-def _make_field_obj(
-        ctx,
-        ty,
-        obj,
-        fac,
-        fac_attr,
+##
+
+
+def _make_field_marshal_obj(
+        ctx: MarshalFactoryContext,
+        ty: ta.Any,
+        obj: Marshaler | None,
+        fac: MarshalerFactory | None,
 ):
     if obj is not None:
         return obj
     if fac is not None:
-        return getattr(fac, fac_attr)(ctx, ty)
-    return ctx.make(ty)
+        if (m := fac.make_marshaler(ctx, ty)) is None:
+            raise UnhandledTypeError(ty)
+        return m()
+    return ctx.make_marshaler(ty)
+
 
+def _make_field_unmarshal_obj(
+        ctx: UnmarshalFactoryContext,
+        ty: ta.Any,
+        obj: Unmarshaler | None,
+        fac: UnmarshalerFactory | None,
+):
+    if obj is not None:
+        return obj
+    if fac is not None:
+        if (m := fac.make_unmarshaler(ctx, ty)) is None:
+            raise UnhandledTypeError(ty)
+        return m()
+    return ctx.make_unmarshaler(ty)
 
 ##
 
@@ -200,119 +219,123 @@ def _type_or_generic_base(rty: rfl.Type) -> type | None:
         return None
 
 
-class DataclassMarshalerFactory(AbstractDataclassFactory, SimpleMarshalerFactory):
-    def guard(self, ctx: MarshalContext, rty: rfl.Type) -> bool:
-        return (
+class DataclassMarshalerFactory(AbstractDataclassFactory, MarshalerFactory):
+    def make_marshaler(self, ctx: MarshalFactoryContext, rty: rfl.Type) -> ta.Callable[[], Marshaler] | None:
+        if not (
             (ty := _type_or_generic_base(rty)) is not None and
             dc.is_dataclass(ty) and
             not lang.is_abstract_class(ty)
-        )
+        ):
+            return None
+
+        def inner() -> Marshaler:
+            ty = check.isinstance(_type_or_generic_base(rty), type)
+            check.state(dc.is_dataclass(ty))
+            check.state(not lang.is_abstract_class(ty))
+
+            dc_md = self._get_metadata(ty)
+            fis = self._get_field_infos(ty, ctx.options)
+
+            fields = [
+                (
+                    fi,
+                    _make_field_marshal_obj(
+                        ctx,
+                        fi.type,
+                        fi.metadata.marshaler,
+                        fi.metadata.marshaler_factory,
+                    ),
+                )
+                for fi in fis
+                if fi.name not in dc_md.specials.set
+            ]
 
-    def fn(self, ctx: MarshalContext, rty: rfl.Type) -> Marshaler:
-        ty = check.isinstance(_type_or_generic_base(rty), type)
-        check.state(dc.is_dataclass(ty))
-        check.state(not lang.is_abstract_class(ty))
-
-        dc_md = self._get_metadata(ty)
-        fis = self._get_field_infos(ty, ctx.options)
-
-        fields = [
-            (
-                fi,
-                _make_field_obj(
-                    ctx,
-                    fi.type,
-                    fi.metadata.marshaler,
-                    fi.metadata.marshaler_factory,
-                    'make_marshaler',
-                ),
+            return ObjectMarshaler(
+                fields,
+                specials=dc_md.specials,
             )
-            for fi in fis
-            if fi.name not in dc_md.specials.set
-        ]
 
-        return ObjectMarshaler(
-            fields,
-            specials=dc_md.specials,
-        )
+        return inner
 
 
 ##
 
 
-class DataclassUnmarshalerFactory(AbstractDataclassFactory, SimpleUnmarshalerFactory):
-    def guard(self, ctx: UnmarshalContext, rty: rfl.Type) -> bool:
-        return (
+class DataclassUnmarshalerFactory(AbstractDataclassFactory, UnmarshalerFactory):
+    def make_unmarshaler(self, ctx: UnmarshalFactoryContext, rty: rfl.Type) -> ta.Callable[[], Unmarshaler] | None:
+        if not (
             (ty := _type_or_generic_base(rty)) is not None and
             dc.is_dataclass(ty) and
             not lang.is_abstract_class(ty)
-        )
+        ):
+            return None
 
-    def fn(self, ctx: UnmarshalContext, rty: rfl.Type) -> Unmarshaler:
-        ty = check.isinstance(_type_or_generic_base(rty), type)
-        check.state(dc.is_dataclass(ty))
-        check.state(not lang.is_abstract_class(ty))
+        def inner() -> Unmarshaler:
+            ty = check.isinstance(_type_or_generic_base(rty), type)
+            check.state(dc.is_dataclass(ty))
+            check.state(not lang.is_abstract_class(ty))
 
-        dc_md = self._get_metadata(ty)
-        fis = self._get_field_infos(ty, ctx.options)
+            dc_md = self._get_metadata(ty)
+            fis = self._get_field_infos(ty, ctx.options)
 
-        d: dict[str, tuple[FieldInfo, Unmarshaler]] = {}
-        defaults: dict[str, ta.Any] = {}
-        embeds: dict[str, type] = {}
-        embeds_by_unmarshal_name: dict[str, tuple[str, str]] = {}
+            d: dict[str, tuple[FieldInfo, Unmarshaler]] = {}
+            defaults: dict[str, ta.Any] = {}
+            embeds: dict[str, type] = {}
+            embeds_by_unmarshal_name: dict[str, tuple[str, str]] = {}
 
-        def add_field(fi: FieldInfo, *, prefixes: ta.Iterable[str] = ('',)) -> ta.Iterable[str]:
-            ret: list[str] = []
+            def add_field(fi: FieldInfo, *, prefixes: ta.Iterable[str] = ('',)) -> ta.Iterable[str]:
+                ret: list[str] = []
 
-            if fi.options.embed:
-                e_ty = check.isinstance(fi.type, type)
-                check.state(dc.is_dataclass(e_ty))
-                e_dc_md = get_dataclass_metadata(e_ty)
-                if e_dc_md.specials.set:
-                    raise Exception(f'Embedded fields cannot have specials: {e_ty}')
+                if fi.options.embed:
+                    e_ty = check.isinstance(fi.type, type)
+                    check.state(dc.is_dataclass(e_ty))
+                    e_dc_md = get_dataclass_metadata(e_ty)
+                    if e_dc_md.specials.set:
+                        raise Exception(f'Embedded fields cannot have specials: {e_ty}')
 
-                embeds[fi.name] = e_ty
-                for e_fi in self._get_field_infos(e_ty, ctx.options):
-                    e_ns = add_field(e_fi, prefixes=[p + ep for p in prefixes for ep in fi.unmarshal_names])
-                    embeds_by_unmarshal_name.update({e_f: (fi.name, e_fi.name) for e_f in e_ns})
-                    ret.extend(e_ns)
+                    embeds[fi.name] = e_ty
+                    for e_fi in self._get_field_infos(e_ty, ctx.options):
+                        e_ns = add_field(e_fi, prefixes=[p + ep for p in prefixes for ep in fi.unmarshal_names])
+                        embeds_by_unmarshal_name.update({e_f: (fi.name, e_fi.name) for e_f in e_ns})
+                        ret.extend(e_ns)
 
-            else:
-                tup = (
-                    fi,
-                    _make_field_obj(
-                        ctx,
-                        fi.type,
-                        fi.metadata.unmarshaler,
-                        fi.metadata.unmarshaler_factory,
-                        'make_unmarshaler',
-                    ),
-                )
+                else:
+                    tup = (
+                        fi,
+                        _make_field_unmarshal_obj(
+                            ctx,
+                            fi.type,
+                            fi.metadata.unmarshaler,
+                            fi.metadata.unmarshaler_factory,
+                        ),
+                    )
 
-                for pfx in prefixes:
-                    for un in fi.unmarshal_names:
-                        un = pfx + un
-                        if un in d:
-                            raise KeyError(f'Duplicate fields for name {un!r}: {fi.name!r}, {d[un][0].name!r}')
-                        d[un] = tup
-                        ret.append(un)
-
-                if fi.options.default.present:
-                    defaults[fi.name] = fi.options.default.must()
-
-            return ret
-
-        for fi in fis:
-            if fi.name in dc_md.specials.set:
-                continue
-            add_field(fi)
-
-        return ObjectUnmarshaler(
-            ty,
-            d,
-            specials=dc_md.specials,
-            defaults=defaults,
-            embeds=embeds,
-            embeds_by_unmarshal_name=embeds_by_unmarshal_name,
-            ignore_unknown=dc_md.ignore_unknown,
-        )
+                    for pfx in prefixes:
+                        for un in fi.unmarshal_names:
+                            un = pfx + un
+                            if un in d:
+                                raise KeyError(f'Duplicate fields for name {un!r}: {fi.name!r}, {d[un][0].name!r}')
+                            d[un] = tup
+                            ret.append(un)
+
+                    if fi.options.default.present:
+                        defaults[fi.name] = fi.options.default.must()
+
+                return ret
+
+            for fi in fis:
+                if fi.name in dc_md.specials.set:
+                    continue
+                add_field(fi)
+
+            return ObjectUnmarshaler(
+                ty,
+                d,
+                specials=dc_md.specials,
+                defaults=defaults,
+                embeds=embeds,
+                embeds_by_unmarshal_name=embeds_by_unmarshal_name,
+                ignore_unknown=dc_md.ignore_unknown,
+            )
+
+        return inner

omlish/marshal/objects/marshal.py

@@ -5,9 +5,10 @@ from ... import check
 from ... import dataclasses as dc
 from ... import reflect as rfl
 from ..base.contexts import MarshalContext
+from ..base.contexts import MarshalFactoryContext
 from ..base.types import Marshaler
+from ..base.types import MarshalerFactory
 from ..base.values import Value
-from ..factories.simple import SimpleMarshalerFactory
 from .metadata import FieldInfo
 from .metadata import FieldInfos
 from .metadata import ObjectSpecials
@@ -29,12 +30,12 @@ class ObjectMarshaler(Marshaler):
     @classmethod
     def make(
             cls,
-            ctx: MarshalContext,
+            ctx: MarshalFactoryContext,
             fis: FieldInfos,
             **kwargs: ta.Any,
     ) -> Marshaler:
         fields = [
-            (fi, ctx.make(fi.type))
+            (fi, ctx.make_marshaler(fi.type))
             for fi in fis
         ]
 
@@ -86,23 +87,26 @@ class ObjectMarshaler(Marshaler):
 
 
 @dc.dataclass(frozen=True)
-class SimpleObjectMarshalerFactory(SimpleMarshalerFactory):
+class SimpleObjectMarshalerFactory(MarshalerFactory):
     dct: ta.Mapping[type, ta.Sequence[FieldInfo]]
 
     _: dc.KW_ONLY
 
     specials: ObjectSpecials = ObjectSpecials()
 
-    def guard(self, ctx: MarshalContext, rty: rfl.Type) -> bool:
-        return isinstance(rty, type) and rty in self.dct
+    def make_marshaler(self, ctx: MarshalFactoryContext, rty: rfl.Type) -> ta.Callable[[], Marshaler] | None:
+        if not (isinstance(rty, type) and rty in self.dct):
+            return None
 
-    def fn(self, ctx: MarshalContext, rty: rfl.Type) -> Marshaler:
-        ty = check.isinstance(rty, type)
+        def inner() -> Marshaler:
+            ty = check.isinstance(rty, type)
 
-        fis = FieldInfos(self.dct[ty])
+            fis = FieldInfos(self.dct[ty])
 
-        return ObjectMarshaler.make(
-            ctx,
-            fis,
-            specials=self.specials,
-        )
+            return ObjectMarshaler.make(
+                ctx,
+                fis,
+                specials=self.specials,
+            )
+
+        return inner

omlish/marshal/objects/namedtuples.py

@@ -5,13 +5,13 @@ from ... import check
 from ... import collections as col
 from ... import lang
 from ... import reflect as rfl
-from ..base.contexts import MarshalContext
-from ..base.contexts import UnmarshalContext
+from ..base.contexts import MarshalFactoryContext
+from ..base.contexts import UnmarshalFactoryContext
 from ..base.options import Option
 from ..base.types import Marshaler
+from ..base.types import MarshalerFactory
 from ..base.types import Unmarshaler
-from ..factories.simple import SimpleMarshalerFactory
-from ..factories.simple import SimpleUnmarshalerFactory
+from ..base.types import UnmarshalerFactory
 from .marshal import ObjectMarshaler
 from .metadata import FieldInfo
 from .metadata import FieldInfos
@@ -55,57 +55,63 @@ def get_namedtuple_field_infos(
 ##
 
 
-class NamedtupleMarshalerFactory(SimpleMarshalerFactory):
-    def guard(self, ctx: MarshalContext, rty: rfl.Type) -> bool:
-        return _is_namedtuple(rty)
+class NamedtupleMarshalerFactory(MarshalerFactory):
+    def make_marshaler(self, ctx: MarshalFactoryContext, rty: rfl.Type) -> ta.Callable[[], Marshaler] | None:
+        if not _is_namedtuple(rty):
+            return None
 
-    def fn(self, ctx: MarshalContext, rty: rfl.Type) -> Marshaler:
-        check.state(_is_namedtuple(rty))
-        ty = check.isinstance(rty, type)
-        check.state(not lang.is_abstract_class(ty))
+        def inner() -> Marshaler:
+            check.state(_is_namedtuple(rty))
+            ty = check.isinstance(rty, type)
+            check.state(not lang.is_abstract_class(ty))
 
-        fis = get_namedtuple_field_infos(ty, ctx.options)
+            fis = get_namedtuple_field_infos(ty, ctx.options)
 
-        fields = [
-            (fi, ctx.make(fi.type))
-            for fi in fis
-        ]
+            fields = [
+                (fi, ctx.make_marshaler(fi.type))
+                for fi in fis
+            ]
 
-        return ObjectMarshaler(
-            fields,
-        )
+            return ObjectMarshaler(
+                fields,
+            )
+
+        return inner
 
 
 ##
 
 
-class NamedtupleUnmarshalerFactory(SimpleUnmarshalerFactory):
-    def guard(self, ctx: UnmarshalContext, rty: rfl.Type) -> bool:
-        return _is_namedtuple(rty)
+class NamedtupleUnmarshalerFactory(UnmarshalerFactory):
+    def make_unmarshaler(self, ctx: UnmarshalFactoryContext, rty: rfl.Type) -> ta.Callable[[], Unmarshaler] | None:
+        if not _is_namedtuple(rty):
+            return None
+
+        def inner() -> Unmarshaler:
+            check.state(_is_namedtuple(rty))
+            ty = check.isinstance(rty, type)
+            check.state(not lang.is_abstract_class(ty))
 
-    def fn(self, ctx: UnmarshalContext, rty: rfl.Type) -> Unmarshaler:
-        check.state(_is_namedtuple(rty))
-        ty = check.isinstance(rty, type)
-        check.state(not lang.is_abstract_class(ty))
+            fis = get_namedtuple_field_infos(ty, ctx.options)
 
-        fis = get_namedtuple_field_infos(ty, ctx.options)
+            d: dict[str, tuple[FieldInfo, Unmarshaler]] = {}
+            defaults: dict[str, ta.Any] = {}
 
-        d: dict[str, tuple[FieldInfo, Unmarshaler]] = {}
-        defaults: dict[str, ta.Any] = {}
+            for fi in fis:
+                tup = (fi, ctx.make_unmarshaler(fi.type))
 
-        for fi in fis:
-            tup = (fi, ctx.make(fi.type))
+                for un in fi.unmarshal_names:
+                    if un in d:
+                        raise KeyError(f'Duplicate fields for name {un!r}: {fi.name!r}, {d[un][0].name!r}')
+                    d[un] = tup
 
-            for un in fi.unmarshal_names:
-                if un in d:
-                    raise KeyError(f'Duplicate fields for name {un!r}: {fi.name!r}, {d[un][0].name!r}')
-                d[un] = tup
+                if fi.options.default.present:
+                    defaults[fi.name] = fi.options.default.must()
 
-            if fi.options.default.present:
-                defaults[fi.name] = fi.options.default.must()
+            return ObjectUnmarshaler(
+                ty,
+                d,
+                defaults=defaults,
+            )
 
-        return ObjectUnmarshaler(
-            ty,
-            d,
-            defaults=defaults,
-        )
+        return inner

omlish/marshal/objects/unmarshal.py

@@ -5,9 +5,10 @@ from ... import check
 from ... import dataclasses as dc
 from ... import reflect as rfl
 from ..base.contexts import UnmarshalContext
+from ..base.contexts import UnmarshalFactoryContext
 from ..base.types import Unmarshaler
+from ..base.types import UnmarshalerFactory
 from ..base.values import Value
-from ..factories.simple import SimpleUnmarshalerFactory
 from .metadata import FieldInfo
 from .metadata import FieldInfos
 from .metadata import ObjectSpecials
@@ -35,13 +36,13 @@ class ObjectUnmarshaler(Unmarshaler):
     @classmethod
     def make(
             cls,
-            ctx: UnmarshalContext,
+            ctx: UnmarshalFactoryContext,
             factory: ta.Callable,
             fis: FieldInfos,
             **kwargs: ta.Any,
     ) -> Unmarshaler:
         fields_by_unmarshal_name = {
-            n: (fi, ctx.make(fi.type))
+            n: (fi, ctx.make_unmarshaler(fi.type))
             for fi in fis
             for n in fi.unmarshal_names
         }
@@ -118,24 +119,27 @@ class ObjectUnmarshaler(Unmarshaler):
 
 
 @dc.dataclass(frozen=True)
-class SimpleObjectUnmarshalerFactory(SimpleUnmarshalerFactory):
+class SimpleObjectUnmarshalerFactory(UnmarshalerFactory):
     dct: ta.Mapping[type, ta.Sequence[FieldInfo]]
 
     _: dc.KW_ONLY
 
     specials: ObjectSpecials = ObjectSpecials()
 
-    def guard(self, ctx: UnmarshalContext, rty: rfl.Type) -> bool:
-        return isinstance(rty, type) and rty in self.dct
+    def make_unmarshaler(self, ctx: UnmarshalFactoryContext, rty: rfl.Type) -> ta.Callable[[], Unmarshaler] | None:
+        if not (isinstance(rty, type) and rty in self.dct):
+            return None
 
-    def fn(self, ctx: UnmarshalContext, rty: rfl.Type) -> Unmarshaler:
-        ty = check.isinstance(rty, type)
+        def inner() -> Unmarshaler:
+            ty = check.isinstance(rty, type)
 
-        fis = FieldInfos(self.dct[ty])
+            fis = FieldInfos(self.dct[ty])
 
-        return ObjectUnmarshaler.make(
-            ctx,
-            ty,
-            fis,
-            specials=self.specials,
-        )
+            return ObjectUnmarshaler.make(
+                ctx,
+                ty,
+                fis,
+                specials=self.specials,
+            )
+
+        return inner

omlish/marshal/polymorphism/marshal.py

@@ -2,13 +2,13 @@ import abc
 import dataclasses as dc
 import typing as ta
 
-from ... import check
 from ... import lang
 from ... import reflect as rfl
 from ..base.contexts import MarshalContext
+from ..base.contexts import MarshalFactoryContext
 from ..base.types import Marshaler
+from ..base.types import MarshalerFactory
 from ..base.values import Value
-from ..factories.simple import SimpleMarshalerFactory
 from .metadata import FieldTypeTagging
 from .metadata import Impls
 from .metadata import Polymorphism
@@ -53,10 +53,10 @@ class FieldPolymorphismMarshaler(PolymorphismMarshaler):
 def make_polymorphism_marshaler(
         impls: Impls,
         tt: TypeTagging,
-        ctx: MarshalContext,
+        ctx: MarshalFactoryContext,
 ) -> Marshaler:
     m = {
-        i.ty: (i.tag, ctx.make(i.ty))
+        i.ty: (i.tag, ctx.make_marshaler(i.ty))
         for i in impls
     }
     if isinstance(tt, WrapperTypeTagging):
@@ -68,13 +68,11 @@ def make_polymorphism_marshaler(
 
 
 @dc.dataclass(frozen=True)
-class PolymorphismMarshalerFactory(SimpleMarshalerFactory):
+class PolymorphismMarshalerFactory(MarshalerFactory):
     p: Polymorphism
     tt: TypeTagging = WrapperTypeTagging()
 
-    def guard(self, ctx: MarshalContext, rty: rfl.Type) -> bool:
-        return rty is self.p.ty
-
-    def fn(self, ctx: MarshalContext, rty: rfl.Type) -> Marshaler:
-        check.is_(rty, self.p.ty)
-        return make_polymorphism_marshaler(self.p.impls, self.tt, ctx)
+    def make_marshaler(self, ctx: MarshalFactoryContext, rty: rfl.Type) -> ta.Callable[[], Marshaler] | None:
+        if rty is not self.p.ty:
+            return None
+        return lambda: make_polymorphism_marshaler(self.p.impls, self.tt, ctx)

omlish/marshal/polymorphism/metadata.py

@@ -107,23 +107,34 @@ class Polymorphism:
         return self._impls
 
 
+class AutoStripSuffix(lang.Marker):
+    pass
+
+
 def polymorphism_from_impls(
         ty: type,
         impls: ta.Iterable[type],
         *,
         naming: Naming | None = None,
-        strip_suffix: bool | ta.Literal['auto'] = False,
+        strip_suffix: bool | type[AutoStripSuffix] | str = False,
 ) -> Polymorphism:
     impls = set(impls)
 
-    if strip_suffix == 'auto':
+    ssx: str | None
+    if strip_suffix is AutoStripSuffix:
         strip_suffix = all(c.__name__.endswith(ty.__name__) for c in impls)
+    if isinstance(strip_suffix, bool):
+        ssx = ty.__name__ if strip_suffix else None
+    elif isinstance(strip_suffix, str):
+        ssx = strip_suffix
+    else:
+        raise TypeError(strip_suffix)
 
     dct: dict[str, Impl] = {}
     for cur in impls:
         name = cur.__name__
-        if strip_suffix:
-            name = lang.strip_suffix(name, ty.__name__)
+        if ssx is not None:
+            name = lang.strip_suffix(name, ssx)
         if naming is not None:
             name = translate_name(name, naming)
         if name in dct:
@@ -141,7 +152,7 @@ def polymorphism_from_subclasses(
         ty: type,
         *,
         naming: Naming | None = None,
-        strip_suffix: bool | ta.Literal['auto'] = False,
+        strip_suffix: bool | type[AutoStripSuffix] | str = False,
 ) -> Polymorphism:
     return polymorphism_from_impls(
         ty,

omlish/marshal/polymorphism/standard.py

@@ -6,6 +6,8 @@ from .marshal import PolymorphismMarshalerFactory
 from .metadata import Polymorphism
 from .metadata import TypeTagging
 from .metadata import WrapperTypeTagging
+from .unions import PolymorphismUnionMarshalerFactory
+from .unions import PolymorphismUnionUnmarshalerFactory
 from .unmarshal import PolymorphismUnmarshalerFactory
 
 
@@ -15,8 +17,18 @@ from .unmarshal import PolymorphismUnmarshalerFactory
 def standard_polymorphism_factories(
         poly: Polymorphism,
         tt: TypeTagging = WrapperTypeTagging(),
+        *,
+        unions: bool | ta.Literal['partial'] = False,
 ) -> ta.Sequence[MarshalerFactory | UnmarshalerFactory]:
-    return [
+    out: list[MarshalerFactory | UnmarshalerFactory] = [
         PolymorphismMarshalerFactory(poly, tt),
         PolymorphismUnmarshalerFactory(poly, tt),
     ]
+
+    if unions:
+        out.extend([
+            PolymorphismUnionMarshalerFactory(poly.impls, tt, allow_partial=unions == 'partial'),
+            PolymorphismUnionUnmarshalerFactory(poly.impls, tt, allow_partial=unions == 'partial'),
+        ])
+
+    return out