add app name in order to have unique key in case there are multiple app on the same redis db

Author: Morry98

.pre-commit-config.yaml

@@ -26,7 +26,7 @@ repos:
           - pre-commit
 
   - repo: https://github.com/pre-commit/mirrors-mypy
-    rev: v1.16.1
+    rev: v1.17.0
     hooks:
       - id: mypy
         additional_dependencies: [ "types-redis", "fastapi", "pydantic"]
@@ -35,7 +35,7 @@ repos:
 
   - repo: https://github.com/astral-sh/uv-pre-commit
     # uv version.
-    rev: 0.7.20
+    rev: 0.7.21
     hooks:
       - id: uv-lock
 

.python-version

@@ -0,0 +1 @@
+3.13

pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "fastapi-task-manager"
-version = "0.6.1"
+version = "0.7.0"
 description = "A task manager for Fastapi. Robust Scheduling, Distributed Safety"
 readme = "README.md"
 authors = [
@@ -37,12 +37,9 @@ dependencies = [
     "redis>=6.2.0",
 ]
 
-[project.scripts]
-fastapi-task-manager = "fastapi_task_manager:main"
-
 [build-system]
-requires = ["hatchling"]
-build-backend = "hatchling.build"
+requires = ["uv_build>=0.7.20,<0.8.0"]
+build-backend = "uv_build"
 
 [[tool.uv.index]]
 name = "testpypi"

src/fastapi_task_manager/config.py

@@ -7,6 +7,7 @@ class Config(BaseModel):
     # --------- End of logging config variables ---------
 
     # --------- App config variables ---------
+    app_name: str = __name__
     concurrent_tasks: int = 2
     statistics_redis_expiration: int = 432_000  # 5 days
     # --------- End of app config variables ---------

src/fastapi_task_manager/runner.py

@@ -76,8 +76,17 @@ async def _run(self):
                             self._running_tasks.pop(task, None)
 
                         next_run = datetime(year=2000, month=1, day=1, tzinfo=timezone.utc)
-                        if await self._redis_client.exists(task_group.name + "_" + task.name + "_next_run"):
-                            next_run_b = await self._redis_client.get(task_group.name + "_" + task.name + "_next_run")
+                        if await self._redis_client.exists(
+                            self._task_manager.config.app_name + "_" + task_group.name + "_" + task.name + "_next_run",
+                        ):
+                            next_run_b = await self._redis_client.get(
+                                self._task_manager.config.app_name
+                                + "_"
+                                + task_group.name
+                                + "_"
+                                + task.name
+                                + "_next_run",
+                            )
                             if next_run_b is not None:
                                 next_run = datetime.fromtimestamp(float(next_run_b.decode("utf-8")), tz=timezone.utc)
                         if next_run <= datetime.now(timezone.utc):
@@ -102,38 +111,52 @@ async def _queue_task(self, task: Task, task_group: TaskGroup):
 
     async def _run_task(self, task_group: TaskGroup, task: Task) -> None:  # noqa: PLR0912, C901  # TODO Reduce complexity
         try:
-            if await self._redis_client.exists(task_group.name + "_" + task.name + "_next_run"):
-                redis_next_run_b = await self._redis_client.get(task_group.name + "_" + task.name + "_next_run")
+            if await self._redis_client.exists(
+                self._task_manager.config.app_name + "_" + task_group.name + "_" + task.name + "_next_run",
+            ):
+                redis_next_run_b = await self._redis_client.get(
+                    self._task_manager.config.app_name + "_" + task_group.name + "_" + task.name + "_next_run",
+                )
                 if redis_next_run_b is None:
                     return
                 redis_next_run = datetime.fromtimestamp(float(redis_next_run_b.decode("utf-8")), tz=timezone.utc)
                 if redis_next_run > datetime.now(timezone.utc):
                     return
 
-            redis_uuid_exists = await self._redis_client.exists(task_group.name + "_" + task.name + "_runner_uuid")
+            redis_uuid_exists = await self._redis_client.exists(
+                self._task_manager.config.app_name + "_" + task_group.name + "_" + task.name + "_runner_uuid",
+            )
             if not redis_uuid_exists:
-                await self._redis_client.set(task_group.name + "_" + task.name + "_runner_uuid", self._uuid, ex=15)
+                await self._redis_client.set(
+                    self._task_manager.config.app_name + "_" + task_group.name + "_" + task.name + "_runner_uuid",
+                    self._uuid,
+                    ex=15,
+                )
                 # Wait a bit to ensure the UUID is set and not overwritten
                 await asyncio.sleep(0.2)
-            redis_uuid_b = await self._redis_client.get(task_group.name + "_" + task.name + "_runner_uuid")
+            redis_uuid_b = await self._redis_client.get(
+                self._task_manager.config.app_name + "_" + task_group.name + "_" + task.name + "_runner_uuid",
+            )
             if redis_uuid_b is None:
                 return
             if redis_uuid_b.decode("utf-8") != self._uuid:
                 return
 
             next_run = next_fire(task.expression)
             await self._redis_client.set(
-                task_group.name + "_" + task.name + "_next_run",
+                self._task_manager.config.app_name + "_" + task_group.name + "_" + task.name + "_next_run",
                 next_run.timestamp(),
                 # using max to ensure that the expiration isn't lower than 15 seconds
                 # in this way we avoid potential issues
                 ex=max(int((next_run - datetime.now(timezone.utc)).total_seconds()) * 2, 15),
             )
 
-            if await self._redis_client.exists(task_group.name + "_" + task.name + "_disabled"):
+            if await self._redis_client.exists(
+                self._task_manager.config.app_name + "_" + task_group.name + "_" + task.name + "_disabled",
+            ):
                 # Set the key in order to update the ttl
                 await self._redis_client.set(
-                    task_group.name + "_" + task.name + "_disabled",
+                    self._task_manager.config.app_name + "_" + task_group.name + "_" + task.name + "_disabled",
                     "1",
                     ex=self._task_manager.config.statistics_redis_expiration,
                 )
@@ -142,38 +165,50 @@ async def _run_task(self, task_group: TaskGroup, task: Task) -> None:  # noqa: P
             start = time.monotonic_ns()
             thread = asyncio.create_task(run_function(task.function))
             while not thread.done():
-                await self._redis_client.set(task_group.name + "_" + task.name + "_runner_uuid", self._uuid, ex=5)
+                await self._redis_client.set(
+                    self._task_manager.config.app_name + "_" + task_group.name + "_" + task.name + "_runner_uuid",
+                    self._uuid,
+                    ex=5,
+                )
                 await asyncio.sleep(0.1)
             end = time.monotonic_ns()
             runs = []  # TODO Evaluate redis linked lists
-            if await self._redis_client.exists(task_group.name + "_" + task.name + "_runs"):
-                runs_b = await self._redis_client.get(task_group.name + "_" + task.name + "_runs")
+            if await self._redis_client.exists(
+                self._task_manager.config.app_name + "_" + task_group.name + "_" + task.name + "_runs",
+            ):
+                runs_b = await self._redis_client.get(
+                    self._task_manager.config.app_name + "_" + task_group.name + "_" + task.name + "_runs",
+                )
                 if runs_b is not None:
                     runs = runs_b.decode("utf-8").split("\n")
             if len(runs) == 30:  # noqa: PLR2004  # TODO Configurable
                 runs.pop(0)
             runs.append(str(datetime.now(timezone.utc).timestamp()))
             await self._redis_client.set(
-                task_group.name + "_" + task.name + "_runs",
+                self._task_manager.config.app_name + "_" + task_group.name + "_" + task.name + "_runs",
                 "\n".join(runs),
                 ex=self._task_manager.config.statistics_redis_expiration,
             )
             durations_second = []  # TODO Evaluate redis linked lists
-            if await self._redis_client.exists(task_group.name + "_" + task.name + "_durations_second"):
+            if await self._redis_client.exists(
+                self._task_manager.config.app_name + "_" + task_group.name + "_" + task.name + "_durations_second",
+            ):
                 durations_second_b = await self._redis_client.get(
-                    task_group.name + "_" + task.name + "_durations_second",
+                    self._task_manager.config.app_name + "_" + task_group.name + "_" + task.name + "_durations_second",
                 )
                 if durations_second_b is not None:
                     durations_second = durations_second_b.decode("utf-8").split("\n")
             if len(durations_second) == 30:  # noqa: PLR2004  # TODO Configurable
                 durations_second.pop(0)
             durations_second.append(str((end - start) / 1e9))
             await self._redis_client.set(
-                task_group.name + "_" + task.name + "_durations_second",
+                self._task_manager.config.app_name + "_" + task_group.name + "_" + task.name + "_durations_second",
                 "\n".join(durations_second),
                 ex=self._task_manager.config.statistics_redis_expiration,
             )
-            await self._redis_client.delete(task_group.name + "_" + task.name + "_runner_uuid")
+            await self._redis_client.delete(
+                self._task_manager.config.app_name + "_" + task_group.name + "_" + task.name + "_runner_uuid",
+            )
 
         except asyncio.CancelledError:
             msg = f"Task {task.name} was cancelled."

src/fastapi_task_manager/task_router_services.py

@@ -47,23 +47,23 @@ def get_tasks(
                 continue
 
             runs = []  # TODO Evaluate redis linked lists
-            if redis_client.exists(tg.name + "_" + t.name + "_runs"):
-                runs_b = redis_client.get(tg.name + "_" + t.name + "_runs")
+            if redis_client.exists(task_manager.config.app_name + "_" + tg.name + "_" + t.name + "_runs"):
+                runs_b = redis_client.get(task_manager.config.app_name + "_" + tg.name + "_" + t.name + "_runs")
                 if runs_b is not None:
                     runs = runs_b.decode("utf-8").split("\n")
 
             durations_second = []  # TODO Evaluate redis linked lists
-            if redis_client.exists(tg.name + "_" + t.name + "_durations_second"):
+            if redis_client.exists(task_manager.config.app_name + "_" + tg.name + "_" + t.name + "_durations_second"):
                 durations_second_b = redis_client.get(
-                    tg.name + "_" + t.name + "_durations_second",
+                    task_manager.config.app_name + "_" + tg.name + "_" + t.name + "_durations_second",
                 )
                 if durations_second_b is not None:
                     durations_second = durations_second_b.decode("utf-8").split("\n")
             assert len(runs) == len(durations_second), "Runs and durations_second must have the same length"
 
             next_run = datetime(year=2000, month=1, day=1, tzinfo=timezone.utc)
-            if redis_client.exists(tg.name + "_" + t.name + "_next_run"):
-                next_run_b = redis_client.get(tg.name + "_" + t.name + "_next_run")
+            if redis_client.exists(task_manager.config.app_name + "_" + tg.name + "_" + t.name + "_next_run"):
+                next_run_b = redis_client.get(task_manager.config.app_name + "_" + tg.name + "_" + t.name + "_next_run")
                 if next_run_b is not None:
                     next_run = datetime.fromtimestamp(float(next_run_b.decode("utf-8")), tz=timezone.utc)
             list_to_return.append(
@@ -74,7 +74,9 @@ def get_tasks(
                     expression=t.expression,
                     high_priority=t.high_priority,
                     next_run=next_run,
-                    is_active=not redis_client.exists(tg.name + "_" + t.name + "_disabled"),
+                    is_active=not redis_client.exists(
+                        task_manager.config.app_name + "_" + tg.name + "_" + t.name + "_disabled",
+                    ),
                     runs=[
                         TaskRun(
                             run_date=datetime.fromtimestamp(float(runs[i]), timezone.utc),
@@ -115,7 +117,7 @@ def disable_task(
         db=task_manager.config.redis_db,
     )
     redis_client.set(
-        task_group.name + "_" + task.name + "_disabled",
+        task_manager.config.app_name + "_" + task_group.name + "_" + task.name + "_disabled",
         "1",
         ex=task_manager.config.statistics_redis_expiration,
     )
@@ -148,5 +150,5 @@ def enable_task(
         password=task_manager.config.redis_password,
         db=task_manager.config.redis_db,
     )
-    if redis_client.exists(task_group.name + "_" + task.name + "_disabled"):
-        redis_client.delete(task_group.name + "_" + task.name + "_disabled")
+    if redis_client.exists(task_manager.config.app_name + "_" + task_group.name + "_" + task.name + "_disabled"):
+        redis_client.delete(task_manager.config.app_name + "_" + task_group.name + "_" + task.name + "_disabled")