django-queuebie 0.3.6__py3-none-any.whl

django_queuebie-0.3.6.dist-info/METADATA

@@ -0,0 +1,192 @@
+Metadata-Version: 2.4
+Name: django-queuebie
+Version: 0.3.6
+Summary: A simple and synchronous message queue for commands and events for Django
+Project-URL: Homepage, https://github.com/ambient-innovation/django-queuebie/
+Project-URL: Documentation, https://django-queuebie.readthedocs.io/en/latest/index.html
+Project-URL: Maintained by, https://ambient.digital/
+Project-URL: Bugtracker, https://github.com/ambient-innovation/django-queuebie/issues
+Project-URL: Changelog, https://django-queuebie.readthedocs.io/en/latest/features/changelog.html
+Author-email: Ambient Digital <hello@ambient.digital>
+License: MIT License
+        
+        Copyright (c) 2025 Ambient Innovation: GmbH
+        
+        Permission is hereby granted, free of charge, to any person obtaining a copy
+        of this software and associated documentation files (the "Software"), to deal
+        in the Software without restriction, including without limitation the rights
+        to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+        copies of the Software, and to permit persons to whom the Software is
+        furnished to do so, subject to the following conditions:
+        
+        The above copyright notice and this permission notice shall be included in all
+        copies or substantial portions of the Software.
+        
+        THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+        IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+        FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+        AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+        LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+        OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+        SOFTWARE.
+License-File: LICENSE
+License-File: LICENSE.md
+Classifier: Development Status :: 4 - Beta
+Classifier: Environment :: Web Environment
+Classifier: Framework :: Django
+Classifier: Framework :: Django :: 4.2
+Classifier: Framework :: Django :: 5.1
+Classifier: Framework :: Django :: 5.2
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Natural Language :: English
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Topic :: Utilities
+Requires-Python: >=3.10
+Requires-Dist: django>=4.2
+Description-Content-Type: text/markdown
+
+[![PyPI release](https://img.shields.io/pypi/v/django-queuebie.svg)](https://pypi.org/project/django-queuebie/)
+[![Downloads](https://static.pepy.tech/badge/django-queuebie)](https://pepy.tech/project/django-queuebie)
+[![Coverage](https://img.shields.io/badge/Coverage-100.0%25-success)](https://github.com/ambient-innovation/django-queuebie/actions?workflow=CI)
+[![Linting](https://img.shields.io/endpoint?url=https://raw.githubusercontent.com/astral-sh/ruff/main/assets/badge/v2.json)](https://github.com/astral-sh/ruff)
+[![Coding Style](https://img.shields.io/badge/code%20style-Ruff-000000.svg)](https://github.com/astral-sh/ruff)
+[![Documentation Status](https://readthedocs.org/projects/django-queuebie/badge/?version=latest)](https://django-queuebie.readthedocs.io/en/latest/?badge=latest)
+
+A simple and synchronous message queue for commands and events for Django.
+
+[PyPI](https://pypi.org/project/django-queuebie/) | [GitHub](https://github.com/ambient-innovation/django-queuebie) | [Full documentation](https://django-queuebie.readthedocs.io/en/latest/index.html)
+
+Creator & Maintainer: [Ambient Digital](https://ambient.digital/)
+
+## Features
+
+* Split up your business logic in commands and events
+* Commands are imperatives telling your system what to do, events reflect that something has happened
+* Register light-weight functions via a decorator to listen to your commands and events
+* Message handlers receive the context of the message (command or event), providing an explicit API
+* No magic, no side effects since the queue works synchronously
+
+```python
+import dataclasses
+
+from queuebie.runner import handle_message
+from queuebie.messages import Command, Event
+from queuebie import message_registry
+
+
+# Example command
+@dataclasses.dataclass(kw_only=True)
+class BuyProduct(Command):
+    product_id: int
+    customer_id: int
+    price: float
+    currency: str
+
+
+# Example event
+@dataclasses.dataclass(kw_only=True)
+class ProductBought(Event):
+    product_id: int
+    customer_id: int
+
+
+# Example handler
+@message_registry.register_command(BuyProduct)
+def handle_buy_product(context: BuyProduct) -> Event:
+    # Here lives your business logic
+
+    return ProductBought(
+        product_id=context.product_id,
+        customer_id=context.customer_id,
+    )
+
+
+# Start queue and process messages
+handle_message(
+    BuyProduct(
+        product_id=product.id,
+        customer_id=customer.id,
+        price=12.99,
+        currency="EUR",
+    )
+)
+```
+
+## Installation
+
+- Install the package via pip:
+
+  `pip install django_queuebie`
+
+  or via uv:
+
+  `uv add django_queuebie`
+
+- Add module to `INSTALLED_APPS` within the main django `settings.py`:
+
+```python
+INSTALLED_APPS = (
+    # ...
+    "queuebie",
+)
+```
+
+### Publish to ReadTheDocs.io
+
+- Fetch the latest changes in GitHub mirror and push them
+- Trigger new build at ReadTheDocs.io (follow instructions in admin panel at RTD) if the GitHub webhook is not yet set
+  up.
+
+### Preparation and building
+
+This package uses [uv](https://github.com/astral-sh/uv) for dependency management and building.
+
+- Update documentation about new/changed functionality
+
+- Update the `CHANGES.md`
+
+- Increment version in main `__init__.py`
+
+- Create pull request / merge to "main"
+
+- This project uses uv to publish to PyPI. This will create distribution files in the `dist/` directory.
+
+  ```bash
+  uv build
+  ```
+
+### Publishing to PyPI
+
+To publish to the production PyPI:
+
+```bash
+uv publish
+```
+
+To publish to TestPyPI first (recommended for testing):
+
+```bash
+uv publish --publish-url https://test.pypi.org/legacy/
+```
+
+You can then test the installation from TestPyPI:
+
+```bash
+uv pip install --index-url https://test.pypi.org/simple/ ambient-package-update
+```
+
+### Maintenance
+
+Please note that this package supports the [ambient-package-update](https://pypi.org/project/ambient-package-update/).
+So you don't have to worry about the maintenance of this package. This updater is rendering all important
+configuration and setup files. It works similar to well-known updaters like `pyupgrade` or `django-upgrade`.
+
+To run an update, refer to the [documentation page](https://pypi.org/project/ambient-package-update/)
+of the "ambient-package-update".

django_queuebie-0.3.6.dist-info/RECORD

@@ -0,0 +1,18 @@
+queuebie/__init__.py,sha256=_updQVD0CxDYYJ-6lQyY6icYwXfB8Lih6hlxK9_r_Rk,233
+queuebie/apps.py,sha256=dTNk2xGvasXJncLUbbIjVQZrX7VYQsIdv_7ToFPy5b8,477
+queuebie/database_blocker.py,sha256=8yszE7wSfVJJ-IdTB-xO4qDLk5AI1k2pjkKVYM4JDi8,766
+queuebie/exceptions.py,sha256=B_vsZBEMqpWsxUp5RrokabiZOYfNEbV0nGxhhX0o5NY,711
+queuebie/logger.py,sha256=OWO9yiNxfnhUqejoR6RCUueKSWYzsMtfUBCmxAuAksk,244
+queuebie/messages.py,sha256=JcC7QxWzWllxDkwbYGefhaL1YWT_froOXa1NDugbGCM,1022
+queuebie/registry.py,sha256=ipD7i2jtookHAYU1iVXII071SaaHLiNmA81-Pf6sKkY,6163
+queuebie/runner.py,sha256=yAVxNEPj400Y9rOLBr_3HrThnoremlBpoPFG-sK_J5k,2626
+queuebie/settings.py,sha256=CAUldgjCH-coTIAPctaYDRWmoZXb2NcWZlaMBxec0Nw,850
+queuebie/utils.py,sha256=aeHOkILLpPrkA9bnDmsR1YF40KLdSlKqk15ItmLTZW4,997
+queuebie/management/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+queuebie/management/commands/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+queuebie/management/commands/clear_queuebie_registry.py,sha256=Vx4JLSo9-i7gK0YeNP5F_50TsyjEP4i4plYK_byHj3I,392
+django_queuebie-0.3.6.dist-info/METADATA,sha256=l07peQktrO71P8csgbIIcTuc7gbxPmr6BMEjBhb0NMo,6937
+django_queuebie-0.3.6.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+django_queuebie-0.3.6.dist-info/licenses/LICENSE,sha256=VCMRQqZBDEG5HsJdp-Ps6a3-GFnpQZPzitGMRUHdgso,1093
+django_queuebie-0.3.6.dist-info/licenses/LICENSE.md,sha256=SiLpAPFRchFM_cDmWQIdItf_xPR6jeYCAaNUgpKWxV8,1102
+django_queuebie-0.3.6.dist-info/RECORD,,

django_queuebie-0.3.6.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: hatchling 1.27.0
+Root-Is-Purelib: true
+Tag: py3-none-any

django_queuebie-0.3.6.dist-info/licenses/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 Ambient Digital
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

django_queuebie-0.3.6.dist-info/licenses/LICENSE.md

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 Ambient Innovation: GmbH
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

queuebie/__init__.py

@@ -0,0 +1,8 @@
+"""A simple and synchronous message queue for commands and events for Django"""
+
+__version__ = "0.3.6"
+
+from queuebie.registry import MessageRegistry
+
+# Initialise global message registry
+message_registry = MessageRegistry()

queuebie/apps.py

@@ -0,0 +1,15 @@
+from django.apps import AppConfig
+
+from queuebie import message_registry
+
+
+class QueuebieConfig(AppConfig):
+    default_auto_field = "django.db.models.BigAutoField"
+    name = "queuebie"
+
+    def ready(self):
+        super().ready()
+
+        # Register all decorated functions before they get imported by something else which will break the
+        # registration process since decorators are only executed the first time
+        message_registry.autodiscover()

queuebie/database_blocker.py

@@ -0,0 +1,25 @@
+from unittest.mock import patch
+
+from django.db import connections
+
+
+class DatabaseAccessDeniedError(RuntimeError):
+    def __init__(self):
+        super().__init__("Database access is disabled in this context.")
+
+
+class BlockDatabaseAccess:
+    def __enter__(self):
+        # Patcht alle aktiven DB-Verbindungen, sodass jede Query fehlschlägt
+        self.patches = [
+            patch.object(connections[alias], "cursor", side_effect=self._raise_error) for alias in connections
+        ]
+        for p in self.patches:
+            p.start()
+
+    def __exit__(self, exc_type, exc_value, traceback):
+        for p in self.patches:
+            p.stop()
+
+    def _raise_error(self, *args, **kwargs):
+        raise DatabaseAccessDeniedError()

queuebie/exceptions.py

@@ -0,0 +1,17 @@
+class RegisterWrongMessageTypeError(TypeError):
+    def __init__(self, *, message_name: str, decoratee_name: str):
+        super().__init__(
+            f'Trying to register message function of wrong type: "{message_name}" on handler "{decoratee_name}".'
+        )
+
+
+class RegisterOutOfScopeCommandError(TypeError):
+    def __init__(self, *, message_name: str, decoratee_name: str):
+        super().__init__(
+            f'Trying to register a command from another scope/app: "{message_name}" on handler "{decoratee_name}".'
+        )
+
+
+class InvalidMessageTypeError(TypeError):
+    def __init__(self, *, class_name: str):
+        super().__init__(f'"{class_name}" is not an Event or Command')

queuebie/logger.py

@@ -0,0 +1,10 @@
+import logging
+
+from queuebie.settings import get_queuebie_logger_name
+
+
+def get_logger() -> logging.Logger:
+    """
+    Returns an instance of a queuebie Django logger
+    """
+    return logging.getLogger(get_queuebie_logger_name())

queuebie/management/commands/clear_queuebie_registry.py

@@ -0,0 +1,13 @@
+from django.core.cache import cache
+from django.core.management.base import BaseCommand
+
+from queuebie.logger import get_logger
+from queuebie.settings import get_queuebie_cache_key
+
+
+class Command(BaseCommand):
+    def handle(self, *args, **options):
+        cache.delete(get_queuebie_cache_key())
+
+        logger = get_logger()
+        logger.info("Queuebie registry cleared.")

queuebie/messages.py

@@ -0,0 +1,39 @@
+import abc
+import uuid
+
+
+class Message(abc.ABC):
+    """
+    Base class for all commands and events.
+    """
+
+    uuid: str
+
+    def __post_init__(self):
+        super().__init__()
+        # Hier kannst du zusätzliche Initialisierungslogik hinzufügen, falls nötig
+        self.uuid = str(uuid.uuid4())
+
+    def __str__(self) -> str:
+        return f"{self.__class__} ({self.uuid})"
+
+    @classmethod
+    def module_path(cls) -> str:
+        return f"{cls.__module__}.{cls.__qualname__}"
+
+
+class Command(Message):
+    """
+    Commands are messages which prompt the system to do something.
+    Are always written in present tense: "CreateInvoice".
+    Every instance has to be decorated as "@dataclass(kw_only=True)".
+    # todo: check that messages are dataclasses?
+    """
+
+
+class Event(Message):
+    """
+    Events are the results of a command.
+    Are always written in past tense: "InvoiceCreated".
+    Every instance has to be decorated as "@dataclass(kw_only=True)".
+    """

queuebie/registry.py

@@ -0,0 +1,153 @@
+import dataclasses
+import importlib
+import json
+import os
+import sys
+from pathlib import Path
+
+from django.apps import apps
+from django.core.cache import cache
+
+from queuebie.exceptions import RegisterOutOfScopeCommandError, RegisterWrongMessageTypeError
+from queuebie.logger import get_logger
+from queuebie.messages import Command, Event
+from queuebie.settings import get_queuebie_app_base_path, get_queuebie_cache_key, get_queuebie_strict_mode
+from queuebie.utils import is_part_of_app, unique_append_to_inner_list
+
+
+@dataclasses.dataclass(kw_only=True)
+class FunctionDefinition:
+    module: str
+    name: str
+
+
+class MessageRegistry:
+    """
+    Singleton for registering messages classes in.
+    """
+
+    # TODO: make message registry generic and put in toolbox
+    _instance: "MessageRegistry" = None
+
+    def __init__(self):
+        self.command_dict: dict = {}
+        self.event_dict: dict = {}
+
+    def __new__(cls, *args, **kwargs):
+        if not cls._instance:
+            cls._instance = super().__new__(cls)
+        return cls._instance
+
+    def register_command(self, *, command: type[Command]):
+        def decorator(decoratee):
+            # Ensure that registered message is of correct type
+            if not (issubclass(command, Command)):
+                raise RegisterWrongMessageTypeError(message_name=command.__name__, decoratee_name=decoratee.__name__)
+
+            if get_queuebie_strict_mode() and not is_part_of_app(function=decoratee, class_type=command):
+                raise RegisterOutOfScopeCommandError(message_name=command.__name__, decoratee_name=decoratee.__name__)
+
+            # Add decoratee to dependency list
+            function_definition = dataclasses.asdict(
+                FunctionDefinition(module=decoratee.__module__, name=decoratee.__name__)
+            )
+            self.command_dict = unique_append_to_inner_list(
+                data=self.command_dict, key=command.module_path(), value=function_definition
+            )
+
+            logger = get_logger()
+            logger.debug("Registered command '%s'", decoratee.__name__)
+
+            # Return decoratee
+            return decoratee
+
+        return decorator
+
+    def register_event(self, *, event: type[Event]):
+        # TODO: create a generic registry function and "inherit" here from it
+        def decorator(decoratee):
+            # Ensure that registered message is of correct type
+            if not (issubclass(event, Event)):
+                raise RegisterWrongMessageTypeError(message_name=event.__name__, decoratee_name=decoratee.__name__)
+
+            # Add decoratee to dependency list
+            function_definition = dataclasses.asdict(
+                FunctionDefinition(module=decoratee.__module__, name=decoratee.__name__)
+            )
+            self.event_dict = unique_append_to_inner_list(
+                data=self.event_dict, key=event.module_path(), value=function_definition
+            )
+
+            logger = get_logger()
+            logger.debug("Registered event '%s'", decoratee.__name__)
+
+            # Return decoratee
+            return decoratee
+
+        return decorator
+
+    def autodiscover(self) -> None:  # noqa: C901
+        """
+        Detects message registries which have been registered via the "register_*" decorator.
+        """
+        # Fetch registered handlers from cache if possible
+        self.command_dict, self.event_dict = self._load_handlers_from_cache()
+
+        # If the handlers were cached, we don't have to go through the file system
+        if len(self.command_dict) > 0 and len(self.event_dict) > 0:
+            return
+
+        # Project directory
+        project_path = get_queuebie_app_base_path()
+        logger = get_logger()
+
+        for app_config in apps.get_app_configs():
+            app_path = Path(app_config.path).resolve()
+
+            # If it's not a local app, we don't care
+            if project_path not in app_path.parents:
+                continue
+
+            for message_type in ("commands", "events"):
+                try:
+                    for module in os.listdir(app_path / "handlers" / message_type):
+                        if module[-3:] != ".py":
+                            continue
+                        module_name = module.replace(".py", "")
+                        module_path = f"{app_config.name}.handlers.{message_type}.{module_name}"
+                        sys_module = sys.modules.get(module_path)
+                        if sys_module:
+                            importlib.reload(sys_module)
+                        else:
+                            importlib.import_module(module_path)
+                        logger.debug(f'"{module_path}" imported.')
+                except FileNotFoundError:
+                    pass
+
+        # Log to shell which functions have been detected
+        logger.debug("Message autodiscovery running for commands...")
+        for command in self.command_dict:
+            handler_list = ", ".join(str(x) for x in self.command_dict[command])
+            logger.debug(f"* {command}: [{handler_list}]")
+        logger.debug("Message autodiscovery running for events...")
+        for event in self.event_dict:
+            handler_list = ", ".join(str(x) for x in self.event_dict[event])
+            logger.debug(f"* {event}: [{handler_list}]")
+
+        logger.debug(f"{len(self.command_dict) + len(self.event_dict)} message handlers detected.\n")
+
+        # Update cache
+        cache.set(get_queuebie_cache_key(), json.dumps({"commands": self.command_dict, "events": self.event_dict}))
+
+    def _load_handlers_from_cache(self) -> tuple[dict, dict]:
+        """
+        Get registered handler definitions from Django cache
+        """
+        cached_data = cache.get(get_queuebie_cache_key())
+        if cached_data is None:
+            return {}, {}
+        json_data = json.loads(cached_data)
+        cached_commands = json_data.get("commands", None)
+        cached_events = json_data.get("events", None)
+
+        return cached_commands, cached_events

queuebie/runner.py

@@ -0,0 +1,63 @@
+import importlib
+from contextlib import nullcontext
+
+from django.db import transaction
+
+from queuebie import message_registry
+from queuebie.database_blocker import BlockDatabaseAccess
+from queuebie.exceptions import InvalidMessageTypeError
+from queuebie.logger import get_logger
+from queuebie.messages import Command, Event, Message
+from queuebie.settings import get_queuebie_strict_mode
+
+
+def handle_message(messages: Message | list[Message]) -> None:
+    queue: list[Message] = messages if isinstance(messages, list) else [messages]
+
+    for message in queue:
+        if not isinstance(message, (Command, Event)):
+            raise InvalidMessageTypeError(class_name=message.__class__.__name__)
+
+    # Run auto-registry
+    message_registry.autodiscover()
+
+    with transaction.atomic():
+        while queue:
+            message = queue.pop(0)
+            if isinstance(message, Command):
+                handler_list = message_registry.command_dict.get(message.module_path(), [])
+                block_db_access = False
+            else:
+                handler_list = message_registry.event_dict.get(message.module_path(), [])
+                block_db_access = True if get_queuebie_strict_mode() else False
+
+            new_messages = _process_message(handler_list=handler_list, message=message, block_db_access=block_db_access)
+            queue.extend(new_messages)
+
+
+def _process_message(*, handler_list: list, message: [Command, Event], block_db_access: bool) -> list[Message]:
+    """
+    Handler to process messages of type "Command"
+    """
+    logger = get_logger()
+    messages = []
+
+    for handler in handler_list:
+        try:
+            logger.debug(
+                f"Handling command '{message.module_path()}' ({message.uuid}) with handler '{handler['name']}'."
+            )
+            module = importlib.import_module(handler["module"])
+            handler_function = getattr(module, handler["name"])
+            with BlockDatabaseAccess() if block_db_access else nullcontext():
+                handler_messages = handler_function(context=message) or []
+            handler_messages = handler_messages if isinstance(handler_messages, list) else [handler_messages]
+            if len(handler_messages) > 0:
+                messages.extend(handler_messages)
+            uuid_list = [f"{m!s}" for m in handler_messages]
+            logger.debug(f"New messages: {uuid_list!s}")
+        except Exception as e:
+            logger.debug(f"Exception handling command {message.module_path()}: {e!s}")
+            raise e from e
+
+    return messages

queuebie/settings.py

@@ -0,0 +1,32 @@
+from pathlib import Path
+
+from django.conf import settings
+
+
+def get_queuebie_app_base_path() -> Path | str:
+    """
+    Base path of the application queuebie should look for registered handlers.
+    :return:
+    """
+    return getattr(settings, "QUEUEBIE_APP_BASE_PATH", getattr(settings, "BASE_PATH", None))
+
+
+def get_queuebie_cache_key() -> str:
+    """
+    Cache key to store registered handlers in.
+    """
+    return getattr(settings, "QUEUEBIE_CACHE_KEY", "queuebie")
+
+
+def get_queuebie_logger_name() -> str:
+    """
+    Django logger name
+    """
+    return getattr(settings, "QUEUEBIE_LOGGER_NAME", "queuebie")
+
+
+def get_queuebie_strict_mode() -> bool:
+    """
+    Determines if commands are allowed to be imported across Django app borders.
+    """
+    return getattr(settings, "QUEUEBIE_STRICT_MODE", True)

queuebie/utils.py

@@ -0,0 +1,30 @@
+from collections.abc import Callable
+
+from django.apps import apps
+
+
+def is_part_of_app(*, function: Callable, class_type: type) -> bool:
+    """
+    Checks if a class belongs to the same Django app as the given function.
+    """
+
+    # Get the app configurations for the class and function
+    class_app_config = apps.get_containing_app_config(class_type.__module__)
+    function_app_config = apps.get_containing_app_config(function.__module__)
+
+    # Check if both belong to the same app
+    return class_app_config == function_app_config
+
+
+def unique_append_to_inner_list(*, data: dict, key: str | int, value) -> dict:
+    """
+    Inserts "value" in the dictionary "data" on "key".
+    If "key" doesn't exist yet, it will create a new list containing "value".
+    If "value" at "key" already exists, it won't be appended.
+    """
+    if key not in data:
+        data[key] = [value]
+    elif value not in data[key]:
+        data[key].append(value)
+
+    return data