ducktools-classbuilder 0.5.1__py3-none-any.whl → 0.6.1__py3-none-any.whl

ducktools/classbuilder/prefab.py

@@ -25,33 +25,25 @@ A 'prebuilt' implementation of class generation.
 
 Includes pre and post init functions along with other methods.
 """
-
-import sys
-
 from . import (
     INTERNALS_DICT, NOTHING,
-    Field, MethodMaker, SlotFields, GatheredFields,
-    builder, fieldclass, get_flags, get_fields, make_slot_gatherer,
-    frozen_setattr_maker, frozen_delattr_maker, is_classvar,
+    Field, MethodMaker, GatheredFields, GeneratedCode, SlotMakerMeta,
+    builder, get_flags, get_fields,
+    make_unified_gatherer,
+    frozen_setattr_maker, frozen_delattr_maker, eq_maker,
+    get_repr_generator,
 )
 
+# These aren't used but are re-exported for ease of use
+# noinspection PyUnresolvedReferences
+from . import SlotFields, KW_ONLY
+
 PREFAB_FIELDS = "PREFAB_FIELDS"
 PREFAB_INIT_FUNC = "__prefab_init__"
 PRE_INIT_FUNC = "__prefab_pre_init__"
 POST_INIT_FUNC = "__prefab_post_init__"
 
 
-# KW_ONLY sentinel 'type' to use to indicate all subsequent attributes are
-# keyword only
-# noinspection PyPep8Naming
-class _KW_ONLY_TYPE:
-    def __repr__(self):
-        return "<KW_ONLY Sentinel Object>"
-
-
-KW_ONLY = _KW_ONLY_TYPE()
-
-
 class PrefabError(Exception):
     pass
 
@@ -68,310 +60,226 @@ def get_attributes(cls):
 
 
 # Method Generators
-def get_init_maker(*, init_name="__init__"):
-    def __init__(cls: "type") -> "tuple[str, dict]":
-        globs = {}
-        # Get the internals dictionary and prepare attributes
-        attributes = get_attributes(cls)
-        flags = get_flags(cls)
-
-        kw_only = flags.get("kw_only", False)
-
-        # Handle pre/post init first - post_init can change types for __init__
-        # Get pre and post init arguments
-        pre_init_args = []
-        post_init_args = []
-        post_init_annotations = {}
-
-        for func_name, func_arglist in [
-            (PRE_INIT_FUNC, pre_init_args),
-            (POST_INIT_FUNC, post_init_args),
-        ]:
-            try:
-                func = getattr(cls, func_name)
-                func_code = func.__code__
-            except AttributeError:
-                pass
-            else:
-                argcount = func_code.co_argcount + func_code.co_kwonlyargcount
+def init_generator(cls, funcname="__init__"):
+    globs = {}
+    # Get the internals dictionary and prepare attributes
+    attributes = get_attributes(cls)
+    flags = get_flags(cls)
 
-                # Identify if method is static, if so include first arg, otherwise skip
-                is_static = type(cls.__dict__.get(func_name)) is staticmethod
+    kw_only = flags.get("kw_only", False)
 
-                arglist = (
-                    func_code.co_varnames[:argcount]
-                    if is_static
-                    else func_code.co_varnames[1:argcount]
-                )
+    # Handle pre/post init first - post_init can change types for __init__
+    # Get pre and post init arguments
+    pre_init_args = []
+    post_init_args = []
+    post_init_annotations = {}
+
+    for extra_funcname, func_arglist in [
+        (PRE_INIT_FUNC, pre_init_args),
+        (POST_INIT_FUNC, post_init_args),
+    ]:
+        try:
+            func = getattr(cls, extra_funcname)
+            func_code = func.__code__
+        except AttributeError:
+            pass
+        else:
+            argcount = func_code.co_argcount + func_code.co_kwonlyargcount
 
-                func_arglist.extend(arglist)
-
-                if func_name == POST_INIT_FUNC:
-                    post_init_annotations.update(func.__annotations__)
-
-        pos_arglist = []
-        kw_only_arglist = []
-        for name, attrib in attributes.items():
-            # post_init annotations can be used to broaden types.
-            if name in post_init_annotations:
-                globs[f"_{name}_type"] = post_init_annotations[name]
-            elif attrib.type is not NOTHING:
-                globs[f"_{name}_type"] = attrib.type
-
-            if attrib.init:
-                if attrib.default is not NOTHING:
-                    if isinstance(attrib.default, (str, int, float, bool)):
-                        # Just use the literal in these cases
-                        if attrib.type is NOTHING:
-                            arg = f"{name}={attrib.default!r}"
-                        else:
-                            arg = f"{name}: _{name}_type = {attrib.default!r}"
-                    else:
-                        # No guarantee repr will work for other objects
-                        # so store the value in a variable and put it
-                        # in the globals dict for eval
-                        if attrib.type is NOTHING:
-                            arg = f"{name}=_{name}_default"
-                        else:
-                            arg = f"{name}: _{name}_type = _{name}_default"
-                        globs[f"_{name}_default"] = attrib.default
-                elif attrib.default_factory is not NOTHING:
-                    # Use NONE here and call the factory later
-                    # This matches the behaviour of compiled
+            # Identify if method is static, if so include first arg, otherwise skip
+            is_static = type(cls.__dict__.get(extra_funcname)) is staticmethod
+
+            arglist = (
+                func_code.co_varnames[:argcount]
+                if is_static
+                else func_code.co_varnames[1:argcount]
+            )
+
+            func_arglist.extend(arglist)
+
+            if extra_funcname == POST_INIT_FUNC:
+                post_init_annotations.update(func.__annotations__)
+
+    pos_arglist = []
+    kw_only_arglist = []
+    for name, attrib in attributes.items():
+        # post_init annotations can be used to broaden types.
+        if name in post_init_annotations:
+            globs[f"_{name}_type"] = post_init_annotations[name]
+        elif attrib.type is not NOTHING:
+            globs[f"_{name}_type"] = attrib.type
+
+        if attrib.init:
+            if attrib.default is not NOTHING:
+                if isinstance(attrib.default, (str, int, float, bool)):
+                    # Just use the literal in these cases
                     if attrib.type is NOTHING:
-                        arg = f"{name}=None"
+                        arg = f"{name}={attrib.default!r}"
                     else:
-                        arg = f"{name}: _{name}_type = None"
-                    globs[f"_{name}_factory"] = attrib.default_factory
+                        arg = f"{name}: _{name}_type = {attrib.default!r}"
                 else:
+                    # No guarantee repr will work for other objects
+                    # so store the value in a variable and put it
+                    # in the globals dict for eval
                     if attrib.type is NOTHING:
-                        arg = name
+                        arg = f"{name}=_{name}_default"
                     else:
-                        arg = f"{name}: _{name}_type"
-                if attrib.kw_only or kw_only:
-                    kw_only_arglist.append(arg)
-                else:
-                    pos_arglist.append(arg)
-            # Not in init, but need to set defaults
-            else:
-                if attrib.default is not NOTHING:
+                        arg = f"{name}: _{name}_type = _{name}_default"
                     globs[f"_{name}_default"] = attrib.default
-                elif attrib.default_factory is not NOTHING:
-                    globs[f"_{name}_factory"] = attrib.default_factory
-
-        pos_args = ", ".join(pos_arglist)
-        kw_args = ", ".join(kw_only_arglist)
-        if pos_args and kw_args:
-            args = f"{pos_args}, *, {kw_args}"
-        elif kw_args:
-            args = f"*, {kw_args}"
-        else:
-            args = pos_args
-
-        assignments = []
-        processes = []  # post_init values still need default factories to be called.
-        for name, attrib in attributes.items():
-            if attrib.init:
-                if attrib.default_factory is not NOTHING:
-                    value = f"{name} if {name} is not None else _{name}_factory()"
+            elif attrib.default_factory is not NOTHING:
+                # Use NONE here and call the factory later
+                # This matches the behaviour of compiled
+                if attrib.type is NOTHING:
+                    arg = f"{name}=None"
                 else:
-                    value = name
+                    arg = f"{name}: _{name}_type = None"
+                globs[f"_{name}_factory"] = attrib.default_factory
             else:
-                if attrib.default_factory is not NOTHING:
-                    value = f"_{name}_factory()"
-                elif attrib.default is not NOTHING:
-                    value = f"_{name}_default"
+                if attrib.type is NOTHING:
+                    arg = name
                 else:
-                    value = None
-
-            if name in post_init_args:
-                if attrib.default_factory is not NOTHING:
-                    processes.append((name, value))
-            elif value is not None:
-                assignments.append((name, value))
-
-        if hasattr(cls, PRE_INIT_FUNC):
-            pre_init_arg_call = ", ".join(f"{name}={name}" for name in pre_init_args)
-            pre_init_call = f"    self.{PRE_INIT_FUNC}({pre_init_arg_call})\n"
-        else:
-            pre_init_call = ""
-
-        if assignments or processes:
-            body = ""
-            body += "\n".join(
-                f"    self.{name} = {value}" for name, value in assignments
-            )
-            body += "\n"
-            body += "\n".join(f"    {name} = {value}" for name, value in processes)
-        else:
-            body = "    pass"
-
-        if hasattr(cls, POST_INIT_FUNC):
-            post_init_arg_call = ", ".join(f"{name}={name}" for name in post_init_args)
-            post_init_call = f"    self.{POST_INIT_FUNC}({post_init_arg_call})\n"
-        else:
-            post_init_call = ""
-
-        code = (
-            f"def {init_name}(self, {args}):\n"
-            f"{pre_init_call}\n"
-            f"{body}\n"
-            f"{post_init_call}\n"
-        )
-        return code, globs
-
-    return MethodMaker(init_name, __init__)
-
-
-def get_repr_maker(*, recursion_safe=False):
-    def __repr__(cls: "type") -> "tuple[str, dict]":
-        attributes = get_attributes(cls)
-
-        globs = {}
-
-        will_eval = True
-        valid_names = []
-        for name, attrib in attributes.items():
-            if attrib.repr and not attrib.exclude_field:
-                valid_names.append(name)
-
-            # If the init fields don't match the repr, or some fields are excluded
-            # generate a repr that clearly will not evaluate
-            if will_eval and (attrib.exclude_field or (attrib.init ^ attrib.repr)):
-                will_eval = False
-
-        content = ", ".join(
-            f"{name}={{self.{name}!r}}"
-            for name in valid_names
-        )
-
-        if recursion_safe:
-            import reprlib
-            globs["_recursive_repr"] = reprlib.recursive_repr()
-            recursion_func = "@_recursive_repr\n"
+                    arg = f"{name}: _{name}_type"
+            if attrib.kw_only or kw_only:
+                kw_only_arglist.append(arg)
+            else:
+                pos_arglist.append(arg)
+        # Not in init, but need to set defaults
         else:
-            recursion_func = ""
-
-        if will_eval:
-            code = (
-                f"{recursion_func}"
-                f"def __repr__(self):\n"
-                f"    return f'{{type(self).__qualname__}}({content})'\n"
-            )
+            if attrib.default is not NOTHING:
+                globs[f"_{name}_default"] = attrib.default
+            elif attrib.default_factory is not NOTHING:
+                globs[f"_{name}_factory"] = attrib.default_factory
+
+    pos_args = ", ".join(pos_arglist)
+    kw_args = ", ".join(kw_only_arglist)
+    if pos_args and kw_args:
+        args = f"{pos_args}, *, {kw_args}"
+    elif kw_args:
+        args = f"*, {kw_args}"
+    else:
+        args = pos_args
+
+    assignments = []
+    processes = []  # post_init values still need default factories to be called.
+    for name, attrib in attributes.items():
+        if attrib.init:
+            if attrib.default_factory is not NOTHING:
+                value = f"{name} if {name} is not None else _{name}_factory()"
+            else:
+                value = name
         else:
-            if content:
-                code = (
-                    f"{recursion_func}"
-                    f"def __repr__(self):\n"
-                    f"    return f'<prefab {{type(self).__qualname__}}; {content}>'\n"
-                )
+            if attrib.default_factory is not NOTHING:
+                value = f"_{name}_factory()"
+            elif attrib.default is not NOTHING:
+                value = f"_{name}_default"
             else:
-                code = (
-                    f"{recursion_func}"
-                    f"def __repr__(self):\n"
-                    f"    return f'<prefab {{type(self).__qualname__}}>'\n"
-                )
+                value = None
 
-        return code, globs
-
-    return MethodMaker("__repr__", __repr__)
+        if name in post_init_args:
+            if attrib.default_factory is not NOTHING:
+                processes.append((name, value))
+        elif value is not None:
+            assignments.append((name, value))
 
+    if hasattr(cls, PRE_INIT_FUNC):
+        pre_init_arg_call = ", ".join(f"{name}={name}" for name in pre_init_args)
+        pre_init_call = f"    self.{PRE_INIT_FUNC}({pre_init_arg_call})\n"
+    else:
+        pre_init_call = ""
 
-def get_eq_maker():
-    def __eq__(cls: "type") -> "tuple[str, dict]":
-        class_comparison = "self.__class__ is other.__class__"
-        attribs = get_attributes(cls)
-        field_names = [
-            name
-            for name, attrib in attribs.items()
-            if attrib.compare and not attrib.exclude_field
-        ]
+    if assignments or processes:
+        body = ""
+        body += "\n".join(
+            f"    self.{name} = {value}" for name, value in assignments
+        )
+        body += "\n"
+        body += "\n".join(f"    {name} = {value}" for name, value in processes)
+    else:
+        body = "    pass"
 
-        if field_names:
-            selfvals = ",".join(f"self.{name}" for name in field_names)
-            othervals = ",".join(f"other.{name}" for name in field_names)
-            instance_comparison = f"({selfvals},) == ({othervals},)"
-        else:
-            instance_comparison = "True"
+    if hasattr(cls, POST_INIT_FUNC):
+        post_init_arg_call = ", ".join(f"{name}={name}" for name in post_init_args)
+        post_init_call = f"    self.{POST_INIT_FUNC}({post_init_arg_call})\n"
+    else:
+        post_init_call = ""
 
-        code = (
-            f"def __eq__(self, other):\n"
-            f"    return {instance_comparison} if {class_comparison} else NotImplemented\n"
+    code = (
+        f"def {funcname}(self, {args}):\n"
+        f"{pre_init_call}\n"
+        f"{body}\n"
+        f"{post_init_call}\n"
         )
-        globs = {}
 
-        return code, globs
+    return GeneratedCode(code, globs)
 
-    return MethodMaker("__eq__", __eq__)
 
+def iter_generator(cls, funcname="__iter__"):
+    fields = get_attributes(cls)
 
-def get_iter_maker():
-    def __iter__(cls: "type") -> "tuple[str, dict]":
-        fields = get_attributes(cls)
-
-        valid_fields = (
-            name for name, attrib in fields.items()
-            if attrib.iter and not attrib.exclude_field
-        )
-
-        values = "\n".join(f"    yield self.{name}" for name in valid_fields)
+    valid_fields = (
+        name for name, attrib in fields.items()
+        if attrib.iter
+    )
 
-        # if values is an empty string
-        if not values:
-            values = "    yield from ()"
+    values = "\n".join(f"    yield self.{name}" for name in valid_fields)
 
-        code = f"def __iter__(self):\n{values}"
-        globs = {}
-        return code, globs
+    # if values is an empty string
+    if not values:
+        values = "    yield from ()"
 
-    return MethodMaker("__iter__", __iter__)
+    code = f"def {funcname}(self):\n{values}"
+    globs = {}
+    return GeneratedCode(code, globs)
 
 
-def get_asdict_maker():
-    def as_dict_gen(cls: "type") -> "tuple[str, dict]":
-        fields = get_attributes(cls)
+def as_dict_generator(cls, funcname="as_dict"):
+    fields = get_attributes(cls)
 
-        vals = ", ".join(
-            f"'{name}': self.{name}"
-            for name, attrib in fields.items()
-            if attrib.serialize and not attrib.exclude_field
-        )
-        out_dict = f"{{{vals}}}"
-        code = f"def as_dict(self): return {out_dict}"
+    vals = ", ".join(
+        f"'{name}': self.{name}"
+        for name, attrib in fields.items()
+        if attrib.serialize
+    )
+    out_dict = f"{{{vals}}}"
+    code = f"def {funcname}(self): return {out_dict}"
 
-        globs = {}
-        return code, globs
-    return MethodMaker("as_dict", as_dict_gen)
+    globs = {}
+    return GeneratedCode(code, globs)
 
 
-init_maker = get_init_maker()
-prefab_init_maker = get_init_maker(init_name=PREFAB_INIT_FUNC)
-repr_maker = get_repr_maker()
-recursive_repr_maker = get_repr_maker(recursion_safe=True)
-eq_maker = get_eq_maker()
-iter_maker = get_iter_maker()
-asdict_maker = get_asdict_maker()
+init_maker = MethodMaker("__init__", init_generator)
+prefab_init_maker = MethodMaker(PREFAB_INIT_FUNC, init_generator)
+repr_maker = MethodMaker(
+    "__repr__",
+    get_repr_generator(recursion_safe=False, eval_safe=True)
+)
+recursive_repr_maker = MethodMaker(
+    "__repr__",
+    get_repr_generator(recursion_safe=True, eval_safe=True)
+)
+iter_maker = MethodMaker("__iter__", iter_generator)
+asdict_maker = MethodMaker("as_dict", as_dict_generator)
 
 
 # Updated field with additional attributes
-@fieldclass
 class Attribute(Field):
-    __slots__ = SlotFields(
-        init=True,
-        repr=True,
-        compare=True,
-        iter=True,
-        kw_only=False,
-        serialize=True,
-        exclude_field=False,
-    )
+    """
+    Get an object to define a prefab attribute
 
-    def validate_field(self):
-        super().validate_field()
-        if self.kw_only and not self.init:
-            raise PrefabError(
-                "Attribute cannot be keyword only if it is not in init."
-            )
+    :param default: Default value for this attribute
+    :param default_factory: 0 argument callable to give a default value
+                            (for otherwise mutable defaults, eg: list)
+    :param init: Include this attribute in the __init__ parameters
+    :param repr: Include this attribute in the class __repr__
+    :param compare: Include this attribute in the class __eq__
+    :param iter: Include this attribute in the class __iter__ if generated
+    :param kw_only: Make this argument keyword only in init
+    :param serialize: Include this attribute in methods that serialize to dict
+    :param doc: Parameter documentation for slotted classes
+    :param type: Type of this attribute (for slotted classes)
+    """
+    iter: bool = True
+    serialize: bool = True
 
 
 # noinspection PyShadowingBuiltins
@@ -390,7 +298,7 @@ def attribute(
     type=NOTHING,
 ):
     """
-    Get an object to define a prefab Attribute
+    Helper function to get an object to define a prefab Attribute
 
     :param default: Default value for this attribute
     :param default_factory: 0 argument callable to give a default value
@@ -401,15 +309,18 @@ def attribute(
     :param iter: Include this attribute in the class __iter__ if generated
     :param kw_only: Make this argument keyword only in init
     :param serialize: Include this attribute in methods that serialize to dict
-    :param exclude_field: Exclude this field from all magic method generation
-                          apart from __init__ signature
-                          and do not include it in PREFAB_FIELDS
-                          Must be assigned in __prefab_post_init__
+    :param exclude_field: Shorthand for setting repr, compare, iter and serialize to False
     :param doc: Parameter documentation for slotted classes
     :param type: Type of this attribute (for slotted classes)
 
     :return: Attribute generated with these parameters.
     """
+    if exclude_field:
+        repr = False
+        compare = False
+        iter = False
+        serialize = False
+
     return Attribute(
         default=default,
         default_factory=default_factory,
@@ -419,90 +330,12 @@ def attribute(
         iter=iter,
         kw_only=kw_only,
         serialize=serialize,
-        exclude_field=exclude_field,
         doc=doc,
         type=type,
     )
 
 
-slot_prefab_gatherer = make_slot_gatherer(Attribute)
-
-
-# Gatherer for classes built on attributes or annotations
-def attribute_gatherer(cls):
-    cls_annotations = cls.__dict__.get("__annotations__", {})
-    cls_annotation_names = cls_annotations.keys()
-
-    cls_slots = cls.__dict__.get("__slots__", {})
-
-    cls_attributes = {
-        k: v for k, v in vars(cls).items() if isinstance(v, Attribute)
-    }
-
-    cls_attribute_names = cls_attributes.keys()
-
-    cls_modifications = {}
-
-    if set(cls_annotation_names).issuperset(set(cls_attribute_names)):
-        # replace the classes' attributes dict with one with the correct
-        # order from the annotations.
-        kw_flag = False
-        new_attributes = {}
-        for name, value in cls_annotations.items():
-            # Ignore ClassVar hints
-            if is_classvar(value):
-                continue
-
-            # Look for the KW_ONLY annotation
-            if value is KW_ONLY or value == "KW_ONLY":
-                if kw_flag:
-                    raise PrefabError(
-                        "Class can not be defined as keyword only twice"
-                    )
-                kw_flag = True
-            else:
-                # Copy attributes that are already defined to the new dict
-                # generate Attribute() values for those that are not defined.
-
-                # Extra parameters to pass to each Attribute
-                extras = {
-                    "type": cls_annotations[name]
-                }
-                if kw_flag:
-                    extras["kw_only"] = True
-
-                # If a field name is also declared in slots it can't have a real
-                # default value and the attr will be the slot descriptor.
-                if hasattr(cls, name) and name not in cls_slots:
-                    if name in cls_attribute_names:
-                        attrib = Attribute.from_field(
-                            cls_attributes[name],
-                            **extras,
-                        )
-                    else:
-                        attribute_default = getattr(cls, name)
-                        attrib = attribute(default=attribute_default, **extras)
-
-                    # Clear the attribute from the class after it has been used
-                    # in the definition.
-                    cls_modifications[name] = NOTHING
-                else:
-                    attrib = attribute(**extras)
-
-                new_attributes[name] = attrib
-
-        cls_attributes = new_attributes
-    else:
-        for name in cls_attributes.keys():
-            attrib = cls_attributes[name]
-            cls_modifications[name] = NOTHING
-
-            # Some items can still be annotated.
-            if name in cls_annotations:
-                new_attrib = Attribute.from_field(attrib, type=cls_annotations[name])
-                cls_attributes[name] = new_attrib
-
-    return cls_attributes, cls_modifications
+prefab_gatherer = make_unified_gatherer(Attribute, False)
 
 
 # Class Builders
@@ -548,16 +381,13 @@ def _make_prefab(
         )
 
     slots = cls_dict.get("__slots__")
+
+    slotted = False if slots is None else True
+
     if gathered_fields is None:
-        if isinstance(slots, SlotFields):
-            gatherer = slot_prefab_gatherer
-            slotted = True
-        else:
-            gatherer = attribute_gatherer
-            slotted = False
+        gatherer = prefab_gatherer
     else:
         gatherer = gathered_fields
-        slotted = False if slots is None else True
 
     methods = set()
 
@@ -657,9 +487,9 @@ def _make_prefab(
         post_init_args.extend(arglist)
 
     # Gather values for match_args and do some syntax checking
-
     default_defined = []
-    valid_args = []
+    valid_args = list(fields.keys())
+
     for name, attrib in fields.items():
         # slot_gather and parent classes may use Fields
         # prefabs require Attributes, so convert.
@@ -667,15 +497,6 @@ def _make_prefab(
             attrib = Attribute.from_field(attrib)
             fields[name] = attrib
 
-        # Excluded fields *MUST* be forwarded to post_init
-        if attrib.exclude_field:
-            if name not in post_init_args:
-                raise PrefabError(
-                    f"{name!r} is an excluded attribute but is not passed to post_init"
-                )
-        else:
-            valid_args.append(name)
-
         if not kw_only:
             # Syntax check arguments for __init__ don't have non-default after default
             if attrib.init and not attrib.kw_only:
@@ -698,6 +519,37 @@ def _make_prefab(
     return cls
 
 
+class Prefab(metaclass=SlotMakerMeta):
+    _meta_gatherer = prefab_gatherer
+    __slots__ = {}
+
+    # noinspection PyShadowingBuiltins
+    def __init_subclass__(
+        cls,
+        init=True,
+        repr=True,
+        eq=True,
+        iter=False,
+        match_args=True,
+        kw_only=False,
+        frozen=False,
+        dict_method=False,
+        recursive_repr=False,
+    ):
+        _make_prefab(
+            cls,
+            init=init,
+            repr=repr,
+            eq=eq,
+            iter=iter,
+            match_args=match_args,
+            kw_only=kw_only,
+            frozen=frozen,
+            dict_method=dict_method,
+            recursive_repr=recursive_repr,
+        )
+
+
 # noinspection PyShadowingBuiltins
 def prefab(
     cls=None,
@@ -895,5 +747,5 @@ def as_dict(o):
     return {
         name: getattr(o, name)
         for name, attrib in flds.items()
-        if attrib.serialize and not attrib.exclude_field
+        if attrib.serialize
     }