PyPI - cherrypy-foundation - Versions diffs - 1.0.0a1__py3-none-any.whl → 1.0.0a2__py3-none-any.whl - Mend

cherrypy-foundation 1.0.0a1py3-none-any.whl → 1.0.0a2py3-none-any.whl

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (31) hide show

cherrypy_foundation/components/Field.jinja CHANGED Viewed

@@ -29,16 +29,24 @@
   {% set input_class, label_class, floating_supported, label_always_last = bootstrap_class_table.get(field.widget.__class__.__name__) or ('', 'form-label', False, False) %}
   {% set label_last = (floating and floating_supported) or label_always_last %}
   {% do attrs.add_class(input_class) %}
-  {# Render label an widget #}
   {# Used for input-group #}
   {% set prepend = attrs.get('prepend', None) %}
   {% set append = attrs.get('append', None) %}
   {% set input_group = prepend or append %}
-  {% set container_class = attrs.get('container_class', 'col-12') %}
-  {% do attrs.__delitem__('container_class') %}
-  <div class="mb-2 form-field {{ container_class }}">
+  {# Build container & label specific attributes #}
+  {% set container_attrs = attrs.__class__({'class': 'mb-2 form-field'}) %}
+  {% set label_attrs = attrs.__class__({'class': label_class}) %}
+  {% for key, value in attrs.as_dict.items() %}
+    {% if key.startswith('container-') or key.startswith('container_') %}
+      {% do container_attrs.set(**{key[10:]: value}) %}
+    {% endif %}
+    {% if key.startswith('label-') or key.startswith('label_') %}
+      {% do label_attrs.set(**{key[6:]: value}) %}
+    {% endif %}
+  {% endfor %}
+  <div {{ container_attrs.as_dict | xmlattr }}>
     {% if floating and floating_supported %}<div class="form-floating">{% endif %}
-      {% if not label_last %}{{ field.label(class=label_class) }}{% endif %}
+      {% if not label_last %}{{ field.label(**label_attrs.as_dict) }}{% endif %}
       {% if input_group %}
         <div class="input-group">
           {% if prepend %}<span class="input-group-text">{{ prepend }}</span>{% endif %}
@@ -48,7 +56,7 @@
           {% if append %}<span class="input-group-text">{{ append }}</span>{% endif %}
         </div>
       {% endif %}
-      {% if label_last %}{{ field.label(class=label_class) }}{% endif %}
+      {% if label_last %}{{ field.label(**label_attrs.as_dict) }}{% endif %}
       {% for error in field.errors %}<div class="invalid-feedback">{{ error }}</div>{% endfor %}
       {% if field.description %}<div class="form-text small test-secondary">{{ field.description }}</div>{% endif %}
       {% if floating and floating_supported %}</div>{% endif %}

cherrypy_foundation/components/__init__.py CHANGED Viewed

@@ -1,4 +1,4 @@
-# udb, A web interface to manage IT network
+# Cherrypy Foundation
 # Copyright (C) 2025 IKUS Software inc.
 #
 # This program is free software: you can redistribute it and/or modify

cherrypy_foundation/error_page.py CHANGED Viewed

@@ -19,9 +19,6 @@ import logging
 import cherrypy
-# Define the logger
-logger = logging.getLogger(__name__)
 HTML_ERROR_TEMPLATE = '''<!DOCTYPE html>
 <html>
 <head>
@@ -53,39 +50,45 @@ HTML_ERROR_TEMPLATE = '''<!DOCTYPE html>
 '''
-def error_page(**kwargs):
+def error_page(status='', message='', traceback='', version=''):
     """
     Error page handler to handle Plain Text (text/plain), Json (application/json) or HTML (text/html) output.
     If available, uses Jina2 environment to generate error page using `error_page.html`.
     """
     # Log server error exception
-    if kwargs.get('status', '').startswith('500'):
-        logger.error(
-            'error page: %s %s\n%s' % (kwargs.get('status', ''), kwargs.get('message', ''), kwargs.get('traceback', ''))
+    if status.startswith('500'):
+        cherrypy.log(
+            f'error page status={status} message={message}\n{traceback}', context='ERROR-PAGE', severity=logging.WARNING
         )
     # Replace message by generic one for 404. Default implementation leak path info.
-    if kwargs.get('status', '') == '404 Not Found':
-        kwargs['message'] = 'Nothing matches the given URI'
+    if status == '404 Not Found':
+        message = 'Nothing matches the given URI'
     # Check expected response type.
     mtype = cherrypy.serving.response.headers.get('Content-Type') or cherrypy.tools.accept.callable(
         ['text/html', 'text/plain', 'application/json']
     )
     if mtype == 'text/plain':
-        return kwargs.get('message')
+        return message
     elif mtype == 'application/json':
-        return json.dumps({'message': kwargs.get('message', ''), 'status': kwargs.get('status', '')})
+        return json.dumps({'message': message, 'status': status})
     elif mtype == 'text/html':
+        context = {'status': status, 'message': message, 'traceback': traceback, 'version': version}
         if hasattr(cherrypy.tools, 'jinja2'):
             # Try to build a nice error page with Jinja2 env
             try:
-                return cherrypy.tools.jinja2.render_request(template='error_page.html', vars=kwargs)
+                return cherrypy.tools.jinja2.render_request(template='error_page.html', context=context)
             except Exception:
-                logger.exception('fail to render error page')
+                cherrypy.log(
+                    'fail to render error page with jinja2',
+                    context='ERROR-PAGE',
+                    severity=logging.ERROR,
+                    traceback=True,
+                )
         # Fallback to built-int HTML error page
-        return HTML_ERROR_TEMPLATE % kwargs
+        return HTML_ERROR_TEMPLATE % context
     # Fallback to raw error message.
-    return kwargs.get('message')
+    return message

cherrypy_foundation/plugins/db.py CHANGED Viewed

@@ -23,8 +23,6 @@ from sqlalchemy.engine import Engine
 from sqlalchemy.exc import IntegrityError, SQLAlchemyError
 from sqlalchemy.orm import declarative_base, scoped_session, sessionmaker
-logger = logging.getLogger(__name__)
 @event.listens_for(Engine, 'connect')
 def _set_sqlite_journal_mode_wal(connection, connection_record):
@@ -168,6 +166,10 @@ class SQLA(SimplePlugin):
     _session = None
     _engine = None
+    @property
+    def engine(self):
+        return self._engine
     def start(self):
         if self.uri is None:
             return
@@ -180,14 +182,22 @@ class SQLA(SimplePlugin):
         self.clear_sessions()
         # Associate our session to our engine
         self.get_session().configure(bind=self._engine)
-        self.bus.log("Database session plugin started.")
+        self.bus.log("database session plugin started")
+    # This is slightly lower priority to get database started first.
+    start.priority = 45
     def stop(self):
         if self._session:
             self.clear_sessions()
         if self._engine:
             self._engine.dispose()
-        self.bus.log("Database session plugin stopped.")
+        self.bus.log("database session plugin stopped")
+    def graceful(self):
+        """Reload of subscribers."""
+        self.stop()
+        self.start()
     def create_all(self):
         try:
@@ -242,11 +252,27 @@ class SQLA(SimplePlugin):
         try:
             # When terminating, raise an error if objects are not commit.
             if self._session.dirty or self._session.new or self._session.deleted:
-                changes = ', '.join([str(_get_model_changes(obj)) for obj in self._session.dirty])
-                logger.exception(
-                    'session is dirty, some database object(s) are not commited, this indicate a bug in the application '
-                    'dirty %s new %s deleted %s' % (changes, self._session.new, self._session.deleted)
+                cherrypy.log(
+                    'database session dirty; uncommitted objects detected — potential application bug',
+                    context='DB',
+                    severity=logging.ERROR,
                 )
+                if self._session.dirty:
+                    changes = ', '.join([str(_get_model_changes(obj)) for obj in self._session.dirty])
+                    cherrypy.log(
+                        f'database session dirty_objects={self._session.dirty}', context='DB', severity=logging.ERROR
+                    )
+                    cherrypy.log(f'database session pending_changes={changes}', context='DB', severity=logging.ERROR)
+                if self._session.new:
+                    cherrypy.log(
+                        f'database session new_objects={self._session.new}', context='DB', severity=logging.ERROR
+                    )
+                if self._session.deleted:
+                    cherrypy.log(
+                        f'database session deleted_objects={self._session.deleted}',
+                        context='DB',
+                        severity=logging.ERROR,
+                    )
                 raise SQLAlchemyError('session is dirty')
         finally:
             self._session.rollback()

cherrypy_foundation/plugins/ldap.py CHANGED Viewed

@@ -21,8 +21,6 @@ import ldap3
 from cherrypy.process.plugins import SimplePlugin
 from ldap3.core.exceptions import LDAPException, LDAPInvalidCredentialsResult
-logger = logging.getLogger(__name__)
 _safe = ldap3.utils.conv.escape_filter_chars
@@ -126,6 +124,11 @@ class LdapPlugin(SimplePlugin):
         if hasattr(self, '_pool'):
             self._pool.unbind()
+    def graceful(self):
+        """Reload of subscribers."""
+        self.stop()
+        self.start()
     def authenticate(self, username, password):
         """
         Check if the given credential as valid according to LDAP.
@@ -148,9 +151,9 @@ class LdapPlugin(SimplePlugin):
                 search_filter = f"(&{self.user_filter}(|{attr_filter}))"
                 response = self._search(conn, search_filter)
                 if not response:
-                    logger.info("user %s not found in LDAP", username)
+                    cherrypy.log(f"lookup failed username={username} reason=not_found", context='LDAP')
                     return False
-                logger.info("user %s found in LDAP", username)
+                cherrypy.log(f"lookup successful username={username}", context='LDAP')
                 user_dn = response[0]['dn']
                 # Use a separate connection to validate credentials
@@ -163,17 +166,21 @@ class LdapPlugin(SimplePlugin):
                     client_strategy=ldap3.ASYNC,
                 )
                 if not login_conn.bind():
-                    logger.warning("LDAP authentication failed for user %s", username)
+                    cherrypy.log(
+                        f'ldap authentication failed username={username} reason=wrong_password',
+                        context='LDAP',
+                        severity=logging.WARNING,
+                    )
                     return False
                 # Get username
                 attrs = response[0]['attributes']
                 new_username = first_attribute(attrs, self.username_attribute)
                 if not new_username:
-                    logger.info(
-                        "user object %s was found but the username attribute %s doesn't exists",
-                        user_dn,
-                        self.username_attribute,
+                    cherrypy.log(
+                        f"object missing username attribute user_dn={user_dn} attribute={self.username_attribute}",
+                        context='LDAP',
+                        severity=logging.WARNING,
                     )
                     return False
@@ -189,17 +196,15 @@ class LdapPlugin(SimplePlugin):
                         self.group_filter,
                     )
                     # Search LDAP Server for matching groups.
-                    logger.info(
-                        "check if user %s is member of any group %s",
-                        user_value,
-                        ' '.join(self.required_group),
+                    cherrypy.log(
+                        f"group check start username={user_value} required_groups={' '.join(self.required_group)}",
+                        context='LDAP',
                     )
                     response = self._search(conn, group_filter, attributes=['cn'])
                     if not response:
-                        logger.info(
-                            "user %s was found but is not member of any group(s) %s",
-                            user_value,
-                            ' '.join(self.required_group),
+                        cherrypy.log(
+                            f"group check failed username={user_value} required_groups={' '.join(self.required_group)}",
+                            context='LDAP',
                         )
                         return False
@@ -215,7 +220,9 @@ class LdapPlugin(SimplePlugin):
             except LDAPInvalidCredentialsResult:
                 return False
             except LDAPException:
-                logger.exception("can't validate user %s credentials", username)
+                cherrypy.log(
+                    f"unexpected error username={username}", context='LDAP', severity=logging.ERROR, traceback=True
+                )
             return None
     def search(self, filter, attributes=ldap3.ALL_ATTRIBUTES, search_base=None, paged_size=None):
@@ -228,11 +235,10 @@ class LdapPlugin(SimplePlugin):
         search_scope = {'base': ldap3.BASE, 'onelevel': ldap3.LEVEL, 'subtree': ldap3.SUBTREE}.get(
             self.scope, ldap3.SUBTREE
         )
-        logger.debug(
-            "search ldap server: {}/{}?{}?{}".format(self.uri, search_base or self.base_dn, search_scope, filter)
-        )
+        search_base = search_base or self.base_dn
+        cherrypy.log(f"search {self.uri}/{search_base}?{search_scope}?{filter}", context='LDAP')
         msg_id = conn.search(
-            search_base=search_base or self.base_dn,
+            search_base=search_base,
             search_filter=filter,
             search_scope=search_scope,
             time_limit=self.timeout,

cherrypy_foundation/plugins/scheduler.py CHANGED Viewed

@@ -1,5 +1,5 @@
 # Scheduler plugins for Cherrypy
-# Copyright (C) 2022-2025 IKUS Software
+# Copyright (C) 2025 IKUS Software
 #
 # This program is free software: you can redistribute it and/or modify
 # it under the terms of the GNU General Public License as published by
@@ -13,147 +13,260 @@
 #
 # You should have received a copy of the GNU General Public License
 # along with this program.  If not, see <https://www.gnu.org/licenses/>.
-'''
-Created on Mar. 23, 2021
-@author: Patrik Dufresne <patrik@ikus-soft.com>
-'''
+import copy
 import logging
-from datetime import datetime
+from datetime import datetime, timezone
+from functools import wraps
+from threading import Event, RLock
 import cherrypy
-from apscheduler.executors.pool import ThreadPoolExecutor
-from apscheduler.jobstores.memory import MemoryJobStore
+from apscheduler.events import EVENT_JOB_ERROR, EVENT_JOB_EXECUTED, EVENT_JOB_SUBMITTED
 from apscheduler.schedulers.background import BackgroundScheduler
 from cherrypy.process.plugins import SimplePlugin
 logger = logging.getLogger(__name__)
-def catch_exception(scheduler, func):
+def clear_db_sessions(func):
     """
-    Wrapper function to execute job.
-    Primarly to handle database connection rollback and also to keep track
-    if any job are still running.
+    A decorator that ensures database connections that have become unusable, or are obsolete, are closed
+    before and after the job is executed.
     """
-    def wrapper(*args, **kwargs):
-        ident = object()
-        scheduler._running.append(ident)
+    @wraps(func)
+    def func_wrapper(*args, **kwargs):
+        cherrypy.db.clear_sessions()
         try:
-            func(*args, **kwargs)
+            result = func(*args, **kwargs)
         finally:
             cherrypy.db.clear_sessions()
-            scheduler._running.remove(ident)
+        return result
-    wrapper._func = func
-    return wrapper
+    return func_wrapper
 class Scheduler(SimplePlugin):
     """
     Plugins to run Job at fixed time (cronjob) and to schedule task to be run on by one.
+    Configuration:
+    - jobstore. Take value 'memory' (default), 'db' to use SQLalchemy database in combination with cherrypy.db. Or any callable function to create an instance of BaseJobStore
     """
+    jobstores = {"default": {"type": "memory"}}
+    executors = {"default": {"type": "threadpool", "max_workers": 10}}
+    job_defaults = {"coalesce": False, "max_instances": 1}
+    timezone = None
     def __init__(self, bus):
         super().__init__(bus)
-        self._scheduler = self._create_scheduler()
-        self._scheduler.start(paused=True)
-        self._running = []
+        self._scheduler = None
+        # Let keep track of running jobs manually.
+        # This is required for unit testing to wait for all running task.
+        self._lock = RLock()
+        self._event = Event()
+        self._submitted_jobs = set()
+        self._completed_jobs = set()
+    @property
+    def _running_jobs(self):
+        with self._lock:
+            return self._submitted_jobs
+    def _track_running_jobs(self, event):
+        """
+        This listener keep track of running jobs.
+        This is required to implement wait for tasks mostly used during unit testing.
+        """
+        with self._lock:
+            # Special care must be taken to handle race condition
+            # the EVENT_JOB_EXECUTED may get called before EVENT_JOB_SUBMITTED
+            if event.code == EVENT_JOB_SUBMITTED:
+                if event.job_id in self._completed_jobs:
+                    self._completed_jobs.remove(event.job_id)
+                else:
+                    self._submitted_jobs.add(event.job_id)
+            elif event.code in (EVENT_JOB_EXECUTED, EVENT_JOB_ERROR):
+                if event.job_id in self._submitted_jobs:
+                    self._submitted_jobs.remove(event.job_id)
+                else:
+                    self._completed_jobs.add(event.job_id)
+            # Wakeup wait_for_tasks.
+            self._event.set()
+    def _drop_table(self, target, conn, **kwargs):
+        """
+        Callback listener to drop table.
+        This is required because SQLAlchemyJobStore creates the table manually.
+        """
+        from sqlalchemy.sql import ddl
+        # Here we need to use private API to loop over all sqlalchemy job store.
+        for jobstore in self._scheduler._jobstores.values():
+            table = getattr(jobstore, 'jobs_t', None)
+            if table is not None:
+                conn.execute(ddl.DropTable(table, if_exists=True))
+    def _create_table(self, target, conn, **kwargs):
+        """
+        Callback listener to drop table.
+        This is required because SQLAlchemyJobStore creates the table manually.
+        """
+        from sqlalchemy.sql import ddl
+        # Here we need to use private API to loop over all sqlalchemy job store.
+        for jobstore in self._scheduler._jobstores.values():
+            table = getattr(jobstore, 'jobs_t', None)
+            if table is not None:
+                conn.execute(ddl.CreateTable(table, if_not_exists=True))
+    def _db_events(self, listen_or_remove):
+        """
+        Listen on database events to create and drop tables as required.
+        """
+        assert listen_or_remove in ['listen', 'remove']
+        try:
+            from sqlalchemy import event
+            if getattr(cherrypy, 'db', False):
+                base = cherrypy.db.get_base()
+                func = getattr(event, listen_or_remove)
+                func(base.metadata, 'after_drop', self._drop_table)
+                func(base.metadata, 'after_create', self._create_table)
+        except ImportError:
+            # Nothing to do if sqlalchemy is not available
+            pass
     def _create_scheduler(self):
-        return BackgroundScheduler(
-            jobstores={
-                'default': MemoryJobStore(),
-                'scheduled': MemoryJobStore(),
-            },
-            executors={
-                'default': ThreadPoolExecutor(
-                    max_workers=1,
-                    pool_kwargs={'thread_name_prefix': 'scheduler-default'},
-                ),
-                'scheduled': ThreadPoolExecutor(
-                    max_workers=1,
-                    pool_kwargs={'thread_name_prefix': 'scheduler-scheduled'},
-                ),
-            },
+        """
+        Create a new APScheduler base on plugin configuration.
+        """
+        # Create the scheduler with deepcopy of configuration.
+        scheduler = BackgroundScheduler(
+            jobstores=copy.deepcopy(self.jobstores),
+            executors=copy.deepcopy(self.executors),
+            job_defaults=copy.deepcopy(self.job_defaults),
+            timezone=self.timezone,
         )
+        # Add listener to keep track of running jobs.
+        scheduler.add_listener(self._track_running_jobs, (EVENT_JOB_EXECUTED | EVENT_JOB_ERROR | EVENT_JOB_SUBMITTED))
+        # Start the scheduler.
+        scheduler.start()
+        return scheduler
     def start(self):
-        self.bus.log('Start Scheduler plugins')
-        self._scheduler.resume()
-        self.bus.subscribe('schedule_job', self.schedule_job)
-        self.bus.subscribe('schedule_task', self.schedule_task)
-        self.bus.subscribe('unschedule_job', self.unschedule_job)
+        self.bus.log('Start Scheduler plugin')
+        # Create apscheduler
+        self._scheduler = self._create_scheduler()
+        # Register drop_table event (when using database)
+        self._db_events('listen')
+        # Then register new channels
+        self.bus.subscribe('scheduler:add_job', self.add_job)
+        self.bus.subscribe('scheduler:add_job_daily', self.add_job_daily)
+        self.bus.subscribe('scheduler:add_job_now', self.add_job_now)
+        self.bus.subscribe('scheduler:remove_job', self.remove_job)
+    # Slightly lower priority to start after database, but before other plugins.
+    start.priority = 49
     def stop(self):
-        self.bus.log('Stop Scheduler plugins')
-        self._scheduler.pause()
-        self.bus.unsubscribe('schedule_job', self.schedule_job)
-        self.bus.unsubscribe('unschedule_job', self.unschedule_job)
-        self.bus.unsubscribe('schedule_task', self.schedule_task)
-    def exit(self):
-        # Shutdown scheduler and create a new one in case the engine get started again.
-        self._scheduler.shutdown(wait=True)
-        self._scheduler = self._create_scheduler()
-        self._scheduler.start(paused=True)
+        self.bus.log('Stop Scheduler plugin')
+        # Unregister drop_table event (when using database)
+        self._db_events('remove')
+        # Shutdown the scheduler & wait for running task to complete.
+        if self._scheduler:
+            self._scheduler.shutdown(wait=True)
+            self._scheduler = None
+        self.bus.unsubscribe('scheduler:add_job', self.add_job)
+        self.bus.unsubscribe('scheduler:add_job_daily', self.add_job_daily)
+        self.bus.unsubscribe('scheduler:add_job_now', self.add_job_now)
+        self.bus.unsubscribe('scheduler:remove_job', self.remove_job)
-    def list_jobs(self):
-        """
-        Return list of scheduled jobs.
-        """
-        return self._scheduler.get_jobs(jobstore='scheduled')
+    stop.priority = 51
+    def graceful(self):
+        """Reload of subscribers."""
+        self.stop()
+        self.start()
-    def list_tasks(self):
+    def add_job(self, func, *args, **kwargs):
         """
-        Return list of tasks.
+        Called via engine.publish('scheduler:add_job', ...)
+        OR directly on the plugin instance.
         """
-        return self._scheduler.get_jobs(jobstore='default')
+        if not self._scheduler:
+            raise RuntimeError("Scheduler not running; cannot add job.")
-    def is_job_running(self):
-        return self._running
+        return self._scheduler.add_job(func, *args, **kwargs)
-    def schedule_job(self, execution_time, job, *args, **kwargs):
+    def add_job_daily(self, execution_time, func, *args, **kwargs):
         """
-        Add the given scheduled job to the scheduler.
+        A convenience wrapper around add_job() that ensures
+        the job runs daily.
         """
-        assert hasattr(job, '__call__'), 'job must be callable'
         hour, minute = execution_time.split(':', 2)
-        self._scheduler.add_job(
-            func=catch_exception(self, job),
-            name=job.__name__,
+        return self.add_job(
+            func=func,
+            name=getattr(func, '__name__', str(func)),
             args=args,
             kwargs=kwargs,
             trigger='cron',
             hour=hour,
             minute=minute,
-            jobstore='scheduled',
-            executor='scheduled',
+            misfire_grace_time=None,
         )
-    def schedule_task(self, task, *args, **kwargs):
+    def add_job_now(self, func, *args, **kwargs):
         """
-        Add the given task to be execute immediately in background.
+        A convenience wrapper around add_job() that ensures
+        the job runs immediately upon being added.
         """
-        assert hasattr(task, '__call__'), 'task must be callable'
-        self._scheduler.add_job(
-            func=catch_exception(self, task),
-            name=task.__name__,
+        return self.add_job(
+            func=func,
+            name=getattr(func, '__name__', str(func)),
             args=args,
             kwargs=kwargs,
-            next_run_time=datetime.now(),
+            next_run_time=datetime.now(timezone.utc),
+            misfire_grace_time=None,
         )
-    def unschedule_job(self, job):
+    def get_jobs(self, jobstore=None):
+        """
+        Return list of scheduled jobs.
+        """
+        if not self._scheduler:
+            raise RuntimeError("Scheduler not running; cannot get jobs.")
+        return self._scheduler.get_jobs(jobstore=jobstore)
+    def remove_job(self, job, jobstore=None):
         """
         Remove the given job from scheduler.
         """
         # Search for a matching job
-        job_id = next((j.id for j in self._scheduler.get_jobs(jobstore='scheduled') if j.func._func == job), None)
-        if job_id:
-            self._scheduler.remove_job(job_id=job_id, jobstore='scheduled')
+        for j in self._scheduler.get_jobs(jobstore=jobstore):
+            if j.func == job:
+                self._scheduler.remove_job(job_id=j.id, jobstore=jobstore)
+    def remove_all_jobs(self, jobstore=None):
+        """
+        Remove all jobs from scheduler.
+        """
+        self._scheduler.remove_all_jobs(jobstore=jobstore)
+    def wait_for_jobs(self, jobstore=None):
+        """
+        Used to wait for all running jobs to complete.
+        """
+        # Wait until the queue is empty.
+        while any(
+            job for job in self._scheduler.get_jobs(jobstore=jobstore) if job.next_run_time < datetime.now(timezone.utc)
+        ):
+            self._event.wait(timeout=1)
+            self._event.clear()
+        # Wait until all jobs are completed.
+        while self._running_jobs:
+            self._event.wait(timeout=1)
+            self._event.clear()
 # Register Scheduler plugin

cherrypy-foundation 1.0.0a1__py3-none-any.whl → 1.0.0a2__py3-none-any.whl

cherrypy-foundation 1.0.0a1py3-none-any.whl → 1.0.0a2py3-none-any.whl