asyncz 0.8.1__tar.gz → 0.8.3__tar.gz

{asyncz-0.8.1 → asyncz-0.8.3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: asyncz
-Version: 0.8.1
+Version: 0.8.3
 Summary: The scheduler that nobody wants but every application needs.
 Project-URL: Homepage, https://github.com/dymmond/asyncz
 Project-URL: Documentation, https://asyncz.dymmond.com/

asyncz-0.8.3/asyncz/__init__.py

@@ -0,0 +1 @@
+__version__ = "0.8.3"

{asyncz-0.8.1 → asyncz-0.8.3}/asyncz/datastructures.py

@@ -1,4 +1,5 @@
-from datetime import datetime, timedelta, timezone, tzinfo
+from datetime import datetime, timedelta, tzinfo
+from datetime import timezone as dt_timezone
 from typing import TYPE_CHECKING, Any, Callable, List, Optional, Union
 
 from pydantic import BaseModel, ConfigDict
@@ -28,11 +29,11 @@ class IntervalState(BaseDatastructureState):
     Handles the state for a IntervalTrigger.
     """
 
-    timezone: Union[timezone, str, tzinfo]
+    timezone: Union[dt_timezone, str, tzinfo]
     start_at: datetime
     end_at: Optional[datetime] = None
-    interval: Optional[Union[timezone, timedelta]] = None
-    jitter: int
+    interval: Optional[Union[dt_timezone, timedelta]] = None
+    jitter: Optional[int] = None
 
 
 class CombinationState(BaseDatastructureState):
@@ -49,7 +50,7 @@ class CronState(BaseDatastructureState):
     Handles the state of the CronTrigger.
     """
 
-    timezone: Optional[Union[timezone, str, tzinfo]] = None
+    timezone: Optional[Union[dt_timezone, str, tzinfo]] = None
     start_at: Optional[datetime] = None
     end_at: Optional[datetime] = None
     fields: Optional[List[Any]] = None

{asyncz-0.8.1 → asyncz-0.8.3}/asyncz/executors/base.py

@@ -97,9 +97,7 @@ class BaseExecutor(BaseStateExtra, ABC):
             if self.instances[task_id] == 0:
                 del self.instances[task_id]
 
-        self.logger.opt(exception=True).error(
-            f"Error running task {task_id}", exc_info=True
-        )
+        self.logger.opt(exception=True).error(f"Error running task {task_id}", exc_info=True)
 
 
 def run_task(

{asyncz-0.8.1 → asyncz-0.8.3}/asyncz/schedulers/base.py

@@ -155,7 +155,6 @@ class BaseScheduler(BaseStateExtra, ABC):
             raise SchedulerAlreadyRunningError()
 
         self.check_uwsgi()
-
         with self.executor_lock:
             if "default" not in self.executors:
                 self.add_executor(self.create_default_executor(), "default")
@@ -414,7 +413,6 @@ class BaseScheduler(BaseStateExtra, ABC):
         }
         task_kwargs = {key: value for key, value in task_struct.items() if value is not undefined}
         task = Task(self, **task_kwargs)
-
         with self.store_lock:
             if self.state == SchedulerState.STATE_STOPPED:
                 self.pending_tasks.append((task, store, replace_existing))
@@ -667,7 +665,7 @@ class BaseScheduler(BaseStateExtra, ABC):
 
         task_defaults = config.get("task_defaults", {})
         self.task_defaults = TaskDefaultStruct(
-            mistrigger_grace_time=to_int(task_defaults.get("mistrigger_grace_time")),
+            mistrigger_grace_time=to_int(task_defaults.get("mistrigger_grace_time", 1)),
             coalesce=to_bool(task_defaults.get("coalesce", True)),
             max_instances=to_int(task_defaults.get("max_instances", 1)),
         )
@@ -825,7 +823,6 @@ class BaseScheduler(BaseStateExtra, ABC):
 
         # Apply replacements
         task._update(**replacements)
-
         # Add the task to the given store
         store = self.lookup_store(store_alias)
         try:

{asyncz-0.8.1 → asyncz-0.8.3}/asyncz/stores/memory.py

@@ -11,7 +11,7 @@ if TYPE_CHECKING:
 
 class MemoryStore(BaseStore):
     """
-    Stores tasks in an arrat in RAM. Provides no persistance support.
+    Stores tasks in an array in RAM. Provides no persistance support.
     """
 
     def __init__(self, **kwargs):

{asyncz-0.8.1 → asyncz-0.8.3}/asyncz/triggers/interval.py

@@ -6,13 +6,7 @@ from tzlocal import get_localzone
 
 from asyncz.datastructures import IntervalState
 from asyncz.triggers.base import BaseTrigger
-from asyncz.utils import (
-    datetime_repr,
-    normalize,
-    timedelta_seconds,
-    to_datetime,
-    to_timezone,
-)
+from asyncz.utils import datetime_repr, normalize, timedelta_seconds, to_datetime, to_timezone
 
 
 class IntervalTrigger(BaseTrigger):
@@ -79,9 +73,7 @@ class IntervalTrigger(BaseTrigger):
             next_trigger_time = self.start_at
         else:
             time_difference_seconds = timedelta_seconds(now - self.start_at)
-            next_interval_number = int(
-                ceil(time_difference_seconds / self.interval_size)
-            )
+            next_interval_number = int(ceil(time_difference_seconds / self.interval_size))
             next_trigger_time = self.start_at + self.interval * next_interval_number
 
         if self.jitter is not None:

{asyncz-0.8.1 → asyncz-0.8.3}/asyncz/utils.py

@@ -234,10 +234,14 @@ def ref_to_obj(ref: str) -> Any:
         raise AsynczLookupError(
             "Error resolving reference %s: could not import module" % ref
         ) from None
-
     try:
         for name in rest.split("."):
             obj = getattr(obj, name)
+
+        # It might come from a class containing the fn attribute
+        # implementation of the __call__ method
+        if hasattr(obj, "fn"):
+            obj = obj.fn
         return obj
     except Exception:
         raise AsynczLookupError(

asyncz-0.8.1/asyncz/__init__.py

@@ -1 +0,0 @@
-__version__ = "0.8.1"

asyncz-0.8.1/asyncz/contrib/esmerald/decorator.py

@@ -1,40 +0,0 @@
-from datetime import datetime
-from typing import Any, Dict, Optional
-
-from asyncz.contrib.esmerald.scheduler import Task
-from asyncz.triggers.types import TriggerType
-
-
-class scheduler(Task):
-    def __init__(
-        self,
-        *,
-        name: Optional[str] = None,
-        trigger: Optional[TriggerType] = None,
-        id: Optional[str] = None,
-        mistrigger_grace_time: Optional[int] = None,
-        coalesce: Optional[bool] = None,
-        max_instances: Optional[int] = None,
-        next_run_time: Optional[datetime] = None,
-        store: Optional[str] = "default",
-        executor: Optional[str] = "default",
-        replace_existing: bool = True,
-        extra_args: Optional[Any] = None,
-        extra_kwargs: Optional[Dict[str, Any]] = None,
-        is_enabled: bool = True,
-    ) -> None:
-        super().__init__(
-            name=name,
-            trigger=trigger,
-            id=id,
-            mistrigger_grace_time=mistrigger_grace_time,
-            coalesce=coalesce,
-            max_instances=max_instances,
-            next_run_time=next_run_time,
-            store=store,
-            executor=executor,
-            replace_existing=replace_existing,
-            args=extra_args,
-            kwargs=extra_kwargs,
-            is_enabled=is_enabled,
-        )

asyncz-0.8.1/asyncz/contrib/esmerald/scheduler.py

@@ -1,217 +0,0 @@
-import warnings
-from datetime import datetime
-from datetime import timezone as dtimezone
-from typing import TYPE_CHECKING, Any, Dict, Optional, Union
-
-from asyncz.schedulers.types import SchedulerType
-from asyncz.triggers.types import TriggerType
-from asyncz.typing import undefined
-
-try:
-    from esmerald.conf import settings
-    from esmerald.exceptions import ImproperlyConfigured
-    from esmerald.utils.module_loading import import_string
-except ImportError:
-    raise ImportError(
-        "Esmerald cannot be found. Please install it by running `pip install esmerald`."
-    ) from None
-
-if TYPE_CHECKING:
-    from esmerald.applications import Esmerald
-
-
-class EsmeraldScheduler:
-    """
-    Scheduler instance to be used by the Esmerald application instance.
-
-    Args:
-        app: Esmerald application
-        scheduler_class: An instance of a SchedulerType
-        tasks: A dictinary str, str mapping the tasks to be executed.
-        timezone: The timezone instance.
-        configurations: A dictionary with extra configurations to be passed to the scheduler.
-    """
-
-    def __init__(
-        self,
-        app: Optional["Esmerald"] = None,
-        scheduler_class: Optional["SchedulerType"] = None,
-        tasks: Optional[Dict[str, str]] = None,
-        timezone: Optional[Union[dtimezone, str]] = None,
-        configurations: Optional[Dict[str, Dict[str, str]]] = None,
-    ) -> None:
-        self.app = app
-        self.tasks = tasks
-        self.timezone = timezone
-        self.scheduler_class = scheduler_class
-        self.configurations = configurations
-
-        if not self.scheduler_class and self.app.enable_scheduler:
-            raise ImproperlyConfigured(
-                "It cannot start the scheduler if there is no scheduler_class declared."
-            )
-
-        for task, module in self.tasks.items():
-            if not isinstance(task, str) or not isinstance(module, str):
-                raise ImproperlyConfigured("The dict of tasks must be Dict[str, str].")
-
-        if not self.tasks:
-            warnings.warn(
-                "Esmerald is starting the scheduler, yet there are no tasks declared.",
-                UserWarning,
-                stacklevel=2,
-            )
-
-        # Load the scheduler object
-        self.handler = self.get_scheduler(
-            scheduler=self.scheduler_class,
-            timezone=self.timezone,
-            configurations=self.configurations,
-        )
-
-        self.register_events(app=self.app)
-        self.register_tasks(tasks=self.tasks)
-
-    def register_tasks(self, tasks: Dict[str, str]) -> None:
-        """
-        Registers the tasks in the Scheduler
-        """
-        for task, _module in tasks.items():
-            imported_task = f"{_module}.{task}"
-            scheduled_task: "Task" = import_string(imported_task)
-
-            if not scheduled_task.is_enabled:
-                continue
-
-            try:
-                scheduled_task.add_task(self.handler)
-            except Exception as e:
-                raise ImproperlyConfigured(str(e)) from e
-
-    def register_events(self, app: "Esmerald") -> None:
-        """
-        Registers the scheduler events in the Esmerald application.
-        """
-        if app.on_startup is not None:
-            app.on_startup.append(self.handler.start)
-        else:
-            app.on_startup = [self.handler.start]
-
-        if app.on_shutdown is not None:
-            app.on_shutdown.append(self.handler.shutdown)
-        else:
-            app.on_shutdown = [self.handler.shutdown]
-
-    def get_scheduler(
-        self,
-        scheduler: "SchedulerType",
-        timezone: Optional[dtimezone] = None,
-        configurations: Optional[Dict[str, str]] = None,
-    ) -> SchedulerType:
-        """
-        Initiates the scheduler from the given time.
-        If no value is provided, it will default to AsyncIOScheduler.
-
-        The value of `scheduler_class` can be overwritten by any esmerald custom settings.
-
-        Args:
-            scheduler: AsyncIOScheduler.
-            timezone: The timezone instance.
-            configurations: A dictionary with extra configurations to be passed to the scheduler.
-
-        Return:
-            SchedulerType: An instance of a Scheduler.
-        """
-        if not timezone:
-            timezone = settings.timezone
-
-        if not configurations:
-            return scheduler(timezone=timezone)
-
-        return scheduler(global_config=configurations, timezone=timezone)
-
-
-class Task:
-    """
-    Base for the scheduler decorator that will auto discover the
-    tasks in the application and add them to the internal scheduler.
-    """
-
-    def __init__(
-        self,
-        *,
-        name: Optional[str] = None,
-        trigger: Optional[TriggerType] = None,
-        id: Optional[str] = None,
-        mistrigger_grace_time: Optional[int] = None,
-        coalesce: Optional[bool] = None,
-        max_instances: Optional[int] = None,
-        next_run_time: Optional[datetime] = None,
-        store: Optional[str] = "default",
-        executor: Optional[str] = "default",
-        replace_existing: bool = False,
-        args: Optional[Any] = None,
-        kwargs: Optional[Dict[str, Any]] = None,
-        is_enabled: bool = True,
-    ) -> None:
-        """_summary_
-
-        Args:
-            name: Textual description of the task.
-            trigger: An instance of a trigger class.
-            identifier: Explicit identifier for the task.
-            mistrigger_grace_time: Seconds after the designated runtime that the task is still allowed to be run (or None to allow the task to run no
-                matter  how late it is).
-            coalesce: Run once instead of many times if the scheduler determines that the task should be run more than once in succession.
-            max_instances: Maximum number of concurrently running instances allowed for this task.
-            next_run_time: When to first run the task, regardless of the trigger (pass None to add the task as paused).
-            store: Alias of the task store to store the task in.
-            executor: Alias of the executor to run the task with.
-            replace_existing: True to replace an existing task with the same id
-                (but retain the number of runs from the existing one).
-            args: List of positional arguments to call func with.
-            kwargs: Dict of keyword arguments to call func with.
-            is_enabled: True if the the task to be added to the scheduler.
-        """
-        self.name = name
-        self.trigger = trigger
-        self.id = id
-        self.mistrigger_grace_time = mistrigger_grace_time or undefined
-        self.coalesce = coalesce or undefined
-        self.max_instances = max_instances or undefined
-        self.next_run_time = next_run_time or undefined
-        self.store = store
-        self.executor = executor
-        self.replace_existing = replace_existing
-        self.args = args
-        self.kwargs = kwargs
-        self.is_enabled = is_enabled
-        self.fn = None
-
-    def add_task(self, scheduler: "SchedulerType"):
-        try:
-            scheduler.add_task(
-                fn=self.fn,
-                trigger=self.trigger,
-                args=self.args,
-                kwargs=self.kwargs,
-                id=self.id,
-                name=self.name,
-                mistrigger_grace_time=self.mistrigger_grace_time,
-                coalesce=self.coalesce,
-                max_instances=self.max_instances,
-                next_run_time=self.next_run_time,
-                store=self.store,
-                executor=self.executor,
-                replace_existing=self.replace_existing,
-            )
-        except Exception as e:
-            raise ImproperlyConfigured(str(e)) from e
-
-    def __call__(self, fn: Any) -> None:
-        """
-        Tricking the object into think it's being instantiated by in reality
-        is just returning itself.
-        """
-        self.fn = fn
-        return self