django-spire 0.24.1__tar.gz → 0.24.3__tar.gz

{django_spire-0.24.1 → django_spire-0.24.3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: django-spire
-Version: 0.24.1
+Version: 0.24.3
 Summary: A project for Django Spire
 Author-email: Brayden Carlson <braydenc@stratusadv.com>, Nathan Johnson <nathanj@stratusadv.com>
 License: Copyright (c) 2025 Stratus Advanced Technologies and Contributors.

{django_spire-0.24.1 → django_spire-0.24.3}/django_spire/consts.py

@@ -1,4 +1,4 @@
-__VERSION__ = '0.24.1'
+__VERSION__ = '0.24.3'
 
 MAINTENANCE_MODE_SETTINGS_NAME = 'MAINTENANCE_MODE'
 

django_spire-0.24.3/django_spire/contrib/admin/admin.py

@@ -0,0 +1,140 @@
+from typing import Type, Tuple
+
+from django.contrib import admin
+from django.contrib.contenttypes.fields import GenericRelation
+from django.db import models
+
+
+class SpireModelAdmin(admin.ModelAdmin):
+    model_class: Type[models.Model] = None
+
+    max_search_fields: int = 5
+    max_list_display: int = 10
+
+    trailing_fields = ('is_active', 'is_deleted')
+
+    auto_readonly_fields: Tuple[str] = (
+        'created_datetime', 'is_active', 'is_deleted',
+    )
+
+    filter_field_types = (
+        models.BooleanField,
+        models.DateField,
+        models.DateTimeField,
+        models.ForeignKey,
+        models.CharField,
+    )
+
+    def __init_subclass__(cls, **kwargs):
+        super().__init_subclass__(**kwargs)
+
+        cls.model_fields = cls.model_class._meta.get_fields()
+
+        if cls.model_class is None:
+            raise ValueError(f'{cls.__name__} must define model_class')
+
+        if cls.model_class is not None:
+            cls._configure_if_needed()
+
+    @classmethod
+    def _configure_if_needed(cls):
+        if not hasattr(cls, '_spire_configured'):
+            cls._configure_list_display()
+            cls._configure_list_filter()
+            cls._configure_search_fields()
+            cls._configure_readonly_fields()
+            cls._configure_ordering()
+            cls._configure_list_per_page()
+            cls._spire_configured = True
+
+    @classmethod
+    def _configure_list_display(cls):
+        if cls.list_display != ('__str__',):
+            return
+
+        fields = []
+
+        for field in cls.model_fields:
+            if not isinstance(
+                field,
+                (models.ManyToManyField, models.ManyToOneRel, GenericRelation),
+            ):
+                if hasattr(field, 'name') and not field.name.startswith('_'):
+                    if field.name not in cls.trailing_fields:
+                        fields.append(field.name)
+
+        for trailing_field in cls.trailing_fields:
+            if trailing_field in [field.name for field in cls.model_fields]:
+                fields.append(trailing_field)
+
+        cls.list_display = tuple(fields[:cls.max_list_display])
+
+    @classmethod
+    def _configure_list_filter(cls):
+        if hasattr(cls, 'list_filter') and cls.list_filter:
+            return
+
+        filters = []
+
+        for field in cls.model_fields:
+            if not isinstance(field, (models.ManyToManyField, models.ManyToOneRel)):
+                if isinstance(field, models.BooleanField):
+                    filters.append(field.name)
+
+                elif isinstance(field, (models.DateField, models.DateTimeField)):
+                    filters.append(field.name)
+
+                elif isinstance(field, models.ForeignKey):
+                    filters.append(field.name)
+
+                elif (
+                    isinstance(field, models.CharField)
+                    and hasattr(field, 'choices')
+                    and field.choices
+                ):
+                    filters.append(field.name)
+
+        cls.list_filter = tuple(filters)
+
+    @classmethod
+    def _configure_search_fields(cls):
+        if hasattr(cls, 'search_fields') and cls.search_fields:
+            return
+
+        search_fields = []
+
+        for field in cls.model_fields:
+            if isinstance(field, (models.CharField, models.TextField)):
+                if not field.name.startswith('_'):
+                    search_fields.append(field.name)
+
+                    if len(search_fields) >= cls.max_search_fields:
+                        break
+
+        cls.search_fields = tuple(search_fields)
+
+    @classmethod
+    def _configure_readonly_fields(cls):
+        if hasattr(cls, 'readonly_fields') and cls.readonly_fields:
+            return
+
+        readonly = []
+
+        for field in cls.model_fields:
+            if hasattr(field, 'name') and field.name in cls.auto_readonly_fields:
+                readonly.append(field.name)
+
+        cls.readonly_fields = tuple(readonly)
+
+    @classmethod
+    def _configure_ordering(cls):
+        if hasattr(cls, 'ordering') and cls.ordering:
+            return
+
+        cls.ordering = ('-id',)
+        return
+
+    @classmethod
+    def _configure_list_per_page(cls):
+        if not hasattr(cls, 'list_per_page') or cls.list_per_page == 100:
+            cls.list_per_page = 25

django_spire-0.24.3/django_spire/contrib/choices/choices.py

@@ -0,0 +1,9 @@
+import json
+
+from django.db.models import TextChoices
+
+
+class SpireTextChoices(TextChoices):
+    @classmethod
+    def to_glue_choices(cls) -> str:
+        return json.dumps(cls.choices)

django_spire-0.24.3/django_spire/contrib/choices/tests/test_choices.py

@@ -0,0 +1,62 @@
+import json
+
+from django_spire.contrib.choices.choices import SpireTextChoices
+from django_spire.core.tests.test_cases import BaseTestCase
+
+
+class TestSpireTextChoices(BaseTestCase):
+    def setUp(self):
+        class StatusChoices(SpireTextChoices):
+            DRAFT = ('dra', 'Draft')
+            PUBLISHED = ('pub', 'Published')
+            ARCHIVED = ('arc', 'Archived')
+
+
+        self.StatusChoices = StatusChoices
+
+    def test_inherits_from_text_choices(self):
+        assert issubclass(self.StatusChoices, SpireTextChoices), self.StatusChoices.__class__
+
+    def test_choices_property_exists(self):
+        assert hasattr(self.StatusChoices, 'choices'), self.StatusChoices.dir()
+        assert self.StatusChoices.choices is not None, self.StatusChoices.choices
+
+    def test_to_glue_choices_returns_string(self):
+        result = self.StatusChoices.to_glue_choices()
+        assert isinstance(result, str), type(result)
+
+    def test_to_glue_choices_returns_valid_json(self):
+        result = self.StatusChoices.to_glue_choices()
+        try:
+            parsed = json.loads(result)
+        except json.JSONDecodeError:
+            assert 'to_glue_choices did not return valid JSON'
+
+    def test_to_glue_choices_correct_structure(self):
+        result = self.StatusChoices.to_glue_choices()
+        parsed = json.loads(result)
+
+        assert isinstance(parsed, list), type(parsed)
+        assert len(parsed) == 3
+
+        assert parsed[0] == ['dra', 'Draft']
+        assert parsed[1] == ['pub', 'Published']
+        assert parsed[2] == ['arc', 'Archived']
+
+    def test_empty_choices(self):
+        class EmptyChoices(SpireTextChoices):
+            pass
+
+
+        result = EmptyChoices.to_glue_choices()
+        parsed = json.loads(result)
+        assert parsed == []
+
+    def test_single_choice(self):
+        class SingleChoice(SpireTextChoices):
+            ONLY = 'only', 'Only Option'
+
+
+        result = SingleChoice.to_glue_choices()
+        parsed = json.loads(result)
+        assert parsed == [['only', 'Only Option']]

django_spire-0.24.3/django_spire/contrib/service/django_model_service.py

@@ -0,0 +1,102 @@
+from __future__ import annotations
+
+import logging
+
+from abc import ABC
+from itertools import chain
+from typing import Generic, TypeVar
+
+from django.contrib.contenttypes.fields import GenericForeignKey
+from django.db import transaction
+from django.db.models import Model, Field, AutoField, ForeignObjectRel, FileField
+
+from django_spire.contrib.constructor.django_model_constructor import BaseDjangoModelConstructor
+from django_spire.contrib.service.exceptions import ServiceError
+
+
+
+log = logging.getLogger(__name__)
+
+TypeDjangoModel_co = TypeVar('TypeDjangoModel_co', bound=Model, covariant=True)
+
+
+class BaseDjangoModelService(
+    BaseDjangoModelConstructor[TypeDjangoModel_co],
+    ABC,
+    Generic[TypeDjangoModel_co]
+):
+    def _set_non_m2m_fields(self, **field_data: dict):
+        model_fields = self.obj._meta.fields
+
+        file_field_list = []
+        updated_fields = []
+
+        for field in model_fields:
+            if isinstance(field, AutoField) or field.name not in field_data:
+                continue
+
+            # Defer saving file-type fields until after the other fields, so a
+            # callable upload_to can use the values from other fields (from django's construct_instance).
+            if isinstance(field, FileField):
+                file_field_list.append(field)
+                updated_fields.append(field.name)
+            else:
+                field.save_form_data(self.obj, field_data[field.name])
+                updated_fields.append(field.name)
+
+        # Update foreign key id aliases in field_data for
+        # related fields that weren't already updated above
+        foreign_key_id_aliases = [
+            f"{field.name}_id" for field in model_fields
+            if f"{field.name}_id" in field_data and field.many_to_one and field.name not in updated_fields
+        ]
+
+        for field_name in foreign_key_id_aliases:
+            setattr(self.obj, field_name, field_data[field_name])
+
+        # Update file fields deferred from earlier
+        for field in file_field_list:
+            field.save_form_data(self.obj, field_data[field.name])
+
+    def _set_m2m_fields(self, **field_data):
+        model_meta = self.obj._meta
+
+        for field in chain(model_meta.many_to_many, model_meta.private_fields):
+            if not hasattr(field, "save_form_data"):
+                continue
+            if field.name in field_data:
+                field.save_form_data(self.obj, field_data[field.name])
+
+    @transaction.atomic
+    def save_model_obj(self, **field_data: dict | None) -> tuple[Model, bool]:
+        """
+        This is the core service method for saving a Django model object with field data provided via kwargs.
+        It will update the object with the given kwargs and handle any upstream attribute changes that were applied
+        directly to the model instance (i.e. it can also be called without any kwargs, similar to `Model.save()`).
+
+        Its purpose is to run extra operations related to the model instance that need to run each time
+        the model is saved - it is meant to replace the need for overriding `BaseModelForm.save()` or `Model.save()`.
+
+        It is designed to emulate django's `BaseModelForm.save()` method as close as possible:
+        first, in `_set_non_m2m_fields`, it updates the fields on `self.obj` using logic similar to `django.forms.models.construct_instance`,
+        then it calls self.obj.save(), then updates the m2m fields on the object instance
+        using logic similar to django's `BaseModelForm._save_m2m()` method. In all cases,
+        it treats the incoming `field_data` exactly the same as `cleaned_data` is treated
+        in the django code that it is emulating, and therefore does not perform any validation 
+        on the data or the model instance as it is assumed that field_data has already been validated upstream.
+
+        Args:
+            **field_data:
+
+        Returns:
+            tuple[Model, bool]
+
+        """
+
+        new_model_obj_was_created = True if self.model_obj_is_new else False
+
+        self._set_non_m2m_fields(**field_data)
+        self.obj.save()
+        self._set_m2m_fields(**field_data)
+
+        return self.obj, new_model_obj_was_created

django_spire-0.24.3/django_spire/contrib/service/tests/test_service.py

@@ -0,0 +1,100 @@
+from __future__ import annotations
+
+import pytest
+
+from unittest.mock import patch
+
+from django.contrib.auth.models import User
+from django.core.exceptions import ValidationError
+from django.test import TestCase
+
+from django_spire.contrib.service import BaseDjangoModelService, ServiceError
+
+
+class UserService(BaseDjangoModelService[User]):
+    obj: User
+
+
+class TestServiceError(TestCase):
+    def test_can_be_raised(self) -> None:
+        with pytest.raises(ServiceError):
+            message = 'Test'
+            raise ServiceError(message)
+
+    def test_is_exception(self) -> None:
+        assert issubclass(ServiceError, Exception)
+
+    def test_message(self) -> None:
+        error = ServiceError('Test error message')
+
+        assert str(error) == 'Test error message'
+
+
+class TestBaseDjangoModelService(TestCase):
+    def setUp(self) -> None:
+        self.user = User.objects.create_user(
+            username='testuser',
+            password='testpass'  # noqa: S106
+        )
+
+    def test_set_non_m2m_fields_sets_attribute(self) -> None:
+        service = UserService(self.user)
+        service._set_non_m2m_fields(first_name='NewName')
+
+        assert service.obj.first_name == 'NewName'
+
+    def test_set_non_m2m_fields_skips_auto_created_fields(self) -> None:
+        UserService(self.user)._set_non_m2m_fields(id=999)
+
+        assert self.user.id != 999
+
+    def test_has_set_non_m2m_fields_method(self) -> None:
+        assert hasattr(BaseDjangoModelService, '_set_non_m2m_fields')
+
+    def test_has_set_m2m_fields_method(self) -> None:
+        assert hasattr(BaseDjangoModelService, '_set_m2m_fields')
+
+    def test_has_save_model_obj_method(self) -> None:
+        assert hasattr(BaseDjangoModelService, 'save_model_obj')
+
+    def test_save_model_obj_returns_tuple(self) -> None:
+        service = UserService(self.user)
+
+        result = service.save_model_obj(first_name='Updated')
+
+        assert isinstance(result, tuple)
+        assert len(result) == 2
+
+    def test_save_model_obj_returns_model_and_bool(self) -> None:
+        service = UserService(self.user)
+
+        obj, created = service.save_model_obj(first_name='Updated')
+
+        assert isinstance(obj, User)
+        assert isinstance(created, bool)
+
+    def test_save_model_obj_updates_existing_model(self) -> None:
+        service = UserService(self.user)
+
+        obj, created = service.save_model_obj(first_name='UpdatedName')
+
+        assert created is False
+        assert obj.first_name == 'UpdatedName'
+
+    def test_save_model_obj_creates_new_model(self) -> None:
+        new_user = User(username='newuser', email='new@test.com')
+        service = UserService(new_user)
+
+        obj, created = service.save_model_obj(username='newuser', email='new@test.com')
+
+        assert created is True
+        assert obj.pk is not None
+
+    def test_save_model_updates_obj_with_previous_changes(self) -> None:
+        service = UserService(self.user)
+
+        service.obj.first_name = 'new_test'
+
+        service.save_model_obj(id=self.user.id)
+
+        assert service.obj.first_name == 'new_test'

django_spire-0.24.3/django_spire/core/templates/django_spire/dropdown/ellipsis_modal_dropdown.html

@@ -0,0 +1,37 @@
+{% extends 'django_spire/dropdown/dropdown.html' %}
+
+{% block dropdown_position %}end-0 top-100{% endblock %}
+
+{% block dropdown_trigger %}
+    <span
+        class="bi bi-three-dots-vertical px-1 {% block ellipsis_class %}{% endblock %}"
+        x-bind="trigger"
+    >
+    </span>
+{% endblock %}
+
+{% block dropdown_content %}
+    {% if view_url %}
+        {% if redirect_view_url %}
+            {% include 'django_spire/dropdown/element/dropdown_link_element.html' with view_url=view_url link_text='View' %}
+        {% else %}
+            {% include 'django_spire/dropdown/element/ellipsis_dropdown_modal_link_element.html' with view_url=view_url link_text='View' %}
+        {% endif %}
+    {% endif %}
+
+    {% if edit_url %}
+        {% if redirect_edit_url %}
+            {% include 'django_spire/dropdown/element/dropdown_link_element.html' with view_url=edit_url link_text='Edit' %}
+        {% else %}
+            {% include 'django_spire/dropdown/element/ellipsis_dropdown_modal_link_element.html' with view_url=edit_url link_text='Edit' %}
+        {% endif %}
+    {% endif %}
+
+    {% if delete_url %}
+        {% if redirect_delete_url %}
+            {% include 'django_spire/dropdown/element/dropdown_link_element.html' with view_url=delete_url link_text='Delete' link_css='text-app-danger' %}
+        {% else %}
+            {% include 'django_spire/dropdown/element/ellipsis_dropdown_modal_link_element.html' with view_url=delete_url link_text='Delete' link_css='text-app-danger' %}
+        {% endif %}
+    {% endif %}
+{% endblock %}

{django_spire-0.24.1 → django_spire-0.24.3}/django_spire/core/templates/django_spire/element/attribute_element.html

@@ -32,6 +32,13 @@
             <span x-text="{{ x_attribute_value_postfix }}"></span>
         {% endif %}
     {% endif %}
+
+    {% if show_copy_button %}
+        {% block copy_button %}
+            {% firstof attribute_value or x_attribute_value as value %}
+            {% include 'django_spire/element/copy_to_clipboard_element.html' with value=value copy_func=copy_func %}
+        {% endblock %}
+    {% endif %}
 {% endblock %}
 
 {% if attribute_href or x_attribute_href %}

django_spire-0.24.3/django_spire/core/templates/django_spire/element/copy_to_clipboard_element.html

@@ -0,0 +1,31 @@
+<span
+    x-data="{
+        clicked: false,
+        copy_value_to_clipboard() {
+            let text = '{{ value }}';
+
+            {% if copy_func %}
+            text = {{ copy_func }}(text);
+            {% endif %}
+
+            navigator.clipboard.writeText(text);
+            this.clicked = true;
+            setTimeout(() => {
+                this.clicked = false;
+            }, 1000);
+        }
+    }"
+>
+    <i
+        @click="copy_value_to_clipboard()"
+        class="bi bi-copy text-app-primary cursor-pointer"
+    ></i>
+    <span
+        class="text-app-primary"
+        x-show="clicked"
+        x-transition:enter.duration.500ms
+        x-transition:leave.duration.500ms
+    >
+        Copied!
+    </span>
+</span>

{django_spire-0.24.1 → django_spire-0.24.3}/django_spire/notification/app/templates/django_spire/notification/app/dropdown/notification_dropdown.html

@@ -4,28 +4,28 @@
     <div x-data="{
         new_notification: false,
         async init(){
-            await this.check_new_notifications()
+            await this.check_new_notifications();
             setInterval(await this.check_new_notifications, 30000);
         },
 
         async check_new_notifications(){
-            let url = '{% url "django_spire:notification:app:json:check_new" %}'
-            let response = await django_glue_fetch(url)
-            this.new_notification = response.has_new_notifications
+            let url = '{% url "django_spire:notification:app:json:check_new" %}';
+            let response = await django_glue_fetch(url);
+            this.new_notification = response.has_new_notifications;
         },
 
         async render_dropdown(){
             let dropdown_content = new ViewGlue(
                 url='{% url "django_spire:notification:app:template:notification_dropdown" %}',
                 shared_payload={app_notification_list_url: '{{ app_notification_list_url|default:"" }}'}
-            )
-            await dropdown_content.render_inner($refs.spire_notification_dropdown_content)
-            await this.mark_notifications_as_viewed()
+            );
+            await dropdown_content.render_inner($refs.spire_notification_dropdown_content);
+            await this.mark_notifications_as_viewed();
         },
 
         async mark_notifications_as_viewed(){
-            let response = await django_glue_fetch('{% url "django_spire:notification:app:json:set_viewed" %}')
-            this.new_notification = false
+            let response = await django_glue_fetch('{% url "django_spire:notification:app:json:set_viewed" %}');
+            this.new_notification = false;
         }
 
     }"
@@ -44,5 +44,5 @@
 {% block dropdown_position %}top-100 end-50{% endblock %}
 
 {% block dropdown_content %}
-    <div x-ref="spire_notification_dropdown_content"></div>
+    <div :style="{ width: window.innerWidth < 768 ? (window.innerWidth / 2).toFixed(0) + 'px' : '350px' }" x-ref="spire_notification_dropdown_content"></div>
 {% endblock %}

django_spire-0.24.3/django_spire/notification/app/templates/django_spire/notification/app/dropdown/notification_dropdown_content.html

@@ -0,0 +1 @@
+{% include 'django_spire/notification/app/scroll/container/dropdown_container.html' with endpoint=notification_endpoint container_height='300px' batch_size=10 %}

django_spire-0.24.3/django_spire/notification/app/templates/django_spire/notification/app/item/notification_item.html

@@ -0,0 +1,26 @@
+{% extends 'django_spire/item/infinite_scroll_item.html' %}
+
+{% block item_content %}
+    {% if app_notification.notification.url %}
+    <a href="{{ app_notification.notification.url }}"
+    {% else %}
+    <div
+    {% endif %}
+        class="row bg-app-layer-two-hover rounded m-0"
+    >
+        <div  class="col-12">
+            <span class="fs-7 fw-semibold">{{ app_notification.notification.title }}</span>
+            {% if not app_notification.viewed %}
+                {% include 'django_spire/badge/primary_badge.html' with badge_text='New' %}
+            {% endif %}
+        </div>
+        <div class="col-12">
+            <span class="fs--1">{{ app_notification.notification.body }}</span><br>
+            <span class="text-app-secondary text-muted fs--2">{{ app_notification.verbose_time_since_delivered }}</span>
+        </div>
+    {% if app_notification.notification.url %}
+    </a>
+    {% else %}
+    </div>
+    {% endif %}
+{% endblock %}

django_spire-0.24.3/django_spire/notification/app/templates/django_spire/notification/app/page/list_page.html

@@ -0,0 +1,5 @@
+{% extends 'django_spire/page/full_page.html' %}
+
+{% block full_page_content %}
+    {% include "django_spire/card/infinite_scroll_card.html" with card_title='Notifications' endpoint=notification_endpoint scroll_height='55vh' %}
+{% endblock  %}

django_spire-0.24.3/django_spire/notification/app/templates/django_spire/notification/app/scroll/container/dropdown_container.html

@@ -0,0 +1,54 @@
+{% extends 'django_spire/infinite_scroll/base.html' %}
+
+{% block scroll_wrapper_class %}bg-app-layer-two rounded-2{% endblock %}
+
+{% block scroll_container %}
+    <div class="row">
+        <div class="col-12">
+            <div
+                :style="{
+                    maxHeight: '{{ container_height|default:'300px' }}',
+                    overflowX: 'hidden',
+                    overflowY: 'auto',
+                    overscrollBehavior: 'contain',
+                    WebkitOverflowScrolling: 'touch',
+                    maxWidth: window.innerWidth < 768 ? (window.innerWidth / 2).toFixed(0) + 'px' : '350px',
+                }"
+                x-ref="scroll_container"
+                :data-scroll-id="scroll_id"
+            >
+                <div x-ref="content_container">
+                    {% block scroll_content %}{% endblock %}
+                </div>
+
+                <div style="height: 10px;" x-ref="infinite_scroll_trigger"></div>
+            </div>
+
+            <template x-if="show_loading && !is_refreshing">
+                <div
+                    class="position-absolute d-flex justify-content-center align-items-center"
+                    style="top: 0; left: 0; right: 0; bottom: 0; background: color-mix(in srgb, var(--app-layer-one) 85%, transparent);"
+                >
+                    <div class="spinner-border text-app-primary" role="status"></div>
+                </div>
+            </template>
+        </div>
+    </div>
+{% endblock %}
+
+{% block scroll_footer %}
+    <div class="row text-center border-top border-dark-subtle m-0">
+        <div class="col-12">
+            <span class="fs-7 text-app-secondary">
+                Showing <span x-text="loaded_count"></span> of <span x-text="total_count"></span> {{ footer_label|default:'items' }}
+            </span>
+        </div>
+
+        <div class="col-12 fs-7 text-center py-1">
+            {% if not app_notification_list_url %}
+                {% url "django_spire:notification:app:page:list" as app_notification_list_url %}
+            {% endif %}
+            <a href='{{ app_notification_list_url }}' class="text-decoration-none text-app-secondary my-2">View All</a>
+        </div>
+    </div>
+{% endblock %}

django_spire-0.24.3/django_spire/notification/app/templates/django_spire/notification/app/scroll/item/items.html

@@ -0,0 +1,5 @@
+{% for app_notification in notifications %}
+    <div class="col-12 p-0">
+        {% include app_notification.template %}
+    </div>
+{% endfor %}

{django_spire-0.24.1 → django_spire-0.24.3}/django_spire/notification/app/urls/template_urls.py

@@ -8,7 +8,14 @@ from django_spire.notification.app.views import template_views
 app_name = 'django_spire_notification'
 
 urlpatterns = [
-    path('notficiation/dropdown/template/',
+    path(
+        'notficiation/scroll/items',
+        template_views.notification_infinite_scroll_view,
+        name='scroll_items'
+    ),
+    path(
+        'notficiation/dropdown/template/',
         template_views.notification_dropdown_template_view,
-        name='notification_dropdown')
+        name='notification_dropdown'
+    )
 ]