schd 0.0.16__tar.gz → 0.1.1__tar.gz

{schd-0.0.16 → schd-0.1.1}/PKG-INFO

@@ -1,8 +1,11 @@
-Metadata-Version: 2.1
-Name: schd
-Version: 0.0.16
-Home-page: https://github.com/kevenli/schd
-License: ApacheV2
-Requires-Dist: apscheduler<4.0
-Requires-Dist: pyaml
-Requires-Dist: aiohttp
+Metadata-Version: 2.4
+Name: schd
+Version: 0.1.1
+Home-page: https://github.com/kevenli/schd
+License: ApacheV2
+Requires-Dist: apscheduler<4.0
+Requires-Dist: pyaml
+Requires-Dist: aiohttp
+Dynamic: home-page
+Dynamic: license
+Dynamic: requires-dist

schd-0.1.1/schd/__init__.py

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

{schd-0.0.16 → schd-0.1.1}/schd/cmds/base.py

@@ -4,6 +4,6 @@ class CommandBase:
     def add_arguments(self, parser):
         pass
 
-    def run(self, args):
+    def run(self, args, config):
         pass
     

{schd-0.0.16 → schd-0.1.1}/schd/cmds/daemon.py

@@ -8,12 +8,10 @@ from schd import __version__  as schd_version
 
 class DaemonCommand(CommandBase):
     def add_arguments(self, parser):
-        parser.add_argument('--config', '-c')
         parser.add_argument('--logfile')
 
-    def run(self, args):
-        config_file = args.config
-        print(f'starting schd, {schd_version}, config_file={config_file}')
+    def run(self, args, config):
+        print(f'starting schd, {schd_version}')
 
         if args.logfile:
             log_stream = open(args.logfile, 'a', encoding='utf8')
@@ -23,4 +21,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)
-        asyncio.run(run_daemon(config_file))
+        asyncio.run(run_daemon(config))

schd-0.1.1/schd/cmds/jobs.py

@@ -0,0 +1,19 @@
+"""
+list jobs
+"""
+import sys
+from .base import CommandBase
+
+
+class JobsCommand(CommandBase):
+    def add_arguments(self, parser):
+        # parser.add_argument('--config', '-c', default=None, help='config file')
+        pass
+
+    def run(self, args, config=None):
+        if config is None:
+            print("No configuration provided.")
+            sys.exit(1)
+
+        for job_name, _ in config.jobs.items():
+            print(job_name)

schd-0.1.1/schd/cmds/run.py

@@ -0,0 +1,27 @@
+import asyncio
+import logging
+import sys
+from schd.cmds.base import CommandBase
+from schd.scheduler import LocalScheduler, build_job
+
+
+async def run_job(config, job_name):
+    scheduler = LocalScheduler(config)
+    job_config = config.jobs[job_name]
+    job = build_job(job_name, job_config.cls, job_config)
+    await scheduler.add_job(job, job_name, job_config)
+    scheduler.execute_job(job_name)
+
+
+class RunCommand(CommandBase):
+    def add_arguments(self, parser):
+        parser.add_argument('job')
+
+    def run(self, args, config):
+        if config is None:
+            print("No configuration provided.")
+            sys.exit(1)
+            
+        logging.basicConfig(format='%(asctime)s %(name)s - %(levelname)s %(message)s', datefmt='%Y-%m-%d %H:%M:%S', level=logging.INFO)
+        job_name = args.job
+        asyncio.run(run_job(config, job_name))

{schd-0.0.16 → schd-0.1.1}/schd/cmds/schd.py

@@ -1,10 +1,11 @@
 import argparse
 import sys
 from schd.cmds.jobs import JobsCommand
-from schd.scheduler import main as scheduler_main
+from schd.config import ConfigFileNotFound, read_config
+from schd import __version__ as schd_version
 from .daemon import DaemonCommand
 from .run import RunCommand
-from schd import __version__ as schd_version
+
 
 commands = {
     'daemon': DaemonCommand(),
@@ -16,6 +17,7 @@ def main():
     sys.path.append('.')
     parser = argparse.ArgumentParser('schd')
     parser.add_argument('--version', action='store_true', default=False)
+    parser.add_argument('--config')
     sub_command_parsers = parser.add_subparsers(dest='cmd')
 
     for cmd, cmd_obj in commands.items():
@@ -23,6 +25,10 @@ def main():
         cmd_obj.add_arguments(sub_command_parser)
 
     args = parser.parse_args()
+    try:
+        config = read_config(args.config)
+    except ConfigFileNotFound:
+        config = None
 
     if args.version:
         print('schd version ', schd_version)
@@ -32,7 +38,7 @@ def main():
         parser.print_help()
         return
     
-    commands[args.cmd].run(args)
+    commands[args.cmd].run(args, config=config)
 
 
 if __name__ == '__main__':

schd-0.1.1/schd/cmds/scsendmail.py

@@ -0,0 +1,87 @@
+"""
+scsendmail - Send email via command line using EmailService
+
+Usage:
+    scsendmail --to someone@example.com --title "Report" --content "Text body"
+    scsendmail --to a@example.com --content-html-file ./body.html -a report.pdf
+"""
+
+import argparse
+import logging
+from pathlib import Path
+from typing import List, Optional
+import sys
+
+from schd.config import read_config, ConfigFileNotFound, EmailConfig
+from schd.email import EmailService
+
+
+def parse_recipients(values: Optional[List[str]]) -> List[str]:
+    if not values:
+        return []
+    emails = []
+    for val in values:
+        emails.extend(email.strip() for email in val.split(',') if email.strip())
+    return emails
+
+
+def main():
+    parser = argparse.ArgumentParser(description='scsendmail command')
+    parser.add_argument('--title', default='report', help='Email subject')
+    parser.add_argument('--content', default='no content', help='Plain text content')
+    parser.add_argument('--content-html-file', help='Path to HTML file for HTML content')
+    parser.add_argument('--to', dest='recipients', action='append', help='To recipients (comma-separated or multiple flags)')
+    parser.add_argument('--cc', action='append', help='CC recipients (comma-separated or multiple flags)')
+    parser.add_argument('--bcc', action='append', help='BCC recipients (comma-separated or multiple flags)')
+    parser.add_argument('--add-attach', '-a', action='append', dest='attachments', help='Attachment file paths')
+    parser.add_argument('--debug', action='store_true', default=False, help='Print instead of sending')
+    parser.add_argument('--config')
+    parser.add_argument('--loglevel', default='INFO', help='Logging level (DEBUG, INFO, WARNING, ERROR, CRITICAL)')
+
+    args = parser.parse_args()
+
+    logging.basicConfig(level=args.loglevel.upper(),
+                        format='%(asctime)s - %(name)s - %(levelname)s - %(message)s')
+
+    # Load HTML content if provided
+    html_content = None
+    if args.content_html_file:
+        try:
+            html_content = Path(args.content_html_file).read_text(encoding='utf-8')
+        except Exception as e:
+            print(f"Failed to read HTML content file: {e}", file=sys.stderr)
+            sys.exit(1)
+
+    # Load config from environment or config file
+    schd_config = read_config(args.config)
+    logging.debug(schd_config.email)
+    service = EmailService.from_config(schd_config.email)
+
+    to_emails = parse_recipients(args.recipients)
+    cc_emails = parse_recipients(args.cc)
+    bcc_emails = parse_recipients(args.bcc)
+    attachments = args.attachments or []
+
+    if args.debug:
+        print("DEBUG MODE: Email will not be sent")
+        print(f"Subject: {args.title}")
+        print(f"To: {to_emails}")
+        print(f"CC: {cc_emails}")
+        print(f"BCC: {bcc_emails}")
+        print(f"Attachments: {attachments}")
+        print(f"Content: {args.content}")
+        print(f"HTML Content File: {args.content_html_file}")
+    else:
+        service.send_mail(
+            title=args.title,
+            content=args.content,
+            content_html=html_content,
+            to_emails=to_emails,
+            cc_emails=cc_emails,
+            bcc_emails=bcc_emails,
+            attachments=attachments
+        )
+
+
+if __name__ == '__main__':
+    main()

{schd-0.0.16 → schd-0.1.1}/schd/config.py

@@ -28,15 +28,20 @@ class 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)
+            raise TypeError(f'class {cls} is not dataclass')
         
         for f in fields(cls):
             field_name = f.name
             json_key = f.metadata.get("json", f.name)
+            envvar_key = f.metadata.get('env_var')
             field_type = type_hints[field_name]
             origin = get_origin(field_type)
             args = get_args(field_type)
 
+            if envvar_key and envvar_key in os.environ:
+                init_data[field_name] = _cast_type(os.environ[envvar_key], field_type)
+                continue
+
             if json_key in data:
                 value = data[json_key]
                 # Handle nested ConfigValue objects
@@ -63,6 +68,44 @@ class ConfigValue:
                     init_data[field_name] = value
         return cls(**init_data)
 
+def _cast_type(value, target_type):
+    origin = get_origin(target_type)
+    args = get_args(target_type)
+
+    # Handle Optional[T] or Union[T1, T2, ...]
+    if origin is Union:
+        # Optional[str] is Union[str, NoneType]
+        for typ in args:
+            if typ is type(None):
+                continue  # skip NoneType
+            try:
+                return _cast_type(value, typ)
+            except (ValueError, TypeError):
+                continue
+        raise ValueError(f"Cannot cast {value!r} to any of {args}")
+    
+    # Handle base types
+    if target_type == bool:
+        return value.lower() in ('true', '1', 'yes', 'on', True)
+    elif target_type == int:
+        return int(value)
+    elif target_type == float:
+        return float(value)
+    elif target_type == str:
+        return value
+    else:
+        raise TypeError(f"Unsupported type: {target_type}")
+
+@dataclass
+class EmailConfig(ConfigValue):
+    smtp_server: Optional[str] = field(metadata={'env_var': 'SCHD_SMTP_SERVER'}, default=None)
+    smtp_user: Optional[str] = field(metadata={'env_var': 'SCHD_SMTP_USER'}, default=None)
+    smtp_password: Optional[str] = field(metadata={'env_var': 'SCHD_SMTP_PASS'}, default=None)
+    from_addr: Optional[str] = field(metadata={'env_var': 'SCHD_SMTP_FROM'}, default=None)
+    to_addr: Optional[str] = field(metadata={'env_var': 'SCHD_SMTP_TO'}, default=None)
+    smtp_port: int = field(metadata={'env_var': 'SCHD_SMTP_PORT'}, default=25)
+    smtp_starttls: bool = field(metadata={'env_var': 'SCHD_SMTP_TLS'}, default=False)
+
 
 @dataclass
 class JobConfig(ConfigValue):
@@ -80,6 +123,7 @@ class SchdConfig(ConfigValue):
     scheduler_cls: str = 'LocalScheduler'
     scheduler_remote_host: Optional[str] = None
     worker_name: str = 'local'
+    email: EmailConfig = field(default_factory=lambda: EmailConfig.from_dict({}))
 
     def __getitem__(self,key):
         # compatible to old fashion config['key']
@@ -89,13 +133,19 @@ class SchdConfig(ConfigValue):
             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']
+class ConfigFileNotFound(Exception):...
 
-    if config_file is None:
-        config_file = 'conf/schd.yaml'
 
-    with open(config_file, 'r', encoding='utf8') as f:
+def read_config(config_file=None) -> SchdConfig:
+    if config_file:
+        config_filepath = config_file
+    elif 'SCHD_CONFIG' in os.environ:
+        config_filepath = os.environ['SCHD_CONFIG']
+    elif os.path.exists('conf/schd.yaml'):
+        config_filepath = 'conf/schd.yaml'
+    else:
+        raise ConfigFileNotFound()
+
+    with open(config_filepath, 'r', encoding='utf8') as f:
         config = SchdConfig.from_dict(yaml.load(f, Loader=yaml.FullLoader))
         return config

schd-0.1.1/schd/email.py

@@ -0,0 +1,71 @@
+import smtplib
+from email.message import EmailMessage
+import logging
+from typing import List, Optional, Union
+import os
+from pathlib import Path
+from schd.config import EmailConfig
+
+logger = logging.getLogger(__name__)
+
+
+class EmailService:
+    def __init__(self, smtp_server: str, smtp_user: str, smtp_password: str,
+                 from_addr: str, smtp_port: int = 25, smtp_starttls: bool = False):
+        self.smtp_server = smtp_server
+        self.smtp_user = smtp_user
+        self.smtp_password = smtp_password
+        self.from_addr = from_addr
+        self.smtp_port = smtp_port
+        self.smtp_starttls = smtp_starttls
+
+    def send_mail(self, title: str, content: str, to_emails: Union[str, List[str]],
+                  attachments: Optional[List[str]] = None,
+                  content_html: Optional[str] = None,
+                  cc_emails: Optional[List[str]] = None,
+                  bcc_emails: Optional[List[str]] = None):
+        msg = EmailMessage()
+        msg['Subject'] = title
+        msg['From'] = self.from_addr
+        if isinstance(to_emails, str):
+            to_emails = [to_emails]
+        msg['To'] = ', '.join(to_emails)
+        if cc_emails:
+            msg['Cc'] = ', '.join(cc_emails)
+
+        recipients = to_emails + (cc_emails or []) + (bcc_emails or [])
+
+        # Add text and HTML
+        if content_html:
+            msg.set_content(content)
+            msg.add_alternative(content_html, subtype='html')
+        else:
+            msg.set_content(content)
+
+        # Attach files
+        for filepath in attachments or []:
+            file_path = Path(filepath)
+            with open(file_path, 'rb') as f:
+                file_data = f.read()
+                msg.add_attachment(file_data, maintype='application', subtype='octet-stream', filename=file_path.name)
+
+        # Send email
+        with smtplib.SMTP(self.smtp_server, self.smtp_port) as server:
+            if self.smtp_starttls:
+                server.starttls()
+            if self.smtp_user and self.smtp_password:
+                server.login(self.smtp_user, self.smtp_password)
+            else:
+                logger.info('no username/pass, skip logging in.')
+            server.send_message(msg, from_addr=self.from_addr, to_addrs=recipients)
+
+    @classmethod
+    def from_config(cls, config: 'EmailConfig') -> 'EmailService':
+        return cls(
+            smtp_server=config.smtp_server,
+            smtp_user=config.smtp_user,
+            smtp_password=config.smtp_password,
+            from_addr=config.from_addr,
+            smtp_port=config.smtp_port,
+            smtp_starttls=config.smtp_starttls
+        )

{schd-0.0.16 → schd-0.1.1}/schd/scheduler.py

@@ -5,6 +5,7 @@ import logging
 import importlib
 import io
 import os
+import socket
 import sys
 from typing import Any, Optional, Dict
 import smtplib
@@ -16,6 +17,7 @@ from apscheduler.schedulers.blocking import BlockingScheduler
 from apscheduler.triggers.cron import CronTrigger
 from apscheduler.executors.pool import ThreadPoolExecutor
 from schd import __version__ as schd_version
+from schd.email import EmailService
 from schd.schedulers.remote import RemoteScheduler
 from schd.util import ensure_bool
 from schd.job import Job, JobContext, JobExecutionResult
@@ -179,7 +181,7 @@ class ConsoleErrorNotifier:
 
 
 class LocalScheduler:
-    def __init__(self, max_concurrent_jobs: int = 10):
+    def __init__(self, config:SchdConfig, max_concurrent_jobs: int = 10):
         """
         Initialize the LocalScheduler with support for concurrent job execution.
         
@@ -190,6 +192,9 @@ class LocalScheduler:
         }
         self.scheduler = BlockingScheduler(executors=executors)
         self._jobs:Dict[str, Job] = {}
+        self.email_service = EmailService.from_config(config.email)
+        self.to_mail = config.email.to_addr
+        self.worker_name = config.worker_name or socket.gethostname()
         logger.info("LocalScheduler initialized in 'local' mode with concurrency support")
 
     async def init(self):
@@ -234,8 +239,13 @@ class LocalScheduler:
             logger.exception('error when executing job, %s', ex)
             ret_code = -1
 
+        output = output_stream.getvalue()
         logger.info('job %s execute complete: %d', job_name, ret_code)
-        logger.info('job %s process output: \n%s', job_name, output_stream.getvalue())
+        logger.info('job %s process output: \n%s', job_name, output)
+        if ret_code != 0 and self.to_mail:
+            self.email_service.send_mail('job failed %s %s' % (self.worker_name, job_name),
+                                         content=output,
+                                         to_emails=self.to_mail)
 
     def run(self):
         """
@@ -255,7 +265,7 @@ def build_scheduler(config:SchdConfig):
     scheduler_cls = os.environ.get('SCHD_SCHEDULER_CLS') or config.scheduler_cls
     
     if scheduler_cls == 'LocalScheduler':
-        scheduler = LocalScheduler()
+        scheduler = LocalScheduler(config)
     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
@@ -270,8 +280,7 @@ def build_scheduler(config:SchdConfig):
     return scheduler
 
 
-async def run_daemon(config_file=None):
-    config = read_config(config_file=config_file)
+async def run_daemon(config):
     scheduler = build_scheduler(config)
     await scheduler.init()
 
@@ -319,11 +328,12 @@ async def main():
     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}')
+    config = read_config(args.config)
+    print(f'starting schd, {schd_version}')
+    
 
     if args.logfile:
         log_stream = open(args.logfile, 'a', encoding='utf8')
@@ -333,7 +343,7 @@ async 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)
-    await run_daemon(config_file)
+    await run_daemon(config)
 
 
 if __name__ == '__main__':

{schd-0.0.16 → schd-0.1.1}/schd.egg-info/PKG-INFO

@@ -1,8 +1,11 @@
-Metadata-Version: 2.1
-Name: schd
-Version: 0.0.16
-Home-page: https://github.com/kevenli/schd
-License: ApacheV2
-Requires-Dist: apscheduler<4.0
-Requires-Dist: pyaml
-Requires-Dist: aiohttp
+Metadata-Version: 2.4
+Name: schd
+Version: 0.1.1
+Home-page: https://github.com/kevenli/schd
+License: ApacheV2
+Requires-Dist: apscheduler<4.0
+Requires-Dist: pyaml
+Requires-Dist: aiohttp
+Dynamic: home-page
+Dynamic: license
+Dynamic: requires-dist

{schd-0.0.16 → schd-0.1.1}/schd.egg-info/SOURCES.txt

@@ -1,9 +1,9 @@
-LICENSE
 README.md
 setup.cfg
 setup.py
 schd/__init__.py
 schd/config.py
+schd/email.py
 schd/job.py
 schd/scheduler.py
 schd/util.py
@@ -19,7 +19,10 @@ schd/cmds/daemon.py
 schd/cmds/jobs.py
 schd/cmds/run.py
 schd/cmds/schd.py
+schd/cmds/scsendmail.py
 schd/schedulers/__init__.py
 schd/schedulers/remote.py
+tests/test_config.py
+tests/test_email.py
 tests/test_scheduler.py
 tests/test_util.py

{schd-0.0.16 → schd-0.1.1}/schd.egg-info/entry_points.txt

@@ -1,2 +1,3 @@
 [console_scripts]
 schd = schd.cmds.schd:main
+scsendmail = schd.cmds.scsendmail:main

{schd-0.0.16 → schd-0.1.1}/setup.cfg

@@ -1,7 +1,7 @@
-[metadata]
-license_files = LICENSE
-
-[egg_info]
-tag_build = 
-tag_date = 0
-
+[metadata]
+license_files = LICENSE
+
+[egg_info]
+tag_build = 
+tag_date = 0
+

{schd-0.0.16 → schd-0.1.1}/setup.py

@@ -7,13 +7,14 @@ def read_requirements():
 
 setup(
     name="schd",
-    version="0.0.16",
+    version="0.1.1",
     url="https://github.com/kevenli/schd",
     packages=find_packages(exclude=('tests', 'tests.*')),
     install_requires=['apscheduler<4.0', 'pyaml', 'aiohttp'],
     entry_points={
         'console_scripts': [
             'schd = schd.cmds.schd:main',
+            'scsendmail = schd.cmds.scsendmail:main',
         ],
     },
     license="ApacheV2",

schd-0.1.1/tests/test_config.py

@@ -0,0 +1,29 @@
+import unittest
+from schd.config import SchdConfig, JobConfig
+
+class TestSchdConfig(unittest.TestCase):
+    def setUp(self):
+        self.config = SchdConfig(
+            jobs={"job1": JobConfig(cls='', cron='* * * * *')},
+            scheduler_cls="RemoteScheduler",
+            scheduler_remote_host="10.0.0.1",
+            worker_name="remote_worker"
+        )
+
+    def test_get_existing_field(self):
+        self.assertEqual(self.config["scheduler_cls"], "RemoteScheduler")
+        self.assertEqual(self.config["worker_name"], "remote_worker")
+        self.assertEqual(self.config["scheduler_remote_host"], "10.0.0.1")
+
+    def test_jobs_access(self):
+        self.assertIn("job1", self.config.jobs)
+        self.assertEqual(self.config.jobs['job1'].cls, '')
+        # self.assertEqual(self.config["jobs"]["job1"].name, "job1")
+
+    def test_invalid_key_raises(self):
+        with self.assertRaises(KeyError):
+            _ = self.config["nonexistent"]
+
+    def test_attribute_access_still_works(self):
+        self.assertEqual(self.config.scheduler_cls, "RemoteScheduler")
+        self.assertEqual(self.config.worker_name, "remote_worker")

schd-0.1.1/tests/test_email.py

@@ -0,0 +1,68 @@
+import os
+import unittest
+from unittest.mock import patch
+from schd.config import EmailConfig
+from schd.email import EmailService
+
+
+class EmailConfigTest(unittest.TestCase):
+    def test_empty(self):
+        target = EmailConfig()
+        self.assertIsNone(target.smtp_server)
+        self.assertIsNone(target.smtp_user)
+        self.assertIsNone(target.smtp_password)
+        self.assertIsNone(target.from_addr)
+        self.assertIsNone(target.to_addr)
+        self.assertEqual(target.smtp_port, 25)
+        self.assertEqual(target.smtp_starttls, False)
+
+    @patch.dict(os.environ, {"SCHD_SMTP_SERVER": "smtp.test.com"}, clear=True)
+    def test_env_var_override(self):
+        config = EmailConfig.from_dict(dict(
+            smtp_server="default.server",
+            smtp_user="user",
+            smtp_password="pass",
+            from_addr="from@example.com",
+            to_addr="to@example.com"
+        ))
+
+        # value should have been overrided by environ variable
+        self.assertEqual(config.smtp_server, "smtp.test.com")
+        self.assertEqual(config.smtp_user, "user")  # not from env, uses instance value
+
+    @patch.dict(os.environ, {"SCHD_SMTP_PORT": "589"}, clear=False)
+    def test_env_port_type(self):
+        # call `from_dict` to let env_var override effective
+        config = EmailConfig.from_dict(dict(
+            smtp_server="default.server",
+            smtp_user="user",
+            smtp_password="pass",
+            from_addr="from@example.com",
+            to_addr="to@example.com"
+        ))
+
+        self.assertEqual(config.smtp_port, 589)
+
+    @patch.dict(os.environ, {"SCHD_SMTP_TLS": "true"}, clear=False)
+    def test_env_tls_type(self):
+        config = EmailConfig.from_dict(dict(
+            smtp_server="default.server",
+            smtp_user="user",
+            smtp_password="pass",
+            from_addr="from@example.com",
+            to_addr="to@example.com"
+        ))
+
+        self.assertEqual(config.smtp_starttls, True)
+
+
+class EmailServiceTest(unittest.TestCase):
+    def test_send_email(self):
+        config = EmailConfig.from_dict(dict())
+        service = EmailService.from_config(config)
+        try:
+            recipient = os.environ['SCHD_SMTP_TO']
+        except KeyError:
+            raise unittest.SkipTest('SCHD_SMTP_TO env not specified, skip test')
+        
+        service.send_mail('test', 'test_content', recipient)

{schd-0.0.16 → schd-0.1.1}/tests/test_scheduler.py

@@ -1,7 +1,7 @@
 import unittest
 from contextlib import redirect_stdout
 import io
-from schd.config import JobConfig
+from schd.config import JobConfig, read_config
 from schd.scheduler import LocalScheduler, build_job
 
 
@@ -31,8 +31,9 @@ class RedirectStdoutTest(unittest.TestCase):
 class LocalSchedulerTest(unittest.IsolatedAsyncioTestCase):
     async def test_add_execute(self):
         job = TestOutputJob()
-        target = LocalScheduler()
-        await target.add_job(job, "0 1 * * *", 'test_job')
+        config = read_config('tests/conf/schd.yaml')
+        target = LocalScheduler(config)
+        await target.add_job(job, 'test_job', config.jobs['ls'])
         target.execute_job("test_job")
 
 

schd-0.0.16/LICENSE

@@ -1,201 +0,0 @@
-                                 Apache License
-                           Version 2.0, January 2004
-                        http://www.apache.org/licenses/
-
-   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
-
-   1. Definitions.
-
-      "License" shall mean the terms and conditions for use, reproduction,
-      and distribution as defined by Sections 1 through 9 of this document.
-
-      "Licensor" shall mean the copyright owner or entity authorized by
-      the copyright owner that is granting the License.
-
-      "Legal Entity" shall mean the union of the acting entity and all
-      other entities that control, are controlled by, or are under common
-      control with that entity. For the purposes of this definition,
-      "control" means (i) the power, direct or indirect, to cause the
-      direction or management of such entity, whether by contract or
-      otherwise, or (ii) ownership of fifty percent (50%) or more of the
-      outstanding shares, or (iii) beneficial ownership of such entity.
-
-      "You" (or "Your") shall mean an individual or Legal Entity
-      exercising permissions granted by this License.
-
-      "Source" form shall mean the preferred form for making modifications,
-      including but not limited to software source code, documentation
-      source, and configuration files.
-
-      "Object" form shall mean any form resulting from mechanical
-      transformation or translation of a Source form, including but
-      not limited to compiled object code, generated documentation,
-      and conversions to other media types.
-
-      "Work" shall mean the work of authorship, whether in Source or
-      Object form, made available under the License, as indicated by a
-      copyright notice that is included in or attached to the work
-      (an example is provided in the Appendix below).
-
-      "Derivative Works" shall mean any work, whether in Source or Object
-      form, that is based on (or derived from) the Work and for which the
-      editorial revisions, annotations, elaborations, or other modifications
-      represent, as a whole, an original work of authorship. For the purposes
-      of this License, Derivative Works shall not include works that remain
-      separable from, or merely link (or bind by name) to the interfaces of,
-      the Work and Derivative Works thereof.
-
-      "Contribution" shall mean any work of authorship, including
-      the original version of the Work and any modifications or additions
-      to that Work or Derivative Works thereof, that is intentionally
-      submitted to Licensor for inclusion in the Work by the copyright owner
-      or by an individual or Legal Entity authorized to submit on behalf of
-      the copyright owner. For the purposes of this definition, "submitted"
-      means any form of electronic, verbal, or written communication sent
-      to the Licensor or its representatives, including but not limited to
-      communication on electronic mailing lists, source code control systems,
-      and issue tracking systems that are managed by, or on behalf of, the
-      Licensor for the purpose of discussing and improving the Work, but
-      excluding communication that is conspicuously marked or otherwise
-      designated in writing by the copyright owner as "Not a Contribution."
-
-      "Contributor" shall mean Licensor and any individual or Legal Entity
-      on behalf of whom a Contribution has been received by Licensor and
-      subsequently incorporated within the Work.
-
-   2. Grant of Copyright License. Subject to the terms and conditions of
-      this License, each Contributor hereby grants to You a perpetual,
-      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
-      copyright license to reproduce, prepare Derivative Works of,
-      publicly display, publicly perform, sublicense, and distribute the
-      Work and such Derivative Works in Source or Object form.
-
-   3. Grant of Patent License. Subject to the terms and conditions of
-      this License, each Contributor hereby grants to You a perpetual,
-      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
-      (except as stated in this section) patent license to make, have made,
-      use, offer to sell, sell, import, and otherwise transfer the Work,
-      where such license applies only to those patent claims licensable
-      by such Contributor that are necessarily infringed by their
-      Contribution(s) alone or by combination of their Contribution(s)
-      with the Work to which such Contribution(s) was submitted. If You
-      institute patent litigation against any entity (including a
-      cross-claim or counterclaim in a lawsuit) alleging that the Work
-      or a Contribution incorporated within the Work constitutes direct
-      or contributory patent infringement, then any patent licenses
-      granted to You under this License for that Work shall terminate
-      as of the date such litigation is filed.
-
-   4. Redistribution. You may reproduce and distribute copies of the
-      Work or Derivative Works thereof in any medium, with or without
-      modifications, and in Source or Object form, provided that You
-      meet the following conditions:
-
-      (a) You must give any other recipients of the Work or
-          Derivative Works a copy of this License; and
-
-      (b) You must cause any modified files to carry prominent notices
-          stating that You changed the files; and
-
-      (c) You must retain, in the Source form of any Derivative Works
-          that You distribute, all copyright, patent, trademark, and
-          attribution notices from the Source form of the Work,
-          excluding those notices that do not pertain to any part of
-          the Derivative Works; and
-
-      (d) If the Work includes a "NOTICE" text file as part of its
-          distribution, then any Derivative Works that You distribute must
-          include a readable copy of the attribution notices contained
-          within such NOTICE file, excluding those notices that do not
-          pertain to any part of the Derivative Works, in at least one
-          of the following places: within a NOTICE text file distributed
-          as part of the Derivative Works; within the Source form or
-          documentation, if provided along with the Derivative Works; or,
-          within a display generated by the Derivative Works, if and
-          wherever such third-party notices normally appear. The contents
-          of the NOTICE file are for informational purposes only and
-          do not modify the License. You may add Your own attribution
-          notices within Derivative Works that You distribute, alongside
-          or as an addendum to the NOTICE text from the Work, provided
-          that such additional attribution notices cannot be construed
-          as modifying the License.
-
-      You may add Your own copyright statement to Your modifications and
-      may provide additional or different license terms and conditions
-      for use, reproduction, or distribution of Your modifications, or
-      for any such Derivative Works as a whole, provided Your use,
-      reproduction, and distribution of the Work otherwise complies with
-      the conditions stated in this License.
-
-   5. Submission of Contributions. Unless You explicitly state otherwise,
-      any Contribution intentionally submitted for inclusion in the Work
-      by You to the Licensor shall be under the terms and conditions of
-      this License, without any additional terms or conditions.
-      Notwithstanding the above, nothing herein shall supersede or modify
-      the terms of any separate license agreement you may have executed
-      with Licensor regarding such Contributions.
-
-   6. Trademarks. This License does not grant permission to use the trade
-      names, trademarks, service marks, or product names of the Licensor,
-      except as required for reasonable and customary use in describing the
-      origin of the Work and reproducing the content of the NOTICE file.
-
-   7. Disclaimer of Warranty. Unless required by applicable law or
-      agreed to in writing, Licensor provides the Work (and each
-      Contributor provides its Contributions) on an "AS IS" BASIS,
-      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
-      implied, including, without limitation, any warranties or conditions
-      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
-      PARTICULAR PURPOSE. You are solely responsible for determining the
-      appropriateness of using or redistributing the Work and assume any
-      risks associated with Your exercise of permissions under this License.
-
-   8. Limitation of Liability. In no event and under no legal theory,
-      whether in tort (including negligence), contract, or otherwise,
-      unless required by applicable law (such as deliberate and grossly
-      negligent acts) or agreed to in writing, shall any Contributor be
-      liable to You for damages, including any direct, indirect, special,
-      incidental, or consequential damages of any character arising as a
-      result of this License or out of the use or inability to use the
-      Work (including but not limited to damages for loss of goodwill,
-      work stoppage, computer failure or malfunction, or any and all
-      other commercial damages or losses), even if such Contributor
-      has been advised of the possibility of such damages.
-
-   9. Accepting Warranty or Additional Liability. While redistributing
-      the Work or Derivative Works thereof, You may choose to offer,
-      and charge a fee for, acceptance of support, warranty, indemnity,
-      or other liability obligations and/or rights consistent with this
-      License. However, in accepting such obligations, You may act only
-      on Your own behalf and on Your sole responsibility, not on behalf
-      of any other Contributor, and only if You agree to indemnify,
-      defend, and hold each Contributor harmless for any liability
-      incurred by, or claims asserted against, such Contributor by reason
-      of your accepting any such warranty or additional liability.
-
-   END OF TERMS AND CONDITIONS
-
-   APPENDIX: How to apply the Apache License to your work.
-
-      To apply the Apache License to your work, attach the following
-      boilerplate notice, with the fields enclosed by brackets "[]"
-      replaced with your own identifying information. (Don't include
-      the brackets!)  The text should be enclosed in the appropriate
-      comment syntax for the file format. We also recommend that a
-      file or class name and description of purpose be included on the
-      same "printed page" as the copyright notice for easier
-      identification within third-party archives.
-
-   Copyright [yyyy] [name of copyright owner]
-
-   Licensed under the Apache License, Version 2.0 (the "License");
-   you may not use this file except in compliance with the License.
-   You may obtain a copy of the License at
-
-       http://www.apache.org/licenses/LICENSE-2.0
-
-   Unless required by applicable law or agreed to in writing, software
-   distributed under the License is distributed on an "AS IS" BASIS,
-   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-   See the License for the specific language governing permissions and
-   limitations under the License.

schd-0.0.16/schd/__init__.py

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

schd-0.0.16/schd/cmds/jobs.py

@@ -1,16 +0,0 @@
-"""
-list jobs
-"""
-
-from schd.scheduler import read_config
-from .base import CommandBase
-
-
-class JobsCommand(CommandBase):
-    def add_arguments(self, parser):
-        parser.add_argument('--config', '-c', default=None, help='config file')
-
-    def run(self, args):
-        config = read_config(config_file=args.config)
-        for job_name, _ in config.jobs.items():
-            print(job_name)

schd-0.0.16/schd/cmds/run.py

@@ -1,26 +0,0 @@
-import logging
-from schd.cmds.base import CommandBase
-from schd.scheduler import build_job, read_config, JobContext
-
-
-def run_job(config_file, job_name):
-    config = read_config(config_file)
-
-    job_config = config.jobs[job_name]
-
-    job = build_job(job_name, job_config.cls, job_config)
-    job_context = JobContext(job_name)
-    job_context.output_to_console = True
-    job(context=job_context)
-
-
-class RunCommand(CommandBase):
-    def add_arguments(self, parser):
-        parser.add_argument('job')
-        parser.add_argument('--config', '-c')
-
-    def run(self, args):
-        logging.basicConfig(level=logging.INFO)
-        job_name = args.job
-        config_file = args.config
-        run_job(config_file, job_name)