schd 0.0.10__tar.gz → 0.0.13__tar.gz

{schd-0.0.10 → schd-0.0.13}/PKG-INFO

@@ -1,7 +1,8 @@
 Metadata-Version: 2.1
 Name: schd
-Version: 0.0.10
+Version: 0.0.13
 Home-page: https://github.com/kevenli/schd
 License: ApacheV2
 Requires-Dist: apscheduler<4.0
 Requires-Dist: pyaml
+Requires-Dist: aiohttp

{schd-0.0.10 → schd-0.0.13}/README.md

@@ -20,6 +20,24 @@ start a daemon
 schd -c conf/schd.yaml
 ```
 
+## local scheduler
+default 
+
+conf/schd.yaml
+```
+scheduler_cls: LocalScheduler
+```
+
+## remote scheduler
+schedule by RemoteScheduler (schd-server)
+
+conf/schd.yaml
+```
+scheduler_cls: RemoteScheduler
+scheduler_remote_host: http://localhost:8899/
+worker_name: local
+```
+
 
 # Email Notifier
 

schd-0.0.13/schd/__init__.py

@@ -0,0 +1 @@
+__version__ = '0.0.12'

{schd-0.0.10 → schd-0.0.13}/schd/cmds/daemon.py

@@ -1,3 +1,4 @@
+import asyncio
 import logging
 import sys
 from .base import CommandBase
@@ -22,4 +23,4 @@ class DaemonCommand(CommandBase):
             log_stream = sys.stdout
 
         logging.basicConfig(level=logging.INFO, format='%(asctime)s %(name)s %(levelname)s %(message)s', datefmt='%Y-%m-%d %H:%M:%S', stream=log_stream)
-        run_daemon(config_file)
+        asyncio.run(run_daemon(config_file))

schd-0.0.13/schd/config.py

@@ -0,0 +1,101 @@
+from dataclasses import dataclass, field, fields, is_dataclass
+import os
+from typing import Any, Dict, Optional, Type, TypeVar, Union, get_args, get_origin, get_type_hints
+import yaml
+
+T = TypeVar("T", bound="ConfigValue")
+
+
+class ConfigValue:
+    """
+    ConfigValue present some config settings.
+    A configvalue class should also be decorated as @dataclass.
+    A ConfigValue class contains some fields, for example:
+
+    @dataclass
+    class SimpleIntValue(ConfigValue):
+        a: int
+
+    User can call derived class 's from_dict class method to construct an instance.
+    config = SimpleIntValue.from_dict({'a': 1})
+    """
+    @classmethod
+    def from_dict(cls: Type[T], data: Dict[str, Any]) -> T:
+        """
+        Creates an instance of the class using the fields specified in the dictionary.
+        Handles nested fields that are also derived from ConfigValue.
+        """
+        type_hints = get_type_hints(cls)
+        init_data:Dict[str,Any] = {}
+        if not is_dataclass(cls):
+            raise TypeError('class %s is not dataclass' % cls)
+        
+        for f in fields(cls):
+            field_name = f.name
+            json_key = f.metadata.get("json", f.name)
+            field_type = type_hints[field_name]
+            origin = get_origin(field_type)
+            args = get_args(field_type)
+
+            if json_key in data:
+                value = data[json_key]
+                # Handle nested ConfigValue objects
+                if isinstance(field_type, type) and issubclass(field_type, ConfigValue):
+                    init_data[field_name] = field_type.from_dict(value)
+                # Handle lists of ConfigValue objects   List[ConfigValue]
+                elif origin is list and issubclass(args[0], ConfigValue):
+                    nested_type = field_type.__args__[0]
+                    init_data[field_name] = [nested_type.from_dict(item) for item in value]
+                    # Handle Optional[ConfigValue]
+                elif origin is Union and type(None) in args:
+                    actual_type = next((arg for arg in args if arg is not type(None)), None)
+                    if actual_type and issubclass(actual_type, ConfigValue):
+                        init_data[field_name] = actual_type.from_dict(value) if value is not None else None
+                    else:
+                        init_data[field_name] = value
+                # Case 4: Dict[str, ConfigValue]
+                elif origin is dict and issubclass(args[1], ConfigValue):
+                    value_type = args[1]
+                    init_data[field_name] = {
+                        k: value_type.from_dict(v) for k, v in value.items()
+                    }
+                else:
+                    init_data[field_name] = value
+        return cls(**init_data)
+
+
+@dataclass
+class JobConfig(ConfigValue):
+    cls: str = field(metadata={"json": "class"})
+    cron: str
+    cmd: Optional[str] = None
+    params: dict = field(default_factory=dict)
+    timezone: Optional[str] = None
+    queue: str = ''
+
+
+@dataclass
+class SchdConfig(ConfigValue):
+    jobs: Dict[str, JobConfig] = field(default_factory=dict)
+    scheduler_cls: str = 'LocalScheduler'
+    scheduler_remote_host: Optional[str] = None
+    worker_name: str = 'local'
+
+    def __getitem__(self,key):
+        # compatible to old fashion config['key']
+        if hasattr(self, key):
+            return getattr(self,key)
+        else:
+            raise KeyError(key)
+
+
+def read_config(config_file=None) -> SchdConfig:
+    if config_file is None and 'SCHD_CONFIG' in os.environ:
+        config_file = os.environ['SCHD_CONFIG']
+
+    if config_file is None:
+        config_file = 'conf/schd.yaml'
+
+    with open(config_file, 'r', encoding='utf8') as f:
+        config = SchdConfig.from_dict(yaml.load(f, Loader=yaml.FullLoader))
+        return config

schd-0.0.13/schd/job.py

@@ -0,0 +1,25 @@
+from typing import Protocol, Union
+
+
+class JobExecutionResult(Protocol):
+    def get_code(self) -> int:...
+
+
+class JobContext:
+    def __init__(self, job_name:str, logger=None, stdout=None, stderr=None):
+        self.job_name = job_name
+        self.logger = logger
+        self.output_to_console = False
+        self.stdout = stdout
+        self.stderr = stderr
+
+
+class Job(Protocol):
+    """
+    Protocol to represent a job structure.
+    """
+    def execute(self, context:JobContext) -> Union[JobExecutionResult, int, None]:
+        """
+        execute the job
+        """
+        pass

{schd-0.0.10 → schd-0.0.13}/schd/scheduler.py

@@ -1,9 +1,12 @@
 import argparse
+import asyncio
+from contextlib import redirect_stdout
 import logging
 import importlib
+import io
 import os
 import sys
-from typing import Any
+from typing import Any, Optional, Dict
 import smtplib
 from email.mime.text import MIMEText
 from email.header import Header
@@ -12,33 +15,41 @@ import tempfile
 from apscheduler.schedulers.blocking import BlockingScheduler
 from apscheduler.triggers.cron import CronTrigger
 from apscheduler.executors.pool import ThreadPoolExecutor
-import yaml
 from schd import __version__ as schd_version
+from schd.schedulers.remote import RemoteScheduler
 from schd.util import ensure_bool
-
+from schd.job import Job, JobContext, JobExecutionResult
+from schd.config import JobConfig, SchdConfig, read_config
 
 logger = logging.getLogger(__name__)
 
 
-def build_job(job_name, job_class_name, config):
-    if not '.' in job_class_name:
+class DefaultJobExecutionResult(JobExecutionResult):
+    def __init__(self, code:int, log:str):
+        self.code = code
+        self.log = log
+
+
+def build_job(job_name, job_class_name, config:JobConfig)->Job:
+    if not ':' in job_class_name:
         module = sys.modules[__name__]
         job_cls = getattr(module, job_class_name)
     else:
-        module_name, cls_name = job_class_name.rsplit('.', 1)
+        # format    "packagea.moduleb:ClassC"
+        module_name, cls_name = job_class_name.rsplit(':', 1)
         m = importlib.import_module(module_name)
         job_cls = getattr(m, cls_name)
 
     if hasattr(job_cls, 'from_settings'):
         job = job_cls.from_settings(job_name=job_name, config=config)
     else:
-        job = job_cls(**config)
+        job = job_cls(**config.params)
 
     return job
 
 
 class JobFailedException(Exception):
-    def __init__(self, job_name, error_message, inner_ex:"Exception"=None):
+    def __init__(self, job_name, error_message, inner_ex:"Optional[Exception]"=None):
         self.job_name = job_name
         self.error_message = error_message
         self.inner_ex = inner_ex
@@ -51,12 +62,6 @@ class CommandJobFailedException(JobFailedException):
         self.output = output
 
 
-class JobContext:
-    def __init__(self, job_name):
-        self.job_name = job_name
-        self.output_to_console = False
-
-
 class CommandJob:
     def __init__(self, cmd, job_name=None):
         self.cmd = cmd
@@ -65,9 +70,30 @@ class CommandJob:
 
     @classmethod
     def from_settings(cls, job_name=None, config=None, **kwargs):
-        return cls(cmd=config['cmd'], job_name=job_name)
+        # compatible with old cmd field
+        command = config.params.get('cmd') or config.cmd
+        return cls(cmd=command, job_name=job_name)
     
-    def __call__(self, context:"JobContext"=None, **kwds: Any) -> Any:
+    def execute(self, context:JobContext) -> int:
+        process = subprocess.Popen(
+            self.cmd,
+            shell=True,
+            env=os.environ,
+            stdout=subprocess.PIPE,
+            stderr=subprocess.PIPE,
+            text=True
+        )
+
+        stdout, stderr = process.communicate()
+        if context.stdout:
+            context.stdout.write(stdout)
+            context.stdout.write(stderr)
+                
+        ret_code = process.wait()
+        return ret_code
+
+    
+    def __call__(self, context:"Optional[JobContext]"=None, **kwds: Any) -> Any:
         output_to_console = False
         if context is not None:
             output_to_console = context.output_to_console
@@ -120,7 +146,6 @@ class EmailErrorNotifier:
 
     def __call__(self, ex:"Exception"):
         if isinstance(ex, JobFailedException):
-            ex: "JobFailedException" = ex
             job_name = ex.job_name
             error_message = str(ex)
         else:
@@ -129,9 +154,9 @@ class EmailErrorNotifier:
 
         mail_subject = f'Schd job failed. {job_name}' 
         msg = MIMEText(error_message, 'plain', 'utf8')
-        msg['From'] = Header(self.from_addr)
-        msg['To'] = Header(self.to_addr)
-        msg['Subject'] = Header(mail_subject)
+        msg['From'] = str(Header(self.from_addr, 'utf8'))
+        msg['To'] = str(Header(self.to_addr, 'utf8'))
+        msg['Subject'] = str(Header(mail_subject, 'utf8'))
 
         try:
             smtp = smtplib.SMTP(self.smtp_server, self.smtp_port)
@@ -153,24 +178,104 @@ class ConsoleErrorNotifier:
         print(e)
 
 
-def read_config(config_file=None):
-    if config_file is None and 'SCHD_CONFIG' in os.environ:
-        config_file = os.environ['SCHD_CONFIG']
+class LocalScheduler:
+    def __init__(self, max_concurrent_jobs: int = 10):
+        """
+        Initialize the LocalScheduler with support for concurrent job execution.
+        
+        :param max_concurrent_jobs: Maximum number of jobs to run concurrently.
+        """
+        executors = {
+            'default': ThreadPoolExecutor(max_concurrent_jobs)
+        }
+        self.scheduler = BlockingScheduler(executors=executors)
+        self._jobs:Dict[str, Job] = {}
+        logger.info("LocalScheduler initialized in 'local' mode with concurrency support")
+
+    async def init(self):
+        pass
+
+    async def add_job(self, job: Job, job_name: str, job_config:JobConfig) -> None:
+        """
+        Add a job to the scheduler.
+
+        :param job: An instance of a class conforming to the Job protocol.
+        :param cron_expression: A string representing the cron schedule.
+        :param job_name: Optional name for the job.
+        """
+        self._jobs[job_name] = job
+        try:
+            cron_expression = job_config.cron
+            cron_trigger = CronTrigger.from_crontab(cron_expression)
+            self.scheduler.add_job(self.execute_job, cron_trigger, kwargs={'job_name':job_name})
+            logger.info(f"Job '{job_name or job.__class__.__name__}' added with cron expression: {cron_expression}")
+        except Exception as e:
+            logger.error(f"Failed to add job '{job_name or job.__class__.__name__}': {str(e)}")
+            raise
+
+    def execute_job(self, job_name:str):
+        job = self._jobs[job_name]
+        output_stream = io.StringIO()
+        context = JobContext(job_name=job_name, stdout=output_stream)
+        try:
+            with redirect_stdout(output_stream):
+                job_result = job.execute(context)
+
+            if job_result is None:
+                ret_code = 0
+            elif isinstance(job_result, int):
+                ret_code = job_result
+            elif hasattr(job_result, 'get_code'):
+                ret_code = job_result.get_code()
+            else:
+                raise ValueError('unsupported result type: %s', job_result)
+            
+        except Exception as ex:
+            logger.exception('error when executing job, %s', ex)
+            ret_code = -1
+
+        logger.info('job %s execute complete: %d', job_name, ret_code)
+        logger.info('job %s process output: \n%s', job_name, output_stream.getvalue())
 
-    if config_file is None:
-        config_file = 'conf/schd.yaml'
+    def run(self):
+        """
+        Start the scheduler.
+        """
+        try:
+            logger.info("Starting LocalScheduler...")
+            self.scheduler.start()
+        except (KeyboardInterrupt, SystemExit):
+            logger.info("Scheduler stopped.")
 
-    with open(config_file, 'r', encoding='utf8') as f:
-        config = yaml.load(f, Loader=yaml.FullLoader)
+    def start(self):
+        self.scheduler.start()
 
-    return config
+
+def build_scheduler(config:SchdConfig):
+    scheduler_cls = os.environ.get('SCHD_SCHEDULER_CLS') or config.scheduler_cls
+    
+    if scheduler_cls == 'LocalScheduler':
+        scheduler = LocalScheduler()
+    elif scheduler_cls == 'RemoteScheduler':
+        logger.info('scheduler_cls: %s', scheduler_cls)
+        scheduler_remote_host = os.environ.get('SCHD_SCHEDULER_REMOTE_HOST') or config.scheduler_remote_host
+        assert scheduler_remote_host, 'scheduler_remote_host cannot be none'
+        logger.info('scheduler_remote_host: %s ', scheduler_remote_host)
+        worker_name = os.environ.get('SCHD_WORKER_NAME') or config.worker_name
+        assert worker_name, 'worker_name cannot be none'
+        logger.info('worker_name: %s ', worker_name)
+        scheduler = RemoteScheduler(worker_name=worker_name, remote_host=scheduler_remote_host)
+    else:
+        raise ValueError('invalid scheduler_cls: %s' % scheduler_cls)
+    return scheduler
 
 
-def run_daemon(config_file=None):
+async def run_daemon(config_file=None):
     config = read_config(config_file=config_file)
-    sched = BlockingScheduler(executors={'default': ThreadPoolExecutor(10)})
+    scheduler = build_scheduler(config)
+    await scheduler.init()
 
-    if 'error_notifier' in config:
+    if hasattr(config, 'error_notifier'):
         error_notifier_config = config['error_notifier']
         error_notifier_type = error_notifier_config.get('type', 'console')
         if error_notifier_type == 'console':
@@ -196,24 +301,28 @@ def run_daemon(config_file=None):
     else:
         job_error_handler = ConsoleErrorNotifier()
         
-    for job_name, job_config in config['jobs'].items():
-        job_class_name = job_config.pop('class')
-        job_cron = job_config.pop('cron')
+    for job_name, job_config in config.jobs.items():
+        job_class_name = job_config.cls
+        job_cron = job_config.cron
         job = build_job(job_name, job_class_name, job_config)
-        job_warpped = JobExceptionWrapper(job, job_error_handler)
-        sched.add_job(job_warpped, CronTrigger.from_crontab(job_cron), id=job_name, misfire_grace_time=10)
+        await scheduler.add_job(job, job_name, job_config)
         logger.info('job added, %s', job_name)
 
     logger.info('scheduler starting.')
-    sched.start()
+    scheduler.start()
+    while True:
+        await asyncio.sleep(1000)
 
-def main():
+
+async def main():
     parser = argparse.ArgumentParser()
     parser.add_argument('--logfile')
     parser.add_argument('--config', '-c')
     args = parser.parse_args()
     config_file = args.config
 
+    logging.basicConfig(level=logging.DEBUG)
+
     print(f'starting schd, {schd_version}, config_file={config_file}')
 
     if args.logfile:
@@ -224,8 +333,8 @@ def main():
         log_stream = sys.stdout
 
     logging.basicConfig(level=logging.INFO, format='%(asctime)s %(name)s - %(levelname)s %(message)s', datefmt='%Y-%m-%d %H:%M:%S', stream=log_stream)
-    run_daemon(config_file)
+    await run_daemon(config_file)
 
 
 if __name__ == '__main__':
-    main()
+    asyncio.run(main())

schd-0.0.13/schd/schedulers/remote.py

@@ -0,0 +1,173 @@
+import asyncio
+from contextlib import redirect_stdout
+import io
+import json
+import os
+from typing import Dict, Tuple
+from urllib.parse import urljoin
+import aiohttp
+import aiohttp.client_exceptions
+from schd.config import JobConfig
+from schd.job import JobContext, Job
+
+import logging
+
+logger = logging.getLogger(__name__)
+
+
+class RemoteApiClient:
+    def __init__(self, base_url:str):
+        self._base_url = base_url
+
+    async def register_worker(self, name:str):
+        url = urljoin(self._base_url, f'/api/workers/{name}')
+        async with aiohttp.ClientSession() as session:
+            async with session.put(url) as response:
+                response.raise_for_status()
+                result = await response.json()
+
+    async def register_job(self, worker_name, job_name, cron, timezone=None):
+        url = urljoin(self._base_url, f'/api/workers/{worker_name}/jobs/{job_name}')
+        post_data = {
+            'cron': cron,
+        }
+        if timezone:
+            post_data['timezone'] = timezone
+
+        async with aiohttp.ClientSession() as session:
+            async with session.put(url, json=post_data) as response:
+                response.raise_for_status()
+                result = await response.json()
+
+    async def subscribe_worker_eventstream(self, worker_name):
+        url = urljoin(self._base_url, f'/api/workers/{worker_name}/eventstream')
+
+        timeout = aiohttp.ClientTimeout(sock_read=600)
+        async with aiohttp.ClientSession(timeout=timeout) as session:
+            async with session.get(url) as resp:
+                resp.raise_for_status()
+                async for line in resp.content:
+                    decoded = line.decode("utf-8").strip()
+                    logger.info('got event, raw data: %s', decoded)
+                    event = json.loads(decoded)
+                    event_type = event['event_type']
+                    if event_type == 'NewJobInstance':
+                        # event = JobInstanceEvent()
+                        yield event
+                    else:
+                        raise ValueError('unknown event type %s' % event_type)
+                    
+    async def update_job_instance(self, worker_name, job_name, job_instance_id, status, ret_code=None):
+        url = urljoin(self._base_url, f'/api/workers/{worker_name}/jobs/{job_name}/{job_instance_id}')
+        post_data = {'status':status}
+        if ret_code is not None:
+            post_data['ret_code'] = ret_code
+
+        async with aiohttp.ClientSession() as session:
+            async with session.put(url, json=post_data) as response:
+                response.raise_for_status()
+                result = await response.json()
+
+    async def commit_job_log(self, worker_name, job_name, job_instance_id, logfile_path):
+        upload_url = urljoin(self._base_url, f'/api/workers/{worker_name}/jobs/{job_name}/{job_instance_id}/log')
+        async with aiohttp.ClientSession() as session:
+            with open(logfile_path, 'rb') as f:
+                data = aiohttp.FormData()
+                data.add_field('logfile', f, filename=os.path.basename(logfile_path), content_type='application/octet-stream')
+
+                async with session.put(upload_url, data=data) as resp:
+                    print("Status:", resp.status)
+                    print("Response:", await resp.text())
+
+
+class RemoteScheduler:
+    def __init__(self, worker_name:str, remote_host:str):
+        self.client = RemoteApiClient(remote_host)
+        self._worker_name = worker_name
+        self._jobs:"Dict[str,Tuple[Job,str]]" = {}
+        self._loop_task = None
+        self._loop = asyncio.get_event_loop()
+        self.queue_semaphores = {}
+
+    async def init(self):
+        await self.client.register_worker(self._worker_name)
+
+    async def add_job(self, job:Job, job_name:str, job_config:JobConfig):
+        cron = job_config.cron
+        queue_name = job_config.queue or ''
+        await self.client.register_job(self._worker_name, job_name=job_name, cron=cron, timezone=job_config.timezone)
+        self._jobs[job_name] = (job, queue_name)
+        if queue_name not in self.queue_semaphores:
+            # each queue has a max concurrency of 1
+            max_conc = 1
+            self.queue_semaphores[queue_name] = asyncio.Semaphore(max_conc)
+
+    async def start_main_loop(self):
+        while True:
+            logger.info('start_main_loop ')
+            try:
+                async for event in self.client.subscribe_worker_eventstream(self._worker_name):
+                    print(event)
+                    job_name = event['data']['job_name']
+                    instance_id = event['data']['id']
+                    _, queue_name = self._jobs[job_name]
+                    # Queue concurrency control
+                    semaphore = self.queue_semaphores[queue_name]
+                    self._loop.create_task(self._run_with_semaphore(semaphore, job_name, instance_id))
+                    # await self.execute_task(event['data']['job_name'], event['data']['id'])
+            except aiohttp.client_exceptions.ClientPayloadError:
+                logger.info('connection lost')
+                await asyncio.sleep(1)
+            except aiohttp.client_exceptions.SocketTimeoutError:
+                logger.info('SocketTimeoutError')
+                await asyncio.sleep(1)
+            except aiohttp.client_exceptions.ClientConnectorError:
+                # cannot connect, try later
+                logger.debug('connect failed, ClientConnectorError, try later.')
+                await asyncio.sleep(10)
+                continue
+            except Exception as ex:
+                logger.error('error in start_main_loop, %s', ex, exc_info=ex)
+                break
+
+    def start(self):
+        self._loop_task = self._loop.create_task(self.start_main_loop())
+
+    async def execute_task(self, job_name, instance_id:int):
+        job, _ = self._jobs[job_name]
+        logfile_dir = f'joblog/{instance_id}'
+        if not os.path.exists(logfile_dir):
+            os.makedirs(logfile_dir)
+        logfile_path = os.path.join(logfile_dir, 'output.txt')
+        output_stream = io.FileIO(logfile_path, mode='w+')
+        text_stream = io.TextIOWrapper(output_stream, encoding='utf-8')
+
+        context = JobContext(job_name=job_name, stdout=text_stream)
+        await self.client.update_job_instance(self._worker_name, job_name, instance_id, status='RUNNING')
+        try:
+            with redirect_stdout(text_stream):
+                job_result = job.execute(context)
+
+            if job_result is None:
+                ret_code = 0
+            elif isinstance(job_result, int):
+                ret_code = job_result
+            elif hasattr(job_result, 'get_code'):
+                ret_code = job_result.get_code()
+            else:
+                raise ValueError('unsupported result type: %s', job_result)
+            
+        except Exception as ex:
+            logger.exception('error when executing job, %s', ex)
+            ret_code = -1
+
+        logger.info('job %s execute complete: %d, log_file: %s', job_name, ret_code, logfile_path)
+        text_stream.flush()
+        output_stream.flush()
+        output_stream.close()
+        await self.client.commit_job_log(self._worker_name, job_name, instance_id, logfile_path)
+        await self.client.update_job_instance(self._worker_name, job_name, instance_id, status='COMPLETED', ret_code=ret_code)
+
+    async def _run_with_semaphore(self, semaphore, job_name, instance_id):
+        async with semaphore:
+            await self.execute_task(job_name, instance_id)

{schd-0.0.10 → schd-0.0.13}/schd.egg-info/PKG-INFO

@@ -1,7 +1,8 @@
 Metadata-Version: 2.1
 Name: schd
-Version: 0.0.10
+Version: 0.0.13
 Home-page: https://github.com/kevenli/schd
 License: ApacheV2
 Requires-Dist: apscheduler<4.0
 Requires-Dist: pyaml
+Requires-Dist: aiohttp

{schd-0.0.10 → schd-0.0.13}/schd.egg-info/SOURCES.txt

@@ -3,6 +3,8 @@ README.md
 setup.cfg
 setup.py
 schd/__init__.py
+schd/config.py
+schd/job.py
 schd/scheduler.py
 schd/util.py
 schd.egg-info/PKG-INFO
@@ -17,4 +19,7 @@ schd/cmds/daemon.py
 schd/cmds/jobs.py
 schd/cmds/run.py
 schd/cmds/schd.py
+schd/schedulers/__init__.py
+schd/schedulers/remote.py
+tests/test_scheduler.py
 tests/test_util.py

{schd-0.0.10 → schd-0.0.13}/schd.egg-info/requires.txt

@@ -1,2 +1,3 @@
 apscheduler<4.0
 pyaml
+aiohttp

{schd-0.0.10 → schd-0.0.13}/setup.py

@@ -7,10 +7,10 @@ def read_requirements():
 
 setup(
     name="schd",
-    version="0.0.10",
+    version="0.0.13",
     url="https://github.com/kevenli/schd",
     packages=find_packages(exclude=('tests', 'tests.*')),
-    install_requires=['apscheduler<4.0', 'pyaml'],
+    install_requires=['apscheduler<4.0', 'pyaml', 'aiohttp'],
     entry_points={
         'console_scripts': [
             'schd = schd.cmds.schd:main',

schd-0.0.13/tests/test_scheduler.py

@@ -0,0 +1,74 @@
+import unittest
+from contextlib import redirect_stdout
+import io
+from schd.config import JobConfig
+from schd.scheduler import LocalScheduler, build_job
+
+
+class TestOutputJob:
+    def execute(self, context):
+        print('test output')
+
+
+class RedirectStdoutTest(unittest.TestCase):
+    def test_redirect(self):
+        buffer = io.StringIO()
+        with redirect_stdout(buffer):
+            print("This goes into the buffer, not the console.")
+        output = buffer.getvalue()
+        # print(f"Captured: {output}")
+        self.assertEqual('This goes into the buffer, not the console.\n', output)
+
+    def test_redirect_job(self):
+        buffer = io.StringIO()
+        with redirect_stdout(buffer):
+            job = TestOutputJob()
+            job.execute(None)
+        output = buffer.getvalue()
+        self.assertEqual('test output\n', output)
+
+
+class LocalSchedulerTest(unittest.IsolatedAsyncioTestCase):
+    async def test_add_execute(self):
+        job = TestOutputJob()
+        target = LocalScheduler()
+        await target.add_job(job, "0 1 * * *", 'test_job')
+        target.execute_job("test_job")
+
+
+class JobHasParams:
+    def __init__(self, x, y):
+        self.x = x
+        self.y = y
+
+
+class JobHasFromSettingsMethod:
+    def __init__(self, job_name, z):
+        self.job_name = job_name
+        self.z = z
+    @classmethod
+    def from_settings(cls, job_name=None, config=None, **kwargs):
+        return JobHasFromSettingsMethod(job_name, config.params['z'])
+
+
+class TestBuildJob(unittest.TestCase):
+    def test_build_no_param(self):
+        job_cls = 'test_scheduler:TestOutputJob'
+        built_job = build_job('TestOutputJob', job_cls, JobConfig(cls=job_cls, cron='* * * * *'))
+        self.assertIsNotNone(built_job)
+
+    def test_build_has_param(self):
+        job_cls = 'test_scheduler:JobHasParams'
+        built_job:JobHasParams = build_job('JobHasParams', job_cls, JobConfig(cls=job_cls, cron='* * * * *', params={'x':1,'y':2}))
+        self.assertIsNotNone(built_job)
+        # build_job should pass params into contrustor accordingly
+        self.assertEqual(built_job.x, 1)
+        self.assertEqual(built_job.y, 2)
+
+    def test_build_from_settings(self):
+        job_cls = 'test_scheduler:JobHasFromSettingsMethod'
+        built_job:JobHasFromSettingsMethod = build_job('JobHasFromSettingsMethod', job_cls, JobConfig(cls=job_cls, cron='* * * * *', params={'z':3}))
+        self.assertIsNotNone(built_job)
+        # build_job should pass params into contrustor accordingly
+        self.assertEqual(built_job.job_name, 'JobHasFromSettingsMethod')
+        self.assertEqual(built_job.z, 3)

schd-0.0.10/schd/__init__.py

@@ -1 +0,0 @@
-__version__ = '0.0.10'