wbcore 1.59.10__tar.gz → 1.59.12__tar.gz

{wbcore-1.59.10 → wbcore-1.59.12}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: wbcore
-Version: 1.59.10
+Version: 1.59.12
 Author-email: Christopher Wittlinger <c.wittlinger@stainly.com>
 Requires-Dist: celery[redis]==5.*
 Requires-Dist: croniter==2.*

{wbcore-1.59.10 → wbcore-1.59.12}/wbcore/configs/registry.py

@@ -1,7 +1,6 @@
 from contextlib import suppress
 from importlib import import_module
 from inspect import getmembers
-from types import ModuleType
 from typing import Any, Iterable
 
 from django.conf import settings
@@ -15,21 +14,24 @@ class ConfigRegistry:
     in the APIView of this module.
     """
 
-    def __init__(self, request: Request, *args, **kwargs):
-        self.request = request
-        super().__init__(*args, **kwargs)
+    def __init__(self, *args, **kwargs):
+        self.config_members = []
+        self._load_configs()
 
-    def discover_configs(self) -> Iterable[ModuleType]:
+    def _load_configs(self):
         for app in settings.INSTALLED_APPS:
             with suppress(ModuleNotFoundError):
                 module = import_module(f"{app}.configs")
-                yield module
+                for member in getmembers(module, lambda member: hasattr(member, "_is_config")):
+                    self.config_members.append(member[1])
 
-    def get_configs(self) -> Iterable[tuple[str, Any]]:
-        for module in self.discover_configs():
-            for member in getmembers(module, lambda member: hasattr(member, "_is_config")):
-                if res := member[1](request=self.request):
-                    yield res
+    def get_configs(self, request: Request) -> Iterable[tuple[str, Any]]:
+        for member in self.config_members:
+            if res := member(request=request):
+                yield res
 
-    def get_config_dict(self) -> dict[str, Any]:
-        return dict(self.get_configs())
+    def get_config_dict(self, request: Request) -> dict[str, Any]:
+        return dict(self.get_configs(request))
+
+
+config_registry = ConfigRegistry()

{wbcore-1.59.10 → wbcore-1.59.12}/wbcore/configs/views.py

@@ -2,11 +2,11 @@ from rest_framework.request import Request
 from rest_framework.response import Response
 from rest_framework.views import APIView
 
-from wbcore.configs.registry import ConfigRegistry
+from wbcore.configs.registry import config_registry
 
 
 class ConfigAPIView(APIView):
     permission_classes = []
 
     def get(self, request: Request) -> Response:
-        return Response(ConfigRegistry(request=request).get_config_dict())
+        return Response(config_registry.get_config_dict(request))

wbcore-1.59.12/wbcore/contrib/authentication/tests/test_configs.py

@@ -0,0 +1,6 @@
+from wbcore.configs.registry import ConfigRegistry
+
+
+def test_authentication_config(config_registry: ConfigRegistry, api_request):
+    authentication = config_registry.get_config_dict(api_request)["authentication"]
+    assert authentication

{wbcore-1.59.10 → wbcore-1.59.12}/wbcore/contrib/authentication/viewsets/users.py

@@ -72,7 +72,7 @@ def reset_password_email(request):
         try:
             user.reset_password(request)
         except Exception as e:
-            logger.error(f"While user {user} try to reset password, we encounter the error {e}")
+            logger.error("While user try to reset password, we encounter the error", extra={"user": user, "detail": e})
     return Response(
         {
             "status": "ok",
@@ -122,7 +122,7 @@ def register_user(request):
                 query_params["error_redirect_url"] = error_redirect_url
 
             token = user.generate_temporary_token()
-            url = f'{reverse("wbcore:authentication:activate", args=[user.uuid, token], request=request)}?{urlencode(query_params)}'
+            url = f"{reverse('wbcore:authentication:activate', args=[user.uuid, token], request=request)}?{urlencode(query_params)}"
 
             # Construct registration mail and send
             rendered_message = render_to_string("user_registration_email.html", {"user": user, "url": url})

{wbcore-1.59.10 → wbcore-1.59.12}/wbcore/contrib/directory/configurations.py

@@ -1,8 +1,7 @@
+from django.utils.module_loading import import_string
 from django.utils.translation import gettext_lazy
 from rest_framework.reverse import reverse
 
-from wbcore.utils.importlib import import_from_dotted_path
-
 
 class ConfigurationRegistry:
     DEFAULT_COMPANY_MODEL_VIEWSET = "wbcore.contrib.directory.viewsets.entries.CompanyModelViewSet"
@@ -20,35 +19,35 @@ class ConfigurationRegistry:
 
     @property
     def company_model_viewset(self):
-        return import_from_dotted_path(self.DEFAULT_COMPANY_MODEL_VIEWSET)
+        return import_string(self.DEFAULT_COMPANY_MODEL_VIEWSET)
 
     @property
     def company_representation_viewset(self):
-        return import_from_dotted_path(self.DEFAULT_COMPANY_REPRESENTATION_VIEWSET)
+        return import_string(self.DEFAULT_COMPANY_REPRESENTATION_VIEWSET)
 
     @property
     def company_model_serializer(self):
-        return import_from_dotted_path(self.DEFAULT_COMPANY_MODEL_SERIALIZER)
+        return import_string(self.DEFAULT_COMPANY_MODEL_SERIALIZER)
 
     @property
     def company_representation_serializer(self):
-        return import_from_dotted_path(self.DEFAULT_COMPANY_REPRESENTATION_SERIALIZER)
+        return import_string(self.DEFAULT_COMPANY_REPRESENTATION_SERIALIZER)
 
     @property
     def person_model_viewset(self):
-        return import_from_dotted_path(self.DEFAULT_PERSON_MODEL_VIEWSET)
+        return import_string(self.DEFAULT_PERSON_MODEL_VIEWSET)
 
     @property
     def person_representation_viewset(self):
-        return import_from_dotted_path(self.DEFAULT_PERSON_REPRESENTATION_VIEWSET)
+        return import_string(self.DEFAULT_PERSON_REPRESENTATION_VIEWSET)
 
     @property
     def person_model_serializer(self):
-        return import_from_dotted_path(self.DEFAULT_PERSON_MODEL_SERIALIZER)
+        return import_string(self.DEFAULT_PERSON_MODEL_SERIALIZER)
 
     @property
     def person_representation_serializer(self):
-        return import_from_dotted_path(self.DEFAULT_PERSON_REPRESENTATION_SERIALIZER)
+        return import_string(self.DEFAULT_PERSON_REPRESENTATION_SERIALIZER)
 
 
 class DirectoryConfigurationMixin:

{wbcore-1.59.10 → wbcore-1.59.12}/wbcore/contrib/directory/serializers/__init__.py

@@ -36,6 +36,7 @@ from .entries import (
     EntryRepresentationSerializer,
     InternalUserProfileRepresentationSerializer,
     PersonRepresentationSerializer,
+    FullDetailPersonRepresentationSerializer,
     SpecializationModelSerializer,
     SpecializationRepresentationSerializer,
 )

{wbcore-1.59.10 → wbcore-1.59.12}/wbcore/contrib/directory/serializers/entries.py

@@ -16,6 +16,7 @@ from ..models import (
     CompanyType,
     CustomerStatus,
     EmailContact,
+    EmployerEmployeeRelationship,
     Entry,
     Person,
     Specialization,
@@ -63,6 +64,54 @@ class PersonRepresentationSerializer(EntryRepresentationSerializer):
         )
 
 
+class FullDetailPersonRepresentationSerializer(PersonRepresentationSerializer):
+    primary_email = wb_serializers.SerializerMethodField(
+        read_only=True, required=False, label=_("Primary Email"), allow_null=True
+    )
+    primary_telephone = wb_serializers.SerializerMethodField(
+        read_only=True, required=False, label=_("Primary Telephone"), allow_null=True
+    )
+    primary_position = wb_serializers.SerializerMethodField(
+        read_only=True, required=False, label=_("Primary Position"), allow_null=True
+    )
+
+    def get_primary_email(self, person):
+        try:
+            return EmailContact.objects.get(entry_id=person.id, primary=True).address
+        except EmailContact.DoesNotExist:
+            return None
+
+    def get_primary_telephone(self, person):
+        try:
+            return TelephoneContact.objects.get(entry_id=person.id, primary=True).number
+        except TelephoneContact.DoesNotExist:
+            return None
+
+    def get_primary_position(self, person):
+        try:
+            rel = EmployerEmployeeRelationship.objects.get(employee_id=person.id, primary=True)
+            return rel.position.title if rel.position else rel.position_name
+        except EmployerEmployeeRelationship.DoesNotExist:
+            return None
+
+    class Meta:
+        model = Person
+        fields = (
+            "id",
+            "computed_str",
+            "first_name",
+            "last_name",
+            "primary_email",
+            "primary_telephone",
+            "primary_position",
+            "profile_image",
+            "description",
+            "_detail",
+            "_detail_preview",
+            "_additional_resources",
+        )
+
+
 class InternalUserProfileRepresentationSerializer(PersonRepresentationSerializer):
     def get_filter_params(self, request):
         return {"only_internal_users": True}

wbcore-1.59.12/wbcore/contrib/directory/tests/test_configs.py

@@ -0,0 +1,6 @@
+from wbcore.configs.registry import ConfigRegistry
+
+
+def test_profile_config(config_registry: ConfigRegistry, api_request):
+    profile = config_registry.get_config_dict(api_request)["profile"]
+    assert profile

{wbcore-1.59.10 → wbcore-1.59.12}/wbcore/contrib/documents/serializers/documents.py

@@ -46,6 +46,7 @@ class DocumentModelSerializer(serializers.ModelSerializer):
             "created",
             "valid_from",
             "valid_until",
+            "permission_type",
             "_additional_resources",
         )
 

{wbcore-1.59.10 → wbcore-1.59.12}/wbcore/contrib/documents/viewsets/display/documents.py

@@ -15,6 +15,7 @@ class DocumentModelDisplay(DisplayViewConfig):
             fields=[
                 dp.Field(key="name", label=_("Name")),
                 dp.Field(key="document_type", label=_("Type")),
+                dp.Field(key="permission_type", label=_("Permission")),
                 dp.Field(key="valid_from", label=_("Valid From")),
                 dp.Field(key="valid_until", label=_("Valid Until")),
                 dp.Field(key="updated", label=_("Updated")),
@@ -52,27 +53,17 @@ class DocumentModelDisplay(DisplayViewConfig):
                     layouts={
                         dp.default(): dp.Layout(
                             grid_template_areas=[
-                                ["file", "file", "file", "file", "file", "file"],
-                                ["name", "name", "name", "document_type", "document_type", "document_type"],
-                                ["created", "created", "updated", "updated", "system_created", "system_created"],
+                                ["file", "file", "file"],
+                                ["name", "document_type", "permission_type"],
+                                ["created", "updated", "system_created"],
+                                ["valid_from", "valid_until", "."],
                                 [
-                                    "valid_from",
-                                    "valid_from",
-                                    "valid_from",
-                                    "valid_until",
-                                    "valid_until",
-                                    "valid_until",
-                                ],
-                                [
-                                    "description",
-                                    "description",
-                                    "description",
                                     "description",
                                     "description",
                                     "description",
                                 ],
                             ],
-                            grid_template_columns=[dp.repeat_field(6, "1fr")],
+                            grid_template_columns=[dp.repeat_field(3, "1fr")],
                         )
                     },
                 ),

{wbcore-1.59.10 → wbcore-1.59.12}/wbcore/contrib/gleap/tests/tests.py

@@ -23,7 +23,7 @@ def test_different_secret():
     assert hash1 != hash2
 
 
-def test_gleap_config(config_registry: ConfigRegistry):
-    gleap = config_registry.get_config_dict()["gleap"]
+def test_gleap_config(config_registry: ConfigRegistry, api_request):
+    gleap = config_registry.get_config_dict(api_request)["gleap"]
     assert gleap["user_identity_endpoint"]
     assert gleap["api_token"]

{wbcore-1.59.10 → wbcore-1.59.12}/wbcore/contrib/guardian/filters.py

@@ -1,3 +1,4 @@
+from django.db.models import Q
 from rest_framework.filters import BaseFilterBackend
 
 
@@ -14,8 +15,11 @@ class ObjectPermissionsFilter(BaseFilterBackend):
         model_class = queryset.model
         if issubclass(model_class, PermissionObjectModelMixin):
             user = request.user
-
-            return get_objects_for_user(
+            protected_objects = get_objects_for_user(
                 user, [model_class.view_perm_str], queryset, **model_class.guardian_shortcut_kwargs
             )
+            public_objects = queryset.filter(permission_type=PermissionObjectModelMixin.PermissionType.PUBLIC)
+            return queryset.filter(
+                Q(id__in=public_objects.values("id")) | Q(id__in=protected_objects.values("id"))
+            ).distinct()
         return queryset

{wbcore-1.59.10 → wbcore-1.59.12}/wbcore/contrib/icons/icons.py

@@ -5,8 +5,7 @@ from types import DynamicClassAttribute
 from django.conf import settings
 from django.db.models import TextChoices
 from django.db.models.enums import ChoicesType
-
-from wbcore.utils.importlib import import_from_dotted_path
+from django.utils.module_loading import import_string
 
 DEFAULT_ICON_BACKEND = "wbcore.contrib.icons.backends.material.IconBackend"
 FALLBACK_ICON_VALUE = "FALLBACK_ICON"
@@ -21,7 +20,7 @@ class WBIconMeta(ChoicesType):
         )  # add a default member that represent the fallback in case it's not yet implement in the imported backend
         cls = super().__new__(cls, classname, bases, classdict, **kwds)
         with suppress(ModuleNotFoundError):
-            cls.icon_backend = import_from_dotted_path(getattr(settings, "WBCORE_ICON_BACKEND", DEFAULT_ICON_BACKEND))
+            cls.icon_backend = import_string(getattr(settings, "WBCORE_ICON_BACKEND", DEFAULT_ICON_BACKEND))
             icon_backend = cls.icon_backend
             # For each enumeration values, attached an "icon" property to its members
             for member, value in zip(cls.__members__.values(), cls.values, strict=False):

{wbcore-1.59.10 → wbcore-1.59.12}/wbcore/contrib/io/import_export/parsers/resources.py

@@ -1,16 +1,16 @@
 import magic
 from django.apps import apps
 from django.conf import settings
+from django.utils.module_loading import import_string
 from import_export.formats.base_formats import CSV
 from import_export.results import RowResult
 from import_export.signals import post_import
-from wbcore.utils.importlib import import_from_dotted_path
 
 
 def default_import_parse(import_source):
     resource_path = import_source.resource_kwargs["resource_path"]
     resource_kwargs = import_source.resource_kwargs["resource_kwargs"]
-    resource_class = import_from_dotted_path(resource_path)
+    resource_class = import_string(resource_path)
     resource = resource_class(**resource_kwargs)
     input_format = CSV(encoding="utf-8-sig")
 

{wbcore-1.59.10 → wbcore-1.59.12}/wbcore/contrib/io/models.py

@@ -28,6 +28,7 @@ from django.db.utils import IntegrityError
 from django.dispatch import receiver
 from django.utils import timezone
 from django.utils.functional import cached_property
+from django.utils.module_loading import import_string
 from django.utils.translation import gettext_lazy as _
 from django_celery_beat.models import CrontabSchedule, PeriodicTask, cronexp
 from import_export.resources import Resource
@@ -37,7 +38,6 @@ from tqdm import tqdm
 
 from wbcore.contrib.notifications.dispatch import send_notification
 from wbcore.contrib.notifications.utils import create_notification_type
-from wbcore.utils.importlib import import_from_dotted_path
 from wbcore.utils.models import ComplexToStringMixin
 
 from ...workers import Queue
@@ -734,7 +734,7 @@ class ExportSource(ImportExportSource):
         """
         Load into an attribute the instantiated resource loaded from the resource path
         """
-        resource_class = import_from_dotted_path(self.resource_path)
+        resource_class = import_string(self.resource_path)
         return resource_class(**self.resource_kwargs)
 
     @property
@@ -802,7 +802,10 @@ class ExportSource(ImportExportSource):
                 self.log = f"{ex_type}: {ex_value}\n"
                 self.log += traceback.format_exc()
                 self.save()
-                logger.error(f"Export source {self.id} error: {e}")
+                logger.error(
+                    "Data source export failed: Processing error during file generation.",
+                    extra={"export_source": self, "parser_handler": self.parser_handler, "detail": e},
+                )
 
 
 class ImportSource(ImportExportSource):
@@ -908,7 +911,10 @@ class ImportSource(ImportExportSource):
             if debug:
                 raise e
             elif not self.creator:  # if a creator is set in this import source, they will receive a proper notification with feedback. No need then to pollute the logger
-                logger.error(f"Could not import file {self.file.name}  (parser/handler: {self.parser_handler})")
+                logger.error(
+                    "Data import failed: Processing error during file parsing and handling.",
+                    extra={"import_source": self, "parser_handler": self.parser_handler, "detail": e},
+                )
 
         self.notify()
 

{wbcore-1.59.10 → wbcore-1.59.12}/wbcore/contrib/io/resources.py

@@ -4,11 +4,11 @@ from inspect import isfunction
 
 import tablib
 from django.template import Context, Template
+from django.utils.module_loading import import_string
 from import_export import resources
 
 from wbcore.serializers import ListSerializer
 from wbcore.serializers.fields.related import ListSerializer as RelatedListSerializer
-from wbcore.utils.importlib import import_from_dotted_path
 
 
 class ExportResourceMixin:
@@ -84,7 +84,7 @@ class ViewResource(ExportResourceMixin, resources.Resource):
         super().__init__(**kwargs)
         # in that case, serializer_class is lazy loaded,
         if serializer_class_path:
-            serializer_class = import_from_dotted_path(serializer_class_path)
+            serializer_class = import_string(serializer_class_path)
             if isfunction(serializer_class):
                 serializer_class = serializer_class(*serializer_class_method_args)
         if not serializer_class:

wbcore-1.59.12/wbcore/contrib/notifications/tests/test_configs.py

@@ -0,0 +1,7 @@
+from wbcore.configs.registry import ConfigRegistry
+
+
+def test_notifications_config(config_registry: ConfigRegistry, api_request):
+    notifications = config_registry.get_config_dict(api_request)["notifications"]
+    assert notifications["endpoint"]
+    assert notifications["token"]

wbcore-1.59.12/wbcore/contrib/workflow/tests/test_configs.py

@@ -0,0 +1,6 @@
+from wbcore.configs.registry import ConfigRegistry
+
+
+def test_workflow_config(config_registry: ConfigRegistry, api_request):
+    workflow = config_registry.get_config_dict(api_request)["workflow"]
+    assert workflow["endpoint"]

{wbcore-1.59.10 → wbcore-1.59.12}/wbcore/metadata/configs/buttons/view_config.py

@@ -69,12 +69,17 @@ class ButtonViewConfig(WBCoreViewConfig):
         return getattr(self.view, "FSM_BUTTONS", set())
 
     # Create Button Configuration
-    CREATE_BUTTONS = frozenset({Button.SAVE.value})
+    CREATE_BUTTONS = frozenset(
+        {
+            Button.SAVE.value,
+            Button.SAVE_AND_CLOSE.value,
+            Button.SAVE_AND_NEW.value,
+        }
+    )
     CREATE_BUTTONS_ORDERING = [
         Button.SAVE.value,
         Button.SAVE_AND_CLOSE.value,
         Button.SAVE_AND_NEW.value,
-        Button.RESET.value,
     ]
 
     def get_create_buttons(self) -> Iterable:

{wbcore-1.59.10 → wbcore-1.59.12}/wbcore/permissions/registry.py

@@ -4,15 +4,15 @@ from django.conf import settings
 from django.contrib.auth.models import Group
 from django.db.models import QuerySet
 from django.utils.functional import cached_property
+from django.utils.module_loading import import_string
 
 from wbcore.contrib.authentication.models import User
-from wbcore.utils.importlib import import_from_dotted_path
 
 
 class UserBackendRegistry:
     def __init__(self):
         internal_users_backend_path = getattr(settings, "USER_BACKEND", "wbcore.permissions.backend.UserBackend")
-        internal_users_backend_class = import_from_dotted_path(internal_users_backend_path)
+        internal_users_backend_class = import_string(internal_users_backend_path)
         self.backend = internal_users_backend_class()
 
     @cached_property

{wbcore-1.59.10 → wbcore-1.59.12}/wbcore/tests/conftest.py

@@ -43,10 +43,12 @@ pre_migrate.connect(app_pre_migration)
 
 @pytest.fixture()
 def config_registry():
-    request = APIRequestFactory().get("/")
-    registry = ConfigRegistry(request)
+    registry = ConfigRegistry()
     return registry
 
+@pytest.fixture()
+def api_request():
+    return APIRequestFactory().get("/")
 
 @pytest.fixture
 def chrome_options(chrome_options):

{wbcore-1.59.10 → wbcore-1.59.12}/wbcore/tests/test_configs.py

@@ -6,37 +6,37 @@ from wbcore.configs.registry import ConfigRegistry
 from wbcore.configs.views import ConfigAPIView
 
 
-def test_registry(config_registry: ConfigRegistry):
-    configs = config_registry.get_config_dict()
+def test_registry(config_registry: ConfigRegistry, api_request):
+    configs = config_registry.get_config_dict(api_request)
     assert configs.keys()
 
 
-def test_release_note_config(config_registry: ConfigRegistry):
-    release_notes = config_registry.get_config_dict()["release_notes"]
+def test_release_note_config(config_registry: ConfigRegistry, api_request):
+    release_notes = config_registry.get_config_dict(api_request)["release_notes"]
     assert release_notes["endpoint"]
     assert release_notes["unread_release_notes"]
 
 
-def test_menu_config(config_registry: ConfigRegistry):
-    menu = config_registry.get_config_dict()["menu"]
+def test_menu_config(config_registry: ConfigRegistry, api_request):
+    menu = config_registry.get_config_dict(api_request)["menu"]
     assert menu
 
 
-def test_share_config(config_registry: ConfigRegistry):
-    share = config_registry.get_config_dict()["share"]
+def test_share_config(config_registry: ConfigRegistry, api_request):
+    share = config_registry.get_config_dict(api_request)["share"]
     assert share
 
 
-def test_menu_calendar_config(config_registry: ConfigRegistry):
-    menu_calendar = config_registry.get_config_dict()["menu_calendar"]
+def test_menu_calendar_config(config_registry: ConfigRegistry, api_request):
+    menu_calendar = config_registry.get_config_dict(api_request)["menu_calendar"]
     assert menu_calendar
 
 
 @pytest.mark.parametrize("text, version", [("Foo bar", "Foo")])
-def test_beta_button_config(config_registry: ConfigRegistry, text, version):
+def test_beta_button_config(config_registry: ConfigRegistry, text, version, api_request):
     settings.BETA_BUTTON_VERSION = version
     settings.BETA_BUTTON_TEXT = text
-    beta_calendar = config_registry.get_config_dict()["beta_button"]
+    beta_calendar = config_registry.get_config_dict(api_request)["beta_button"]
     assert beta_calendar["url"] == f"{settings.CDN_BASE_ENDPOINT_URL}/{version}/main.js"
     assert beta_calendar["text"] == text
 

wbcore-1.59.12/wbcore/utils/importlib.py

@@ -0,0 +1,4 @@
+def parse_signal_received_for_module(receiver_response) -> tuple[str, any]:
+    for receiver, response in receiver_response:
+        if response:
+            yield receiver.__module__.split(".", 1)[0], response

wbcore-1.59.10/wbcore/contrib/authentication/tests/test_configs.py

@@ -1,6 +0,0 @@
-from wbcore.configs.registry import ConfigRegistry
-
-
-def test_authentication_config(config_registry: ConfigRegistry):
-    authentication = config_registry.get_config_dict()["authentication"]
-    assert authentication

wbcore-1.59.10/wbcore/contrib/directory/tests/test_configs.py

@@ -1,6 +0,0 @@
-from wbcore.configs.registry import ConfigRegistry
-
-
-def test_profile_config(config_registry: ConfigRegistry):
-    profile = config_registry.get_config_dict()["profile"]
-    assert profile

wbcore-1.59.10/wbcore/contrib/notifications/tests/test_configs.py

@@ -1,7 +0,0 @@
-from wbcore.configs.registry import ConfigRegistry
-
-
-def test_notifications_config(config_registry: ConfigRegistry):
-    notifications = config_registry.get_config_dict()["notifications"]
-    assert notifications["endpoint"]
-    assert notifications["token"]

wbcore-1.59.10/wbcore/contrib/workflow/tests/test_configs.py

@@ -1,6 +0,0 @@
-from wbcore.configs.registry import ConfigRegistry
-
-
-def test_workflow_config(config_registry: ConfigRegistry):
-    workflow = config_registry.get_config_dict()["workflow"]
-    assert workflow["endpoint"]

wbcore-1.59.10/wbcore/utils/importlib.py

@@ -1,13 +0,0 @@
-from importlib import import_module
-from typing import Callable, Type, Union
-
-
-def import_from_dotted_path(path: str) -> Union[Type, Callable]:
-    *module_path, name = path.split(".")
-    return getattr(import_module(".".join(module_path)), name)
-
-
-def parse_signal_received_for_module(receiver_response) -> tuple[str, any]:
-    for receiver, response in receiver_response:
-        if response:
-            yield receiver.__module__.split(".", 1)[0], response