django-queuebie 0.1.0__py2.py3-none-any.whl

django_queuebie-0.1.0.dist-info/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.1.0.dist-info/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.

django_queuebie-0.1.0.dist-info/METADATA

@@ -0,0 +1,205 @@
+Metadata-Version: 2.3
+Name: django-queuebie
+Version: 0.1.0
+Summary: Simple message queue for commands and events (CQRS)
+Author-email: Ambient Digital <hello@ambient.digital>
+Description-Content-Type: text/markdown
+Classifier: Development Status :: 4 - Beta
+Classifier: Environment :: Web Environment
+Classifier: Framework :: Django
+Classifier: Framework :: Django :: 4.2
+Classifier: Framework :: Django :: 5.0
+Classifier: Framework :: Django :: 5.1
+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-Dist: Django>=4.2
+Requires-Dist: typer~=0.12 ; extra == "dev"
+Requires-Dist: pytest-django~=4.9 ; extra == "dev"
+Requires-Dist: pytest-mock~=3.14 ; extra == "dev"
+Requires-Dist: coverage~=7.6 ; extra == "dev"
+Requires-Dist: pre-commit~=4.0 ; extra == "dev"
+Requires-Dist: ruff~=0.6 ; extra == "dev"
+Requires-Dist: sphinx~=7.1 ; extra == "dev"
+Requires-Dist: sphinx-rtd-theme~=2.0 ; extra == "dev"
+Requires-Dist: m2r2==0.3.3.post2 ; extra == "dev"
+Requires-Dist: mistune<2.0.0 ; extra == "dev"
+Requires-Dist: flit~=3.9 ; extra == "dev"
+Requires-Dist: keyring~=25.4 ; extra == "dev"
+Requires-Dist: ambient-package-update ; extra == "dev"
+Project-URL: Bugtracker, https://github.com/ambient-innovation/django-queuebie/issues
+Project-URL: Changelog, https://django-queuebie.readthedocs.io/en/latest/features/changelog.html
+Project-URL: Documentation, https://django-queuebie.readthedocs.io/en/latest/index.html
+Project-URL: Homepage, https://github.com/ambient-innovation/django-queuebie/
+Project-URL: Maintained by, https://ambient.digital/
+Provides-Extra: dev
+
+[![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 message queue for commands and events (CQRS) 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
+
+## Installation
+
+- Install the package via pip:
+
+  `pip install django_queuebie`
+
+  or via pipenv:
+
+  `pipenv install django_queuebie`
+
+- Add module to `INSTALLED_APPS` within the main django `settings.py`:
+
+    ```python
+    INSTALLED_APPS = (
+        # ...
+        "queuebie",
+    )
+    ```
+
+
+
+## Contribute
+
+### Setup package for development
+
+- Create a Python virtualenv and activate it
+- Install "pip-tools" with `pip install -U pip-tools`
+- Compile the requirements with `pip-compile --extra dev, -o requirements.txt pyproject.toml --resolver=backtracking`
+- Sync the dependencies with your virtualenv with `pip-sync`
+
+### Add functionality
+
+- Create a new branch for your feature
+- Change the dependency in your requirements.txt to a local (editable) one that points to your local file system:
+  `-e /Users/workspace/django-queuebie` or via pip  `pip install -e /Users/workspace/django-queuebie`
+- Ensure the code passes the tests
+- Create a pull request
+
+### Run tests
+
+- Run tests
+  ````
+  pytest --ds settings tests
+  ````
+
+- Check coverage
+  ````
+  coverage run -m pytest --ds settings tests
+  coverage report -m
+  ````
+
+### Git hooks (via pre-commit)
+
+We use pre-push hooks to ensure that only linted code reaches our remote repository and pipelines aren't triggered in
+vain.
+
+To enable the configured pre-push hooks, you need to [install](https://pre-commit.com/) pre-commit and run once:
+
+    pre-commit install -t pre-push -t pre-commit --install-hooks
+
+This will permanently install the git hooks for both, frontend and backend, in your local
+[`.git/hooks`](./.git/hooks) folder.
+The hooks are configured in the [`.pre-commit-config.yaml`](templates/.pre-commit-config.yaml.tpl).
+
+You can check whether hooks work as intended using the [run](https://pre-commit.com/#pre-commit-run) command:
+
+    pre-commit run [hook-id] [options]
+
+Example: run single hook
+
+    pre-commit run ruff --all-files
+
+Example: run all hooks of pre-push stage
+
+    pre-commit run --all-files --hook-stage push
+
+### Update documentation
+
+- To build the documentation, run: `sphinx-build docs/ docs/_build/html/`.
+- Open `docs/_build/html/index.html` to see the documentation.
+
+
+### Translation files
+
+If you have added custom text, make sure to wrap it in `_()` where `_` is
+gettext_lazy (`from django.utils.translation import gettext_lazy as _`).
+
+How to create translation file:
+
+* Navigate to `django-queuebie`
+* `python manage.py makemessages -l de`
+* Have a look at the new/changed files within `queuebie/locale`
+
+How to compile translation files:
+
+* Navigate to `django-queuebie`
+* `python manage.py compilemessages`
+* Have a look at the new/changed files within `queuebie/locale`
+
+
+### 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.
+
+### Publish to PyPi
+
+- Update documentation about new/changed functionality
+
+- Update the `Changelog`
+
+- Increment version in main `__init__.py`
+
+- Create pull request / merge to main
+
+- This project uses the flit package to publish to PyPI. Thus, publishing should be as easy as running:
+  ```
+  flit publish
+  ```
+
+  To publish to TestPyPI use the following to ensure that you have set up your .pypirc as
+  shown [here](https://flit.readthedocs.io/en/latest/upload.html#using-pypirc) and use the following command:
+
+  ```
+  flit publish --repository testpypi
+  ```
+
+### 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.1.0.dist-info/RECORD

@@ -0,0 +1,17 @@
+queuebie/__init__.py,sha256=fEdc8GP2WxdWAotrTBYmqywK_fAZhkIq72ITTcv0Bwo,207
+queuebie/apps.py,sha256=dTNk2xGvasXJncLUbbIjVQZrX7VYQsIdv_7ToFPy5b8,477
+queuebie/exceptions.py,sha256=B_vsZBEMqpWsxUp5RrokabiZOYfNEbV0nGxhhX0o5NY,711
+queuebie/logger.py,sha256=OWO9yiNxfnhUqejoR6RCUueKSWYzsMtfUBCmxAuAksk,244
+queuebie/messages.py,sha256=JcC7QxWzWllxDkwbYGefhaL1YWT_froOXa1NDugbGCM,1022
+queuebie/registry.py,sha256=F9kMwwl09ZEJYGHUKxg7zSPPXRzqOvQFOAFJy4tRY94,6149
+queuebie/runner.py,sha256=VmPCLQfWdvU3HjOscQyulG-emsNGMRkR3GwFuuTn-Jg,2252
+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.1.0.dist-info/LICENSE,sha256=VCMRQqZBDEG5HsJdp-Ps6a3-GFnpQZPzitGMRUHdgso,1093
+django_queuebie-0.1.0.dist-info/LICENSE.md,sha256=SiLpAPFRchFM_cDmWQIdItf_xPR6jeYCAaNUgpKWxV8,1102
+django_queuebie-0.1.0.dist-info/WHEEL,sha256=ssQ84EZ5gH1pCOujd3iW7HClo_O_aDaClUbX4B8bjKY,100
+django_queuebie-0.1.0.dist-info/METADATA,sha256=sX7mvm05fJwZO5LqjMvybDjFivZsrcdY5ETQMsRxfaQ,7536
+django_queuebie-0.1.0.dist-info/RECORD,,

django_queuebie-0.1.0.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: flit 3.10.1
+Root-Is-Purelib: true
+Tag: py2-none-any
+Tag: py3-none-any

queuebie/__init__.py

@@ -0,0 +1,8 @@
+"""Simple message queue for commands and events (CQRS)"""
+
+__version__ = "0.1.0"
+
+from queuebie.registry import MessageRegistry
+
+# Create 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/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:
+        """
+        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,58 @@
+import importlib
+
+from django.db import transaction
+
+from queuebie import message_registry
+from queuebie.exceptions import InvalidMessageTypeError
+from queuebie.logger import get_logger
+from queuebie.messages import Command, Event, Message
+
+
+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()
+
+    handler_list = []
+    while queue:
+        message = queue.pop(0)
+        if isinstance(message, Command):
+            handler_list = message_registry.command_dict.get(message.module_path(), [])
+        else:
+            handler_list = message_registry.event_dict.get(message.module_path(), [])
+
+        new_messages = _process_message(handler_list=handler_list, message=message)
+        queue.extend(new_messages)
+
+
+def _process_message(*, handler_list: list, message: [Command, Event]):
+    """
+    Handler to process messages of type "Command"
+    """
+    logger = get_logger()
+    messages = []
+
+    with transaction.atomic():
+        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"])
+                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