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

cherrypy_foundation/plugins/scheduler.py

@@ -1,5 +1,5 @@
 # Scheduler plugins for Cherrypy
-# Copyright (C) 2026 IKUS Software
+# Copyright (C) 2022-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,271 +13,147 @@
 #
 # You should have received a copy of the GNU General Public License
 # along with this program.  If not, see <https://www.gnu.org/licenses/>.
-import copy
+
+'''
+Created on Mar. 23, 2021
+
+@author: Patrik Dufresne <patrik@ikus-soft.com>
+'''
 import logging
-from datetime import datetime, timezone
-from functools import wraps
-from threading import Event, RLock
+from datetime import datetime
 
 import cherrypy
-from apscheduler.events import EVENT_JOB_ERROR, EVENT_JOB_EXECUTED, EVENT_JOB_SUBMITTED
+from apscheduler.executors.pool import ThreadPoolExecutor
+from apscheduler.jobstores.memory import MemoryJobStore
 from apscheduler.schedulers.background import BackgroundScheduler
 from cherrypy.process.plugins import SimplePlugin
 
 logger = logging.getLogger(__name__)
 
 
-def clear_db_sessions(func):
+def catch_exception(scheduler, func):
     """
-    A decorator that ensures database connections that have become unusable, or are obsolete, are closed
-    before and after the job is executed.
+    Wrapper function to execute job.
+    Primarly to handle database connection rollback and also to keep track
+    if any job are still running.
     """
 
-    @wraps(func)
-    def func_wrapper(*args, **kwargs):
+    def wrapper(*args, **kwargs):
+        ident = object()
+        scheduler._running.append(ident)
         try:
-            result = func(*args, **kwargs)
+            func(*args, **kwargs)
         finally:
             cherrypy.db.clear_sessions()
-        return result
+            scheduler._running.remove(ident)
 
-    return func_wrapper
+    wrapper._func = func
+    return 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 = 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
+        self._scheduler = self._create_scheduler()
+        self._scheduler.start(paused=True)
+        self._running = []
 
     def _create_scheduler(self):
-        """
-        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,
+        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'},
+                ),
+            },
         )
-        # 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 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
+        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)
 
     def stop(self):
-        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)
-
-    stop.priority = 51
+        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)
 
-    def graceful(self):
-        """Reload of subscribers."""
-        self.stop()
-        self.start()
+    def list_jobs(self):
+        """
+        Return list of scheduled jobs.
+        """
+        return self._scheduler.get_jobs(jobstore='scheduled')
 
-    def add_job(self, func, *args, **kwargs):
+    def list_tasks(self):
         """
-        Called via engine.publish('scheduler:add_job', ...)
-        OR directly on the plugin instance.
+        Return list of tasks.
         """
-        if not self._scheduler:
-            raise RuntimeError("Scheduler not running; cannot add job.")
+        return self._scheduler.get_jobs(jobstore='default')
 
-        return self._scheduler.add_job(func, *args, **kwargs)
+    def is_job_running(self):
+        return self._running
 
-    def add_job_daily(self, execution_time, func, *args, **kwargs):
+    def schedule_job(self, execution_time, job, *args, **kwargs):
         """
-        A convenience wrapper around add_job() that ensures
-        the job runs daily.
+        Add the given scheduled job to the scheduler.
         """
+        assert hasattr(job, '__call__'), 'job must be callable'
         hour, minute = execution_time.split(':', 2)
-        return self.add_job(
-            id=getattr(func, '__name__', str(func)),
-            func=func,
-            name=getattr(func, '__name__', str(func)),
+        self._scheduler.add_job(
+            func=catch_exception(self, job),
+            name=job.__name__,
             args=args,
             kwargs=kwargs,
             trigger='cron',
             hour=hour,
             minute=minute,
-            misfire_grace_time=None,
-            coalesce=True,
-            replace_existing=True,
+            jobstore='scheduled',
+            executor='scheduled',
         )
 
-    def add_job_now(self, func, *args, **kwargs):
+    def schedule_task(self, task, *args, **kwargs):
         """
-        A convenience wrapper around add_job() that ensures
-        the job runs immediately upon being added.
+        Add the given task to be execute immediately in background.
         """
-        return self.add_job(
-            func=func,
-            name=getattr(func, '__name__', str(func)),
+        assert hasattr(task, '__call__'), 'task must be callable'
+        self._scheduler.add_job(
+            func=catch_exception(self, task),
+            name=task.__name__,
             args=args,
             kwargs=kwargs,
-            next_run_time=datetime.now(timezone.utc),
-            misfire_grace_time=None,
+            next_run_time=datetime.now(),
         )
 
-    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):
+    def unschedule_job(self, job):
         """
         Remove the given job from scheduler.
         """
         # Search for a matching job
-        return_value = False
-        if self._scheduler is None:
-            return return_value
-        for j in self._scheduler.get_jobs(jobstore=jobstore):
-            if j.func == job or j.name == job:
-                self._scheduler.remove_job(job_id=j.id, jobstore=jobstore)
-                return_value = True
-        return return_value
-
-    def remove_all_jobs(self, jobstore=None):
-        """
-        Remove all jobs from scheduler.
-        """
-        if self._scheduler is None:
-            return
-        self._scheduler.remove_all_jobs(jobstore=jobstore)
-
-    def wait_for_jobs(self, jobstore=None):
-        """
-        Used to wait for all running jobs to complete.
-        """
-        if self._scheduler is None:
-            return
-        # 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()
+        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')
 
 
 # Register Scheduler plugin

cherrypy_foundation/plugins/smtp.py

@@ -1,5 +1,5 @@
 # SMTP Plugins for cherrypy
-# Copyright (C) 2026 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
@@ -100,26 +100,6 @@ def _formataddr(value):
     return ', '.join(map(_formataddr, value))
 
 
-def _send_message(server, encryption, username, password, msg):
-    """
-    Send message using SMTP.
-    """
-    host, unused, port = server.partition(':')
-    if encryption == 'ssl':
-        conn = smtplib.SMTP_SSL(host, port or 465)
-    else:
-        conn = smtplib.SMTP(host, port or 25)
-    try:
-        if encryption == 'starttls':
-            conn.starttls()
-        # Authenticate if required.
-        if username:
-            conn.login(username, password)
-        conn.send_message(msg)
-    finally:
-        conn.quit()
-
-
 class SmtpPlugin(SimplePlugin):
 
     server = None
@@ -127,38 +107,6 @@ class SmtpPlugin(SimplePlugin):
     password = None
     encryption = None
     email_from = None
-    bcc = None
-
-    def _create_msg(self, subject: str, message: str, to=None, cc=None, bcc=None, reply_to=None, headers={}):
-        assert subject
-        assert message
-        assert to or bcc
-
-        # Record the MIME types of both parts - text/plain and text/html.
-        msg = MIMEMultipart('alternative')
-        msg['Subject'] = str(subject)
-        msg['From'] = _formataddr(self.email_from)
-        if to:
-            msg['To'] = _formataddr(to)
-        if cc:
-            msg['Cc'] = _formataddr(cc)
-        bcc_list = []
-        if self.bcc:
-            bcc_list.append(_formataddr(self.bcc))
-        if bcc:
-            bcc_list.append(_formataddr(bcc))
-        if bcc_list:
-            msg['Bcc'] = ', '.join(bcc_list)
-        if reply_to:
-            msg['Reply-To'] = _formataddr(reply_to)
-        msg['Message-ID'] = email.utils.make_msgid()
-        if headers:
-            for key, value in headers.items():
-                msg[key] = value
-        text = _html2plaintext(message)
-        msg.attach(MIMEText(text, 'plain', 'utf8'))
-        msg.attach(MIMEText(message, 'html', 'utf8'))
-        return msg
 
     def start(self):
         self.bus.log('Start SMTP plugin')
@@ -170,50 +118,70 @@ class SmtpPlugin(SimplePlugin):
         self.bus.unsubscribe("send_mail", self.send_mail)
         self.bus.unsubscribe("queue_mail", self.queue_mail)
 
-    def graceful(self):
-        """Reload of subscribers."""
-        self.stop()
-        self.start()
-
     def queue_mail(self, *args, **kwargs):
         """
         Queue mail to be sent.
         """
         # Skip sending email if smtp server is not configured.
         if not self.server:
-            cherrypy.log('cannot send email because SMTP Server is not configured', context='SMTP')
+            self.bus.log('cannot send email because SMTP Server is not configured')
             return
         if not self.email_from:
-            cherrypy.log('cannot send email because SMTP From is not configured', context='SMTP')
+            self.bus.log('cannot send email because SMTP From is not configured')
             return
-        msg = self._create_msg(*args, **kwargs)
-        self.bus.publish(
-            'scheduler:add_job_now',
-            _send_message,
-            server=self.server,
-            encryption=self.encryption,
-            username=self.username,
-            password=self.password,
-            msg=msg,
-        )
-
-    def send_mail(self, *args, **kwargs):
+        self.bus.publish('schedule_task', self.send_mail, *args, **kwargs)
+
+    def send_mail(self, subject: str, message: str, to=None, cc=None, bcc=None, reply_to=None, headers={}):
         """
         Reusable method to be called to send email to the user user.
         `user` user object where to send the email.
         """
+        assert subject
+        assert message
+        assert to or bcc
+
         # Skip sending email if smtp server is not configured.
         if not self.server:
-            cherrypy.log('cannot send email because SMTP Server is not configured', context='SMTP')
+            self.bus.log('cannot send email because SMTP Server is not configured')
             return
         if not self.email_from:
-            cherrypy.log('cannot send email because SMTP From is not configured', context='SMTP')
+            self.bus.log('cannot send email because SMTP From is not configured')
             return
 
-        msg = self._create_msg(*args, **kwargs)
-        _send_message(
-            server=self.server, encryption=self.encryption, username=self.username, password=self.password, msg=msg
-        )
+        # Record the MIME types of both parts - text/plain and text/html.
+        msg = MIMEMultipart('alternative')
+        msg['Subject'] = str(subject)
+        msg['From'] = _formataddr(self.email_from)
+        if to:
+            msg['To'] = _formataddr(to)
+        if cc:
+            msg['Cc'] = _formataddr(cc)
+        if bcc:
+            msg['Bcc'] = _formataddr(bcc)
+        if reply_to:
+            msg['Reply-To'] = _formataddr(reply_to)
+        msg['Message-ID'] = email.utils.make_msgid()
+        if headers:
+            for key, value in headers.items():
+                msg[key] = value
+        text = _html2plaintext(message)
+        msg.attach(MIMEText(text, 'plain', 'utf8'))
+        msg.attach(MIMEText(message, 'html', 'utf8'))
+
+        host, unused, port = self.server.partition(':')
+        if self.encryption == 'ssl':
+            conn = smtplib.SMTP_SSL(host, port or 465)
+        else:
+            conn = smtplib.SMTP(host, port or 25)
+        try:
+            if self.encryption == 'starttls':
+                conn.starttls()
+            # Authenticate if required.
+            if self.username:
+                conn.login(self.username, self.password)
+            conn.send_message(msg)
+        finally:
+            conn.quit()
 
 
 # Register SMTP plugin

cherrypy_foundation/plugins/tests/test_db.py

@@ -1,5 +1,5 @@
-# Cherrypy-foundation
-# Copyright (C) 2022-2026 IKUS Software
+# Cherrypy Foundation
+# Copyright (C) 2022-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
@@ -93,7 +93,7 @@ else:
             # Given an empty database
             self.assertEqual(0, User.query.count())
             # When calling "/add/" to create a user
-            self.getPage('/add', method='POST', body=urlencode({'username': 'myuser'}))
+            self.getPage('/add', method='POST', body=urlencode([('username', 'myuser')]))
             self.assertStatus(200)
             self.assertInBody('OK')
             # Then user get added to database
@@ -103,7 +103,7 @@ else:
             # Given a database with a users
             User(username='user1').add().commit()
             # When trying to add another user
-            self.getPage('/add', method='POST', body=urlencode({'username': 'user1'}))
+            self.getPage('/add', method='POST', body=urlencode([('username', 'user1')]))
             # Then an error get raised
             self.assertStatus(200)
             self.assertInBody('user_username_unique_ix')

cherrypy_foundation/plugins/tests/test_ldap.py

@@ -1,5 +1,5 @@
 # LDAP Plugins for cherrypy
-# Copyright (C) 2026 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
@@ -19,13 +19,13 @@ Created on Oct 17, 2015
 @author: Patrik Dufresne <patrik@ikus-soft.com>
 """
 import os
-from unittest import TestCase, mock, skipUnless
+from unittest import mock, skipUnless
 
 import cherrypy
 import ldap3
 from cherrypy.test import helper
 
-from ..ldap import all_attribute, first_attribute  # noqa
+from .. import ldap  # noqa
 
 original_connection = ldap3.Connection
 
@@ -35,79 +35,6 @@ def mock_ldap_connection(*args, **kwargs):
     return original_connection(*args, client_strategy=ldap3.MOCK_ASYNC, **kwargs)
 
 
-class LdapFirstAttributeTest(TestCase):
-
-    def test_no_keys_returns_default(self):
-        attributes = {"cn": ["John Doe"]}
-        self.assertIsNone(first_attribute(attributes, None))
-        self.assertEqual(first_attribute(attributes, [], default="fallback"), "fallback")
-
-    def test_single_key_with_scalar_value(self):
-        attributes = {"uid": "jdoe"}
-        self.assertEqual(first_attribute(attributes, "uid"), "jdoe")
-
-    def test_single_key_with_list_value(self):
-        attributes = {"mail": ["john@example.com", "alt@example.com"]}
-        self.assertEqual(first_attribute(attributes, "mail"), "john@example.com")
-
-    def test_empty_list_value_is_skipped(self):
-        attributes = {
-            "mail": [],
-            "uid": ["jdoe"],
-        }
-        self.assertEqual(first_attribute(attributes, ["mail", "uid"]), "jdoe")
-
-    def test_missing_first_key_uses_next_key(self):
-        attributes = {"cn": ["John Doe"]}
-        self.assertEqual(first_attribute(attributes, ["sn", "cn"]), "John Doe")
-
-    def test_all_keys_missing_returns_default(self):
-        attributes = {"cn": ["John Doe"]}
-        self.assertEqual(first_attribute(attributes, ["sn", "uid"], default="unknown"), "unknown")
-
-    def test_key_not_found_without_default_returns_none(self):
-        attributes = {"cn": ["John Doe"]}
-        self.assertIsNone(first_attribute(attributes, "uid"))
-
-
-class LdapAllAttributeTest(TestCase):
-
-    def test_no_keys_returns_default(self):
-        attributes = {"cn": ["John Doe"]}
-        self.assertIsNone(all_attribute(attributes, None))
-        self.assertEqual(all_attribute(attributes, [], default="fallback"), "fallback")
-
-    def test_single_key_with_scalar_value(self):
-        attributes = {"uid": "jdoe"}
-        self.assertEqual(all_attribute(attributes, "uid"), ["jdoe"])
-
-    def test_single_key_with_list_value(self):
-        attributes = {"mail": ["john@example.com", "alt@example.com"]}
-        self.assertEqual(all_attribute(attributes, "mail"), ["john@example.com"])
-
-    def test_multiple_keys_collect_values(self):
-        attributes = {
-            "uid": "jdoe",
-            "cn": ["John Doe"],
-        }
-        self.assertEqual(all_attribute(attributes, ["uid", "cn"]), ["jdoe", "John Doe"])
-
-    def test_missing_keys_are_skipped(self):
-        attributes = {"cn": ["John Doe"]}
-        self.assertEqual(all_attribute(attributes, ["sn", "cn", "uid"]), ["John Doe"])
-
-    def test_all_keys_missing_returns_default(self):
-        attributes = {"cn": ["John Doe"]}
-        self.assertEqual(all_attribute(attributes, ["sn", "uid"], default=[]), [])
-
-    def test_empty_list_value_is_appended_as_empty_list(self):
-        attributes = {
-            "mail": [],
-            "uid": "jdoe",
-        }
-        self.assertEqual(all_attribute(attributes, ["mail", "uid"]), [[], "jdoe"])
-
-
 class LdapPluginTest(helper.CPWebCase):
 
     @classmethod