celery-beat-sqlalchemy 0.0.1__tar.gz

celery_beat_sqlalchemy-0.0.1/.gitignore

@@ -0,0 +1,8 @@
+venv
+.venv
+
+# Python stuff
+__pycache__
+
+# Pycharm
+.idea

celery_beat_sqlalchemy-0.0.1/LICENSE

@@ -0,0 +1,19 @@
+Copyright (c) 2026 sqlalchemy_celery_beat
+
+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.

celery_beat_sqlalchemy-0.0.1/PKG-INFO

@@ -0,0 +1,13 @@
+Metadata-Version: 2.4
+Name: celery-beat-sqlalchemy
+Version: 0.0.1
+Summary: Library for managing celery beat schedule through sqlalchemy models
+Project-URL: Homepage, https://github.com/ebergard/sqlalchemy_celery_beat
+Author-email: Kseniia Ebergard <ebergard-xu@bk.ru>
+License-File: LICENSE
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3
+Requires-Python: >=3.8.0
+Requires-Dist: celery>=5.4.0
+Requires-Dist: sqlalchemy>=2.0.0

celery_beat_sqlalchemy-0.0.1/pyproject.toml

@@ -0,0 +1,25 @@
+[build-system]
+requires = ["hatchling"]
+build-backend = "hatchling.build"
+
+[project]
+name = "celery-beat-sqlalchemy"
+version = "0.0.1"
+authors = [
+ { name="Kseniia Ebergard", email="ebergard-xu@bk.ru" },
+]
+description = "Library for managing celery beat schedule through sqlalchemy models"
+readme = "README.md"
+requires-python = ">=3.8.0"
+dependencies = [
+    "celery>=5.4.0",
+    "sqlalchemy>=2.0.0"
+]
+classifiers = [
+   "Programming Language :: Python :: 3",
+   "License :: OSI Approved :: MIT License",
+   "Operating System :: OS Independent",
+]
+
+[project.urls]
+Homepage = "https://github.com/ebergard/sqlalchemy_celery_beat"

celery_beat_sqlalchemy-0.0.1/src/celery_beat_sqlalchemy/db.py

@@ -0,0 +1,18 @@
+import contextlib
+from collections.abc import Generator
+from typing import Any
+
+from celery import current_app as celery_app
+from sqlalchemy import NullPool, create_engine
+from sqlalchemy.orm import Session
+
+engine = create_engine(url=celery_app.conf.beat_db_scheduler_dsn, future=True, poolclass=NullPool)
+
+
+@contextlib.contextmanager
+def db_sessionmaker() -> Generator[Session, Any, None]:
+    with (
+        engine.connect() as conn,
+        Session(bind=conn, expire_on_commit=False, autoflush=False) as session,
+    ):
+        yield session

celery_beat_sqlalchemy-0.0.1/src/celery_beat_sqlalchemy/models/base.py

@@ -0,0 +1,3 @@
+from sqlalchemy.orm import declarative_base
+
+CeleryTasksScheduleBase = declarative_base()

celery_beat_sqlalchemy-0.0.1/src/celery_beat_sqlalchemy/models/celery_tasks.py

@@ -0,0 +1,79 @@
+from sqlalchemy import (
+    Column,
+    DateTime,
+    String,
+    bindparam,
+    delete,
+    func,
+    insert,
+    or_,
+    select,
+    update,
+)
+from sqlalchemy.orm import relationship
+
+from ..db import db_sessionmaker
+from ..schemas.db.celery_tasks import CeleryTasksDbSchema
+from .base import CeleryTasksScheduleBase
+
+
+class CeleryTasksModel(CeleryTasksScheduleBase):
+    """Application celery tasks."""
+
+    __tablename__ = "celery_tasks"
+
+    task = Column(String, primary_key=True, unique=True)
+    params = Column(String, nullable=False, server_default="")
+    description = Column(String, nullable=False, server_default="")
+    tags = Column(String, nullable=False, server_default="")
+    created_at = Column(DateTime(timezone=True), server_default=func.now())
+    updated_at = Column(DateTime(timezone=True), onupdate=func.now())
+
+    scheduled_tasks = relationship(
+        "CeleryTasksScheduleModel",
+        back_populates="task_head",
+        lazy="selectin",
+        cascade="all, delete-orphan",
+    )
+
+    @classmethod
+    def bulk_insert(cls, data: list[CeleryTasksDbSchema]):
+        with db_sessionmaker() as session, session.begin():
+            existing_tasks = set((session.execute(select(cls.task))).scalars().all())
+            tasks_to_insert = {d.task for d in data}
+            missing_tasks = tasks_to_insert - existing_tasks
+            if missing_tasks:
+                stmt = insert(cls).values(**CeleryTasksDbSchema.get_bindparams())
+                session.execute(stmt, [d.model_dump() for d in data if d.task in missing_tasks])
+
+    @classmethod
+    def bulk_update(cls, data: list[CeleryTasksDbSchema]):
+        with db_sessionmaker() as session, session.begin():
+            stmt = (
+                update(cls)
+                .where(
+                    cls.task == bindparam("task_value"),
+                    or_(
+                        cls.params != bindparam("params_value"),
+                        cls.description != bindparam("description_value"),
+                    ),
+                )
+                .values(**CeleryTasksDbSchema.get_bindparams(exclude=["tags"]))
+                .execution_options(synchronize_session=None)
+            )
+            session.connection().execute(stmt, [d.model_dump() for d in data])
+
+    @classmethod
+    def select_all_tasks(cls) -> list[str]:
+        with db_sessionmaker() as session, session.begin():
+            stmt = select(cls.task)
+            return (session.execute(stmt)).scalars().all()
+
+    @classmethod
+    def delete(cls, tasks: list[str]):
+        with db_sessionmaker() as session, session.begin():
+            stmt = delete(cls).where(cls.task.in_(tasks))
+            session.execute(stmt)
+
+    def __repr__(self):
+        return f"{self.task}"

celery_beat_sqlalchemy-0.0.1/src/celery_beat_sqlalchemy/models/celery_tasks_schedule.py

@@ -0,0 +1,175 @@
+import json
+from json import JSONDecodeError
+
+from celery import current_app as celery_app
+from celery.beat import debug
+from celery.schedules import crontab
+from sqlalchemy import (
+    BigInteger,
+    Boolean,
+    Column,
+    DateTime,
+    ForeignKey,
+    String,
+    delete,
+    event,
+    func,
+    insert,
+    select,
+    true,
+)
+from sqlalchemy.orm import relationship
+
+from ..db import db_sessionmaker
+from ..schemas.db.celery_tasks_schedule import CeleryTasksScheduleDbSchema
+from ..utils import get_task_key
+from .base import CeleryTasksScheduleBase
+from .celery_tasks_schedule_meta import CeleryTasksScheduleMetaModel
+
+
+class CeleryTasksScheduleModel(CeleryTasksScheduleBase):
+    """Celery tasks schedule."""
+
+    __tablename__ = "celery_tasks_schedule"
+
+    id = Column(BigInteger, primary_key=True)
+    task = Column(
+        String,
+        ForeignKey("celery_tasks.task", ondelete="CASCADE"),
+        nullable=False,
+        doc="Task name (Example: my_task)",
+    )
+    args = Column(
+        String,
+        nullable=False,
+        server_default="[]",
+        default="[]",
+        doc='Task positional arguments (Example: ["arg1", 2])',
+    )
+    kwargs = Column(
+        String,
+        nullable=False,
+        server_default="{}",
+        default="{}",
+        doc='Task keyword arguments (Example: {"kwarg1": true})',
+    )
+    schedule = Column(
+        String,
+        nullable=False,
+        doc="Crontab schedule [minute hour day_of_month month day_of_week] (Example: */2 * * * *)",
+    )
+    enabled = Column(
+        Boolean,
+        nullable=False,
+        server_default=true(),
+        default="checked",
+        doc="Enable/disable task execution",
+    )
+    created_at = Column(
+        DateTime(timezone=True), server_default=func.now(), doc="Datetime this task was created"
+    )
+    updated_at = Column(
+        DateTime(timezone=True), onupdate=func.now(), doc="Datetime this task was last modified"
+    )
+    comment = Column(String, nullable=True, doc="Any comment")
+    task_key = Column(String, nullable=False, unique=True)
+
+    task_head = relationship("CeleryTasksModel", back_populates="scheduled_tasks", lazy="selectin")
+
+    @classmethod
+    def bulk_insert(cls, data: list[CeleryTasksScheduleDbSchema]):
+        with db_sessionmaker() as session, session.begin():
+            existing_entries = set((session.execute(select(cls.task_key))).scalars().all())
+            entries_to_insert = {d.task_key for d in data}
+            missing_entries = entries_to_insert - existing_entries
+            if missing_entries:
+                stmt = insert(cls).values(**CeleryTasksScheduleDbSchema.get_bindparams())
+                session.execute(
+                    stmt, [d.model_dump() for d in data if d.task_key in missing_entries]
+                )
+
+    @classmethod
+    def select_all_tasks(cls) -> list[str]:
+        with db_sessionmaker() as session, session.begin():
+            stmt = select(cls.task)
+            return (session.execute(stmt)).scalars().all()
+
+    @classmethod
+    def select_enabled_entries(cls):
+        with db_sessionmaker() as session, session.begin():
+            stmt = select(cls).where(cls.enabled)
+            return (session.execute(stmt)).scalars().all()
+
+    @classmethod
+    def delete(cls, tasks: list[str]):
+        with db_sessionmaker() as session, session.begin():
+            stmt = delete(cls).where(cls.task.in_(tasks))
+            session.execute(stmt)
+
+    def __repr__(self):
+        return (
+            f"Task: {self.task} Args: {self.args} Kwargs: {self.kwargs} Schedule: {self.schedule}"
+        )
+
+
+@event.listens_for(CeleryTasksScheduleModel, "before_insert")
+def before_insert_handler(mapper, connection, target: CeleryTasksScheduleModel):
+    before_validator(mapper, connection, target)
+
+
+@event.listens_for(CeleryTasksScheduleModel, "before_update")
+def before_update_handler(mapper, connection, target: CeleryTasksScheduleModel):
+    before_validator(mapper, connection, target)
+
+
+@event.listens_for(CeleryTasksScheduleModel, "after_insert")
+def after_insert_handler(mapper, connection, target: CeleryTasksScheduleModel):
+    CeleryTasksScheduleMetaModel.update_last_updated_at()
+
+
+@event.listens_for(CeleryTasksScheduleModel, "after_update")
+def after_update_handler(mapper, connection, target: CeleryTasksScheduleModel):
+    CeleryTasksScheduleMetaModel.update_last_updated_at()
+
+
+@event.listens_for(CeleryTasksScheduleModel, "after_delete")
+def after_delete_handler(mapper, connection, target: CeleryTasksScheduleModel):
+    CeleryTasksScheduleMetaModel.update_last_updated_at()
+
+
+def before_validator(mapper, connection, target):
+    if target.task not in celery_app.tasks:
+        raise RuntimeError(f"Task '{target.task}' does not exist")
+
+    try:
+        args = json.loads(target.args)
+    except JSONDecodeError as e:
+        raise RuntimeError(f"Invalid format for task positional arguments: {e}")
+
+    try:
+        kwargs = json.loads(target.kwargs)
+    except JSONDecodeError as e:
+        raise RuntimeError(f"Invalid format for task keyword arguments: {e}")
+
+    task = celery_app.tasks[target.task]
+    try:
+        check_arguments = task.__header__
+    except AttributeError:  # pragma: no cover
+        debug(f"Task '{task}' has no attribute '__header__': cannot validate arguments")
+    else:
+        check_arguments(*(args or ()), **(kwargs or {}))
+
+    try:
+        minute, hour, day_of_month, month_of_year, day_of_week = target.schedule.split()
+        crontab(
+            minute=minute,
+            hour=hour,
+            day_of_week=day_of_week,
+            day_of_month=day_of_month,
+            month_of_year=month_of_year,
+        )
+    except Exception as e:
+        raise RuntimeError(f"Invalid schedule: {e}")
+
+    # Generate unique task key
+    target.task_key = get_task_key(target.task, args, kwargs)

celery_beat_sqlalchemy-0.0.1/src/celery_beat_sqlalchemy/models/celery_tasks_schedule_meta.py

@@ -0,0 +1,46 @@
+import datetime as dt
+
+from sqlalchemy import (
+    BigInteger,
+    Column,
+    DateTime,
+    func,
+    insert,
+    select,
+    update,
+)
+
+from ..db import db_sessionmaker
+from .base import CeleryTasksScheduleBase
+
+
+class CeleryTasksScheduleMetaModel(CeleryTasksScheduleBase):
+    """Keeps time when celery_tasks_schedule table was last updated."""
+
+    __tablename__ = "celery_tasks_schedule_meta"
+
+    id = Column(BigInteger, primary_key=True)
+    last_updated_at = Column(DateTime(timezone=True), nullable=False, server_default=func.now())
+
+    @classmethod
+    def init_last_updated_at(cls):
+        with db_sessionmaker() as session, session.begin():
+            entry = (session.execute(select(cls).where(cls.id == 1))).scalars().first()
+            if not entry:
+                stmt = insert(cls).values(id=1, last_updated_at=dt.datetime.now(tz=dt.UTC))
+                session.execute(stmt)
+
+    @classmethod
+    def update_last_updated_at(cls):
+        with db_sessionmaker() as session, session.begin():
+            stmt = update(cls).where(cls.id == 1).values(last_updated_at=dt.datetime.now(tz=dt.UTC))
+            session.execute(stmt)
+
+    @classmethod
+    def get_last_updated_at(cls) -> dt.datetime:
+        with db_sessionmaker() as session, session.begin():
+            stmt = select(cls.last_updated_at).where(cls.id == 1)
+            return (session.execute(stmt)).scalars().first()
+
+    def __repr__(self):
+        return f"{self.last_updated_at}"

celery_beat_sqlalchemy-0.0.1/src/celery_beat_sqlalchemy/scheduler.py

@@ -0,0 +1,221 @@
+import datetime as dt
+import enum
+import inspect
+import json
+import time
+
+from celery.beat import ScheduleEntry, Scheduler, debug, error
+from celery.schedules import crontab
+from celery.utils.time import get_exponential_backoff_interval
+from sqlalchemy.exc import DatabaseError
+
+from .db import engine
+from .models.base import CeleryTasksScheduleBase
+from .models.celery_tasks import CeleryTasksModel
+from .models.celery_tasks_schedule import CeleryTasksScheduleModel
+from .models.celery_tasks_schedule_meta import CeleryTasksScheduleMetaModel
+from .schemas.db.celery_tasks import CeleryTasksDbSchema
+from .schemas.db.celery_tasks_schedule import CeleryTasksScheduleDbSchema
+from .utils import get_task_category, get_task_key
+
+DEFAULT_MAX_LOOP_INTERVAL = 5  # seconds
+MAX_SYNC_SCHEDULE_INTERVAL = 5  # minutes
+PREPARE_MODELS_MAX_RETRIES = 10
+
+
+class DatabaseScheduler(Scheduler):
+    """Database-backed Beat Scheduler."""
+
+    ModelTask = CeleryTasksModel
+    ModelSchedule = CeleryTasksScheduleModel
+    ModelMeta = CeleryTasksScheduleMetaModel
+
+    _schedule = None
+    _last_updated_at = None
+
+    def __init__(self, *args, **kwargs):
+        """Initialize the database scheduler."""
+        Scheduler.__init__(self, *args, **kwargs)
+        self.max_interval = (
+            kwargs.get("max_interval")
+            or self.app.conf.beat_max_loop_interval
+            or DEFAULT_MAX_LOOP_INTERVAL
+        )
+
+    @property
+    def schedule(self):
+        self._schedule = self._schedule or {}
+        if self._need_update():
+            self._update_schedule()
+        return self._schedule
+
+    def setup_schedule(self):
+        debug("Setup schedule")
+        self._prepare_models()
+        self._clean_deprecated()
+        self._fill_celery_tasks()
+        self._fill_celery_tasks_schedule()
+        self._update_schedule()
+
+    def _fill_celery_tasks(self):
+        """Fill celery_tasks table with application celery tasks."""
+
+        def convert_type(param_type) -> str:
+            if param_type is inspect._empty:
+                return ""
+            if type(param_type) is type:
+                return param_type.__name__
+            if type(param_type) is enum.EnumType:
+                return f"<one of: {", ".join(set(st.value for st in param_type))}>"
+            return str(param_type)
+
+        def get_annotation(param_annotation) -> str:
+            if param_annotation is inspect._empty:
+                return ""
+            return f": {convert_type(param_annotation)}"
+
+        def get_default(param_default) -> str:
+            if param_default is inspect._empty:
+                return ""
+            return f" [default: {convert_type(param_default)}]"
+
+        if self.app.tasks:
+            db_entries = [
+                CeleryTasksDbSchema(
+                    task=task_name,
+                    params=", ".join(
+                        [
+                            f"{name}{get_annotation(param.annotation)}{get_default(param.default)}"
+                            for name, param in inspect.signature(task).parameters.items()
+                            if name != "kwargs"
+                        ]
+                    ),
+                    description=inspect.getdoc(task) if task.__doc__ else "",
+                    tags=get_task_category(task.__module__),
+                )
+                for task_name, task in sorted(self.app.tasks.items(), key=lambda item: item[0])
+                if not task_name.startswith("celery.")
+            ]
+            self.ModelTask.bulk_insert(data=db_entries)
+            self.ModelTask.bulk_update(data=db_entries)
+
+    def _fill_celery_tasks_schedule(self):
+        """Fill celery_tasks_schedule table with application beat schedule."""
+        if self.app.conf.beat_schedule:
+            comment = (
+                f"loaded from app celery beat schedule on {dt.datetime.now(tz=dt.UTC).isoformat()}"
+            )
+            db_entries = [
+                CeleryTasksScheduleDbSchema(
+                    task_key=get_task_key(task["task"], task["args"], task["kwargs"]),
+                    task=task["task"],
+                    args=json.dumps(task["args"]),
+                    kwargs=json.dumps(task["kwargs"]),
+                    schedule=(
+                        f"{task["schedule"]._orig_minute} "
+                        f"{task["schedule"]._orig_hour} "
+                        f"{task["schedule"]._orig_day_of_month} "
+                        f"{task["schedule"]._orig_month_of_year} "
+                        f"{task["schedule"]._orig_day_of_week}"
+                    ),
+                    comment=comment,
+                )
+                for task in self.app.conf.beat_schedule.values()
+            ]
+            self.ModelSchedule.bulk_insert(data=db_entries)
+
+    def update_from_dict(self, dict_):
+        self._schedule = self._schedule or {}
+        self._schedule.update(
+            {name: self._maybe_entry(name, entry) for name, entry in dict_.items()}
+        )
+
+    def _need_update(self) -> bool:
+        now = dt.datetime.now(tz=dt.UTC)
+
+        if self.max_interval < 30:  # noqa
+            # Don't update at the beginning and at the end of a minute
+            # to avoid overriding current heap
+            if 0 <= now.second < 20 or now.second > 50:  # noqa
+                return False
+
+        # Sync beat schedule with db every 5 minutes
+        # in case we didn't get sqlalchemy update event
+        sync_threshold = now - dt.timedelta(minutes=MAX_SYNC_SCHEDULE_INTERVAL)
+
+        if (  # noqa
+            self._last_updated_at is None
+            or self._last_updated_at < sync_threshold
+            or self._last_updated_at < self.ModelMeta.get_last_updated_at()
+        ):
+            return True
+        return False
+
+    def _update_schedule(self):
+        enabled_tasks = self._get_enabled_tasks()
+        self._schedule = enabled_tasks
+        self._last_updated_at = dt.datetime.now(tz=dt.UTC)
+        self.install_default_entries(self._schedule)
+        debug("Current schedule:\n" + "\n".join(repr(entry) for entry in self._schedule.values()))
+
+    def _get_enabled_tasks(self) -> dict[str, ScheduleEntry]:
+        """Return list of enabled periodic tasks."""
+        rows = self.ModelSchedule.select_enabled_entries()
+        entries = {}
+        for row in rows:
+            try:
+                entries[row.task_key] = self._model_to_entry(model=row)
+            except Exception as e:
+                error(str(e))
+        return entries
+
+    def _model_to_entry(self, model: CeleryTasksScheduleModel) -> ScheduleEntry:
+        args = json.loads(model.args)
+        kwargs = json.loads(model.kwargs)
+        minute, hour, day_of_month, month_of_year, day_of_week = model.schedule.split()
+        schedule = crontab(
+            minute=minute,
+            hour=hour,
+            day_of_week=day_of_week,
+            day_of_month=day_of_month,
+            month_of_year=month_of_year,
+        )
+        entry_dict = {
+            "task": model.task,
+            "args": args,
+            "kwargs": kwargs,
+            "schedule": schedule,
+        }
+        return self._maybe_entry(model.task_key, entry_dict)
+
+    def _prepare_models(self):
+        # ###
+        # COPIED from: celery.backends.database.session.SessionManager.prepare_models
+        # ###
+        # SQLAlchemy will check if the items exist before trying to
+        # create them, which is a race condition. If it raises an error
+        # in one iteration, the next may pass all the existence checks
+        # and the call will succeed.
+        retries = 0
+        while True:
+            try:
+                CeleryTasksScheduleBase.metadata.create_all(engine)
+            except DatabaseError:
+                if retries < PREPARE_MODELS_MAX_RETRIES:
+                    sleep_amount_ms = get_exponential_backoff_interval(10, retries, 1000, True)
+                    time.sleep(sleep_amount_ms / 1000)
+                    retries += 1
+                else:
+                    raise
+            else:
+                break
+
+        self.ModelMeta.init_last_updated_at()
+
+    def _clean_deprecated(self):
+        """Sync celery_tasks table with application tasks."""
+        tasks = set(self.app.tasks)
+        db_tasks = set(self.ModelTask.select_all_tasks())
+        deprecated_tasks = db_tasks - tasks
+        if deprecated_tasks:
+            self.ModelTask.delete(tasks=list(deprecated_tasks))

celery_beat_sqlalchemy-0.0.1/src/celery_beat_sqlalchemy/schemas/db/base.py

@@ -0,0 +1,18 @@
+from dataclasses import dataclass, fields
+
+from sqlalchemy import bindparam
+
+from ...utils import db_bindparam
+
+
+@dataclass
+class BindparamDbSchema:
+    @classmethod
+    def get_bindparams(cls, exclude: list[str] | None = None):
+        exclude = exclude or []
+        return {
+            f.name: bindparam(db_bindparam(f.name)) for f in fields(cls) if f.name not in exclude
+        }
+
+    def model_dump(self):
+        return {db_bindparam(f.name): getattr(self, f.name) for f in fields(self)}

celery_beat_sqlalchemy-0.0.1/src/celery_beat_sqlalchemy/schemas/db/celery_tasks.py

@@ -0,0 +1,11 @@
+from dataclasses import dataclass
+
+from .base import BindparamDbSchema
+
+
+@dataclass
+class CeleryTasksDbSchema(BindparamDbSchema):
+    task: str
+    params: str
+    description: str
+    tags: str

celery_beat_sqlalchemy-0.0.1/src/celery_beat_sqlalchemy/schemas/db/celery_tasks_schedule.py

@@ -0,0 +1,14 @@
+from dataclasses import dataclass
+
+from .base import BindparamDbSchema
+
+
+@dataclass
+class CeleryTasksScheduleDbSchema(BindparamDbSchema):
+    task_key: str
+    task: str
+    args: str
+    kwargs: str
+    schedule: str
+    enabled: bool = True
+    comment: str | None = None

celery_beat_sqlalchemy-0.0.1/src/celery_beat_sqlalchemy/utils.py

@@ -0,0 +1,26 @@
+import re
+
+
+def get_task_key(name, args, kwargs) -> str:
+    """
+    Get task unique identifier.
+    The same task can be run with different args/kwargs, and they are different entries for celery beat.
+    To uniquely identify those entries we use combination of task_name-args-kwargs.
+    """
+    args = "-".join(map(str, args))
+    kwargs = "-".join([f"{k}-{v}" for k, v in kwargs.items()])
+    # Zabbix compatible key format: 0-9a-zA-Z_-.
+    return re.sub(r"[\[\](){}, '\"]", "", f"{name}-{args}-{kwargs}".strip("-"))
+
+
+def get_task_category(task_module: str):
+    """
+    Get task category by its module:
+    src.apps.users.tasks -> users;
+    src.apps.base.tasks.tasks -> base.
+    """
+    return task_module.replace(".tasks", "").split(".")[-1]
+
+
+def db_bindparam(name: str) -> str:
+    return f"{name}_value"