wbcore 1.46.0__py2.py3-none-any.whl → 1.58.2__py2.py3-none-any.whl

wbcore/contrib/io/tests/test_exports.py

@@ -50,7 +50,7 @@ class TestExportSourceModel:
         parser_handler_factory.create()  # noise
 
         # check with customer queryset and filtering
-        query_str, query_params = ParserHandler.objects.filter(handler=ph1.handler).query.sql_with_params()
+        query_str, query_params = ParserHandler.objects.filter(parser=ph1.parser).query.sql_with_params()
         export_source = export_source_factory.create(query_str=query_str, query_params=query_params)
 
         assert set(export_source.queryset) == {ph1}

wbcore/contrib/io/tests/test_imports.py

@@ -128,7 +128,7 @@ class TestImportSourceModel:
         assert model.name != comparison_model.name
 
     def test_process_wrongly_formatted_import_data(self, handler, import_source):
-        with pytest.raises(Exception):
+        with pytest.raises(KeyError):
             handler.process(dict(a=1, b="b"))
 
     def test_process_basic(self, handler, import_source, parser_handler_factory):

wbcore/contrib/io/tests/test_models.py

@@ -1,4 +1,5 @@
 import json
+import logging
 from io import BytesIO
 from unittest.mock import patch
 
@@ -14,7 +15,6 @@ from faker import Faker
 from pytest_factoryboy import LazyFixture
 
 from ..backends.abstract import AbstractDataBackend
-from ..exceptions import ImportError
 from ..models import (
     ImportCredential,
     ImportSource,
@@ -25,6 +25,8 @@ from ..models import (
 )
 from ..utils import nest_row
 
+logger = logging.getLogger("io")
+
 fake = Faker()
 
 
@@ -33,7 +35,13 @@ def parse(data):
 
 
 def test_nest_row():
-    a = {"nest1__field1": "val1", "nest2__field2": "val2", "field3": "val3", "nest1__field4": "val4", "field4": "val5"}
+    a = {
+        "nest1__field1": "val1",
+        "nest2__field2": "val2",
+        "field3": "val3",
+        "nest1__field4": "val4",
+        "field4": "val5",
+    }
     expected_res = {
         "nest1": {
             "field1": "val1",
@@ -99,7 +107,7 @@ class TestSourceModel:
         assert source.crontab_repr == ""
 
     @pytest.mark.parametrize("source__crontab", [None, LazyFixture("crontab_schedule")])
-    @pytest.mark.parametrize("_datetime", [(fake.date_time())])
+    @pytest.mark.parametrize("_datetime", [fake.date_time()])
     def test_is_valid_date(self, source, _datetime):
         if not source.crontab:
             assert not source.is_valid_date(_datetime)
@@ -232,7 +240,8 @@ class TestImportSourceModel:
     @patch.object(ParserHandler, "parse")
     @patch.object(ParserHandler, "handle")
     @pytest.mark.parametrize(
-        "import_source__file, import_source__save_data", [(get_test_file(), True), (get_test_file(), False)]
+        "import_source__file, import_source__save_data",
+        [(get_test_file(), True), (get_test_file(), False)],
     )
     def test_import_data_success(self, mock_handle, mock_parse, import_source):
         file_data = json.loads(import_source.file.read().decode("utf-8"))
@@ -248,16 +257,12 @@ class TestImportSourceModel:
         else:
             assert import_source.data == {}
 
-    def test_import_data_error(self, import_source):
+    def test_import_data_error(self, caplog, import_source):
         assert import_source.status == ImportSource.Status.PENDING
-        with pytest.raises(ImportError):
+        with caplog.at_level(logging.ERROR):
             import_source.import_data()
         assert import_source.status == ImportSource.Status.ERROR
 
-    def test_not_silent_raise_error(self, import_source):
-        with pytest.raises(Exception):
-            import_source.import_data(silent=False)
-
 
 @pytest.mark.django_db
 class TestImportCredentialModel:
@@ -274,8 +279,22 @@ class TestImportCredentialModel:
     @pytest.mark.parametrize(
         "type, password, username, authentication_token,  certificate_pem, certificate_key",
         [
-            (ImportCredential.Type.CREDENTIAL, None, "username", None, "certificate_pem", "certificate_key"),
-            (ImportCredential.Type.CREDENTIAL, "password", None, None, "certificate_pem", "certificate_key"),
+            (
+                ImportCredential.Type.CREDENTIAL,
+                None,
+                "username",
+                None,
+                "certificate_pem",
+                "certificate_key",
+            ),
+            (
+                ImportCredential.Type.CREDENTIAL,
+                "password",
+                None,
+                None,
+                "certificate_pem",
+                "certificate_key",
+            ),
             (
                 ImportCredential.Type.AUTHENTICATION_TOKEN,
                 "password",
@@ -284,7 +303,14 @@ class TestImportCredentialModel:
                 "certificate_pem",
                 "certificate_key",
             ),
-            (ImportCredential.Type.CERTIFICATE, "password", "username", "token", None, "certificate_key"),
+            (
+                ImportCredential.Type.CERTIFICATE,
+                "password",
+                "username",
+                "token",
+                None,
+                "certificate_key",
+            ),
         ],
     )
     def test_unvalid_credential(
@@ -310,7 +336,14 @@ class TestImportCredentialModel:
     @pytest.mark.parametrize(
         "type, username, password, authentication_token, certificate_pem, certificate_key",
         [
-            (ImportCredential.Type.CREDENTIAL, None, None, fake.random_letters(16), None, None),
+            (
+                ImportCredential.Type.CREDENTIAL,
+                None,
+                None,
+                fake.random_letters(16),
+                None,
+                None,
+            ),
             (
                 ImportCredential.Type.AUTHENTICATION_TOKEN,
                 fake.random_letters(8),

wbcore/contrib/io/tests/test_viewsets.py

@@ -0,0 +1,271 @@
+import pytest
+from pytest import FixtureRequest
+from rest_framework import status
+from rest_framework.test import APIRequestFactory
+
+from wbcore.contrib.authentication.factories import SuperUserFactory
+from wbcore.contrib.io.factories import (
+    DataBackendFactory,
+    ImportSourceFactory,
+    ParserHandlerFactory,
+    SourceFactory,
+)
+from wbcore.contrib.io.models import DataBackend, ImportSource, ParserHandler
+from wbcore.contrib.io.serializers import (
+    ImportSourceModelSerializer,
+    ParserHandlerModelSerializer,
+)
+from wbcore.contrib.io.viewsets import (
+    DataBackendRepresentationViewSet,
+    ImportSourceModelViewSet,
+    ImportSourceRepresentationViewSet,
+    ParserHandlerModelViewSet,
+    ParserHandlerRepresentationViewSet,
+    SourceModelViewSet,
+    SourceRepresentationViewSet,
+)
+
+BATCH_SIZE = 3
+
+
+@pytest.mark.django_db
+@pytest.mark.with_db
+class TestViewsets:
+    @pytest.fixture
+    def request_factory(self):
+        return APIRequestFactory()
+
+    @pytest.fixture
+    def super_user(self):
+        return SuperUserFactory()
+
+    @pytest.fixture
+    def import_sources(self):
+        return ImportSourceFactory.create_batch(BATCH_SIZE)
+
+    @pytest.fixture
+    def import_source(self, import_sources):
+        return import_sources[0]
+
+    @pytest.fixture
+    def import_source_build(self):
+        parser_handler = ParserHandlerFactory()
+        source = SourceFactory()
+
+        instance = ImportSourceFactory.build(parser_handler=None, source=None)
+
+        serialized_data = ImportSourceModelSerializer(instance).data
+
+        serialized_data["parser_handler"] = parser_handler.id
+        serialized_data["source"] = source.id
+
+        return serialized_data
+
+    @pytest.fixture
+    def sources(self):
+        return SourceFactory.create_batch(BATCH_SIZE)
+
+    @pytest.fixture
+    def source(self, sources):
+        return sources[0]
+
+    @pytest.fixture
+    def parser_handlers(self):
+        return ParserHandlerFactory.create_batch(BATCH_SIZE)
+
+    @pytest.fixture
+    def parser_handler(self, parser_handlers):
+        return parser_handlers[0]
+
+    @pytest.fixture
+    def parser_handler_build(self):
+        instance = ParserHandlerFactory.build()
+        return ParserHandlerModelSerializer(instance).data
+
+    @pytest.fixture
+    def data_backends(self):
+        DataBackend.objects.all().delete()
+        return DataBackendFactory.create_batch(BATCH_SIZE)
+
+    @pytest.fixture
+    def data_backend(self, data_backends):
+        return data_backends[0]
+
+    @pytest.mark.parametrize(
+        "vs, batch",
+        [
+            (ImportSourceRepresentationViewSet, "import_sources"),
+            (ImportSourceModelViewSet, "import_sources"),
+            (SourceRepresentationViewSet, "sources"),
+            (SourceModelViewSet, "sources"),
+            (ParserHandlerRepresentationViewSet, "parser_handlers"),
+            (ParserHandlerModelViewSet, "parser_handlers"),
+            (DataBackendRepresentationViewSet, "data_backends"),
+        ],
+    )
+    def test_get(self, request_factory, super_user, vs, batch, request: FixtureRequest):
+        # Arrange
+        request.getfixturevalue(batch)
+        get_request = request_factory.get("")
+        get_request.user = super_user
+        viewset = vs.as_view({"get": "list"})
+        # Act
+        response = viewset(get_request)
+        # Assert
+        assert len(response.data["results"]) == BATCH_SIZE
+        assert response.status_code == status.HTTP_200_OK
+
+    @pytest.mark.parametrize(
+        "vs, instance",
+        [
+            (ImportSourceRepresentationViewSet, "import_source"),
+            (ImportSourceModelViewSet, "import_source"),
+            (SourceRepresentationViewSet, "source"),
+            (SourceModelViewSet, "source"),
+            (ParserHandlerRepresentationViewSet, "parser_handler"),
+            (ParserHandlerModelViewSet, "parser_handler"),
+            (DataBackendRepresentationViewSet, "data_backend"),
+        ],
+    )
+    def test_retrieve(self, request_factory, super_user, vs, instance, request: FixtureRequest):
+        # Arrange
+        entry = request.getfixturevalue(instance)
+        get_request = request_factory.get("")
+        get_request.user = super_user
+        viewset = vs.as_view({"get": "retrieve"})
+        # We need to work with lookup_field since SourceModelViewSet uses uuid as lookup field
+        lookup_field = getattr(vs, "lookup_field", "pk")
+        lookup_value = getattr(entry, lookup_field)
+        # Act
+        response = viewset(get_request, **{lookup_field: lookup_value})
+        lookup_field = "id" if lookup_field != "uuid" else "uuid"
+        instance = response.data.get("instance")
+        # Assert
+        assert instance is not None
+        assert str(instance[lookup_field]) == str(lookup_value)
+        assert not response.data.get("results")
+        assert response.status_code == status.HTTP_200_OK
+
+    @pytest.mark.parametrize(
+        "vs, data, creatable",
+        [
+            (ImportSourceModelViewSet, "import_source_build", True),
+            (ParserHandlerModelViewSet, "parser_handler_build", False),
+        ],
+    )
+    def test_create(self, request_factory, super_user, vs, data, creatable, request: FixtureRequest):
+        # Arrange
+        build_data = request.getfixturevalue(data)
+        post_request = request_factory.post("", data=build_data, format="json")
+        post_request.user = super_user
+        viewset = vs.as_view({"post": "create"})
+        # Act
+        response = viewset(post_request)
+        expected_status_code = status.HTTP_201_CREATED if creatable else status.HTTP_405_METHOD_NOT_ALLOWED
+        # Assert
+        assert response.status_code == expected_status_code
+
+    @pytest.mark.parametrize(
+        "vs, batch, model, deletable",
+        [
+            (ImportSourceModelViewSet, "import_sources", ImportSource, True),
+            (ParserHandlerModelViewSet, "parser_handlers", ParserHandler, False),
+        ],
+    )
+    def test_delete(
+        self,
+        request_factory,
+        super_user,
+        vs,
+        batch,
+        model,
+        deletable,
+        request: FixtureRequest,
+    ):
+        # Arrange
+        entries = request.getfixturevalue(batch)
+        entry_id = entries[0].id
+        delete_request = request_factory.delete("", args=entry_id)
+        delete_request.user = super_user
+        viewset = vs.as_view({"delete": "destroy"})
+        # Act
+        response = viewset(delete_request, pk=entry_id)
+        # Assert
+        if deletable:
+            assert response.status_code == status.HTTP_204_NO_CONTENT
+            assert model.objects.count() == BATCH_SIZE - 1
+            assert not model.objects.filter(id=entry_id).exists()
+        else:
+            assert response.status_code == status.HTTP_405_METHOD_NOT_ALLOWED
+            assert model.objects.count() == BATCH_SIZE
+            assert model.objects.filter(id=entry_id).exists()
+
+    @pytest.mark.parametrize(
+        "vs, entry, new_data, updatable",
+        [
+            (ImportSourceModelViewSet, "import_source", "import_source_build", True),
+            (
+                ParserHandlerModelViewSet,
+                "parser_handler",
+                "parser_handler_build",
+                False,
+            ),
+        ],
+    )
+    def test_put(
+        self,
+        request_factory,
+        super_user,
+        vs,
+        entry,
+        new_data,
+        updatable,
+        request: FixtureRequest,
+    ):
+        # Arrange
+        entry = request.getfixturevalue(entry)
+        new_data = request.getfixturevalue(new_data)
+        new_data["id"] = entry.id
+        put_request = request_factory.put("", data=new_data, format="json")
+        put_request.user = super_user
+        viewset = vs.as_view({"put": "update"})
+        # Act
+        response = viewset(put_request, pk=entry.id)
+        expected_status_code = status.HTTP_200_OK if updatable else status.HTTP_405_METHOD_NOT_ALLOWED
+        # Assert
+        assert response.status_code == expected_status_code
+
+    @pytest.mark.parametrize(
+        "vs, entry, field, updatable",
+        [
+            (ImportSourceModelViewSet, "import_source", "origin", True),
+            (ParserHandlerModelViewSet, "parser_handler", "parser", False),
+        ],
+    )
+    def test_patch(
+        self,
+        request_factory,
+        super_user,
+        vs,
+        entry,
+        field,
+        updatable,
+        request: FixtureRequest,
+    ):
+        # Arrange
+        instance = request.getfixturevalue(entry)
+        old_field_data = getattr(instance, field)
+        new_field_data = "Foo Bar"
+        patch_request = request_factory.patch("", data={field: new_field_data})
+        patch_request.user = super_user
+        viewset = vs.as_view({"patch": "partial_update"})
+        # Act
+        response = viewset(patch_request, pk=instance.id)
+        instance.refresh_from_db()
+        # Assert
+        if updatable:
+            assert response.status_code == status.HTTP_200_OK
+            assert getattr(instance, field) == new_field_data
+        else:
+            assert response.status_code == status.HTTP_405_METHOD_NOT_ALLOWED
+            assert getattr(instance, field) == old_field_data

wbcore/contrib/io/viewset_mixins.py

@@ -8,7 +8,6 @@ from django.http import HttpResponse
 from django.utils.functional import cached_property
 from django.utils.translation import gettext as _
 from import_export.admin import ImportExportMixin
-from import_export.signals import post_export
 from rest_framework import status
 from rest_framework.authentication import SessionAuthentication
 from rest_framework.decorators import action, parser_classes
@@ -20,6 +19,7 @@ from rest_framework.response import Response
 from wbcore import serializers
 from wbcore.contrib.authentication.authentication import JWTCookieAuthentication
 from wbcore.contrib.icons import WBIcon
+from wbcore.contrib.io.import_export.parsers.base_csv import parse
 from wbcore.enums import RequestType
 from wbcore.metadata.configs import buttons as bt
 from wbcore.metadata.configs.display.instance_display import create_simple_display
@@ -51,8 +51,8 @@ class ImportExportDRFMixin(ImportExportMixin):
     def model(self):
         try:
             return getattr(self.queryset, "model", None)
-        except AttributeError:
-            raise ParseError("Malformed Queryset")
+        except AttributeError as e:
+            raise ParseError("Malformed Queryset") from e
 
     @cached_property
     def opts(self):
@@ -70,14 +70,26 @@ class ImportExportDRFMixin(ImportExportMixin):
         """
         return ViewResource
 
-    def get_import_filter_kwargs(self, request):
-        return dict()
+    def get_import_resource_kwargs(self):
+        return {
+            "extra_columns_values": self.kwargs,  # contains the extra column to inject into the dataset during parsing
+            "columns_mapping": {},  # Store the column mapping to rename dataset column during parsing
+        }
+
+    def get_import_parser_path(self) -> str:
+        return parse.__module__
 
     def get_resource_serializer_class(self):
         resource_kwargs = {}
         with suppress(AttributeError, AssertionError):
-            serializer_class = self.get_serializer_class()
+            # we have to mocky patch the action to be "list" because sometime we differentiate the serializer to use
+            previous_action = getattr(self, "action", "list")
+            self.action = "list"
+            serializer_class = getattr(
+                self, "serializer_class", self.get_serializer_class()
+            )  # we prioritize the default serializer class attribute
             resource_kwargs["serializer_class_path"] = serializer_class.__module__ + "." + serializer_class.__name__
+            self.action = previous_action
         return resource_kwargs
 
     def _get_data_for_export(self, request, queryset, *args, **kwargs) -> tablib.Dataset:
@@ -103,7 +115,7 @@ class ImportExportDRFMixin(ImportExportMixin):
         detail=False,
         methods=["PATCH"],
         permission_classes=[IsAuthenticated],
-        authentication_classes=[SessionAuthentication, JWTCookieAuthentication],
+        # authentication_classes=[SessionAuthentication, JWTCookieAuthentication],
         url_name="processimport",
     )
     @parser_classes([MultiPartParser])
@@ -114,7 +126,7 @@ class ImportExportDRFMixin(ImportExportMixin):
         if not self.has_import_permission(request):
             raise PermissionDenied
         if request.data:
-            if (file_tmp := request.FILES.get("file")) and (resource_class := self.get_resource_class()):
+            if file_tmp := request.FILES.get("file"):
                 from wbcore.contrib.io.models import (  # for circular dependency. Will fix later
                     ImportSource,
                     ParserHandler,
@@ -122,10 +134,14 @@ class ImportExportDRFMixin(ImportExportMixin):
                 )
 
                 parser_handler, _ = ParserHandler.objects.get_or_create(
-                    handler=f"{self.model._meta.app_label}.{self.model.__name__}", parser=resource_class.__module__
+                    handler=f"{self.model._meta.app_label}.{self.model.__name__}", parser=self.get_import_parser_path()
                 )
                 import_source = ImportSource.objects.create(
-                    parser_handler=parser_handler, file=file_tmp, origin="Internal Import", creator=request.user
+                    parser_handler=parser_handler,
+                    file=file_tmp,
+                    origin="Internal Import",
+                    creator=request.user,
+                    resource_kwargs=self.get_import_resource_kwargs(),
                 )
                 import_data_as_task.delay(import_source.id)
 
@@ -193,46 +209,24 @@ class ImportExportDRFMixin(ImportExportMixin):
         """
         This action export a template into a file
         """
-        if (
-            export_format := int(request.GET.get("export_format", -1))
-        ) is not None and export_format in ExportFormat.values:
-            file_format = get_django_import_export_format()[export_format]()
-            export_data = self.get_export_data(file_format, None, request=request, encoding=self.to_encoding, **kwargs)
-            content_type = file_format.get_content_type()
-            response = HttpResponse(export_data, content_type=content_type)
-            response["Content-Disposition"] = 'attachment; filename="%s"' % (
-                self.get_export_filename(request, None, file_format),
-            )
-            post_export.send(sender=None, model=self.model)
-            return response
+        file_format = get_django_import_export_format(ExportFormat.CSV)()
+        export_data = self.get_export_data(file_format, request, None, **kwargs)
+        content_type = file_format.get_content_type()
+        response = HttpResponse(export_data, content_type=content_type)
+        response["Content-Disposition"] = 'attachment; filename="%s"' % (
+            self.get_export_filename(request, None, file_format),
+        )
+        return response
 
 
 @receiver(add_extra_button)
 def add_template_extra_button(sender, instance, request, view, pk=None, **kwargs):
-    if (
-        view
-        and not instance
-        and not view.inline
-        and hasattr(view, "has_import_permission")
-        and view.has_import_permission(request)
-    ):
-        buttons = []
-        for format in ExportFormat:
-            buttons.append(
-                bt.HyperlinkButton(
-                    endpoint=parse_endpoint(request, "export_template", export_format=format.value),
-                    title=format.label,
-                    label=format.label,
-                )
-            )
-        if buttons:
-            return bt.DropDownButton(
-                title=_("Templates"),
-                label=_("Templates"),
-                icon=WBIcon.UPLOAD.icon,
-                buttons=tuple(buttons),
-                weight=2,
-            )
+    if view and not instance and hasattr(view, "has_import_permission") and view.has_import_permission(request):
+        return bt.HyperlinkButton(
+            endpoint=parse_endpoint(request, "export_template", export_format=ExportFormat.CSV),
+            title="Import Template (CSV)",
+            label="Import Template (CSV)",
+        )
 
 
 @receiver(add_extra_button)
@@ -240,7 +234,6 @@ def add_import_extra_button(sender, instance, request, view, pk=None, **kwargs):
     if (
         view
         and not instance
-        and not view.inline
         and hasattr(view, "has_import_permission")
         and view.has_import_permission(request)
         and view.get_resource_class()
@@ -262,13 +255,7 @@ def add_import_extra_button(sender, instance, request, view, pk=None, **kwargs):
 
 @receiver(add_extra_button)
 def add_export_extra_button(sender, instance, request, view, pk=None, **kwargs):
-    if (
-        view
-        and not instance
-        and not view.inline
-        and hasattr(view, "has_export_permission")
-        and view.has_export_permission(request)
-    ):
+    if view and not instance and hasattr(view, "has_export_permission") and view.has_export_permission(request):
         return bt.ActionButton(
             method=RequestType.PATCH,
             icon=WBIcon.DOWNLOAD.icon,

wbcore/contrib/notifications/admin.py

@@ -59,4 +59,5 @@ class NotificationTypeModelAdmin(admin.ModelAdmin):
         "default_enable_web",
         "default_enable_mobile",
         "default_enable_email",
+        "is_lock",
     )

wbcore/contrib/notifications/apps.py

@@ -16,7 +16,7 @@ def notification_type_post_migrate(app_config, using=DEFAULT_DB_ALIAS, **kwargs)
         contenttype = ContentType.objects.db_manager(using).get_for_model(klass, for_concrete_model=False)  # type: ignore
         NotificationType.objects.db_manager(using).filter(contenttype=contenttype).update(stale=True)
 
-        for code, title, help_text, web, mobile, email, resource_button_label in getattr(
+        for code, title, help_text, web, mobile, email, resource_button_label, is_lock in getattr(
             klass._meta, "notification_types", []
         ):
             NotificationType.objects.using(using).update_or_create(
@@ -30,6 +30,7 @@ def notification_type_post_migrate(app_config, using=DEFAULT_DB_ALIAS, **kwargs)
                     "default_enable_email": email,
                     "resource_button_label": resource_button_label,
                     "stale": False,
+                    "is_lock": is_lock,
                 },
             )
 

wbcore/contrib/notifications/backends/abstract_backend.py

@@ -5,9 +5,7 @@ from wbcore.contrib.notifications.models import Notification
 
 class AbstractNotificationBackend(ABC):
     @abstractclassmethod
-    def send_notification(cls, notification: Notification):
-        ...
+    def send_notification(cls, notification: Notification): ...
 
     @abstractclassmethod
-    def get_configuration(cls) -> dict:
-        ...
+    def get_configuration(cls) -> dict: ...

wbcore/contrib/notifications/backends/firebase/backends.py

@@ -5,6 +5,7 @@ import firebase_admin
 from django.utils.html import strip_tags
 from firebase_admin import messaging
 from firebase_admin.credentials import Certificate
+from firebase_admin.exceptions import InvalidArgumentError
 
 from wbcore.contrib.notifications.backends.abstract_backend import (
     AbstractNotificationBackend,
@@ -70,8 +71,10 @@ class NotificationBackend(AbstractNotificationBackend):
             )
             try:
                 messaging.send(message, False, app)
-            except messaging.UnregisteredError:
+            except (messaging.UnregisteredError, messaging.QuotaExceededError):
                 expired_tokens.append(token)
+            except InvalidArgumentError:  # this happens if the body is too big for the mobile push
+                pass
 
         for token in tokens.filter(device_type=NotificationUserToken.NotificationDeviceType.WEB):
             data = {
@@ -89,7 +92,7 @@ class NotificationBackend(AbstractNotificationBackend):
             )
             try:
                 messaging.send(message, False, app)
-            except messaging.UnregisteredError:
+            except (messaging.UnregisteredError, messaging.QuotaExceededError):
                 expired_tokens.append(token)
 
         for expired_token in expired_tokens: