schd 0.0.16__py3-none-any.whl → 0.1.1__py3-none-any.whl

schd/__init__.py

@@ -1 +1 @@
-__version__ = '0.0.16'
+__version__ = '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/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/cmds/jobs.py

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

schd/cmds/run.py

@@ -1,26 +1,27 @@
+import asyncio
 import logging
+import sys
 from schd.cmds.base import CommandBase
-from schd.scheduler import build_job, read_config, JobContext
+from schd.scheduler import LocalScheduler, build_job
 
 
-def run_job(config_file, job_name):
-    config = read_config(config_file)
-
+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)
-    job_context = JobContext(job_name)
-    job_context.output_to_console = True
-    job(context=job_context)
+    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')
-        parser.add_argument('--config', '-c')
 
-    def run(self, args):
-        logging.basicConfig(level=logging.INFO)
+    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
-        config_file = args.config
-        run_job(config_file, job_name)
+        asyncio.run(run_job(config, job_name))

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/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/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/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/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.dist-info → schd-0.1.1.dist-info}/METADATA

@@ -1,9 +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.dist-info/RECORD

@@ -0,0 +1,20 @@
+schd/__init__.py,sha256=zGU39ZwaRkNKxWLnAB7Zte9ZtfyfMEsBJp-bHUfQTyA,23
+schd/config.py,sha256=YjwqUFkULjNONDw-Q0QQeNnWQK3XMGHuGSjAHZMGwh8,5981
+schd/email.py,sha256=eBKzNnuQxcJwlWOeXcAMNkGZlUa3O5zM7amfUW7h3gE,2633
+schd/job.py,sha256=AoW-2W1hRY_O4nz_pKukgmEXYkjlP2XmYimyoGCs-Bw,614
+schd/scheduler.py,sha256=IJu_FW5n9U_AXXrjcQAVvJN7bLTI8LoweV1PO_k9WuM,13400
+schd/util.py,sha256=NH4EqIns1Y01yz1Rf3cw-tlKSLc-XNuS9hHbAdq5D_I,592
+schd/cmds/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+schd/cmds/base.py,sha256=lsVIqE1m-uBRRNt7UDYJIIthYR7pyINccfS5hVK3BWA,130
+schd/cmds/daemon.py,sha256=8Ia99abtMatCfYUliDNvlUjRY1-RZPSWUYIuzftLnpI,783
+schd/cmds/jobs.py,sha256=F3ArEeBTOiFpe3gmtkFg6kRtoYCjQGp4kAc3r6UJbtA,459
+schd/cmds/run.py,sha256=woTK4C2h6D5JEYcwXOzS9IHuTVtaTKWMf5jfFhikW2k,888
+schd/cmds/schd.py,sha256=anVfbXXElKRI5Zd8sJYYroBfyqS35RGAtXD5nTEv6ag,1164
+schd/cmds/scsendmail.py,sha256=WIQzzXOFfh8Rwxtzdbn7HH14oG0jUrbxLyA3KL10yM4,3285
+schd/schedulers/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+schd/schedulers/remote.py,sha256=iaQmddf-g095jAIJAGAn0mQKrLRfu9gNZFvE0NkJVy0,8087
+schd-0.1.1.dist-info/METADATA,sha256=XHxYNbTdnNTyBraS-odUpJLGZb2612_vm_rRUigi01E,243
+schd-0.1.1.dist-info/WHEEL,sha256=DnLRTWE75wApRYVsjgc6wsVswC54sMSJhAEd4xhDpBk,91
+schd-0.1.1.dist-info/entry_points.txt,sha256=lY18p1hQAKgv47FBqPj37z8o4Kr1MHnbGlsrNLS4ZKs,84
+schd-0.1.1.dist-info/top_level.txt,sha256=Vojim8xSOsYyQHrZBNhx7n0F7WqbEJ2SeBFAvEnrJ_U,5
+schd-0.1.1.dist-info/RECORD,,

{schd-0.0.16.dist-info → schd-0.1.1.dist-info}/WHEEL

@@ -1,5 +1,5 @@
 Wheel-Version: 1.0
-Generator: setuptools (75.3.2)
+Generator: setuptools (80.4.0)
 Root-Is-Purelib: true
 Tag: py3-none-any
 

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

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

schd-0.0.16.dist-info/RECORD

@@ -1,18 +0,0 @@
-schd/__init__.py,sha256=3kGSHQKV1gPB0rPzBMZNIYjHiZim2MThuzEWpP2YZcg,24
-schd/config.py,sha256=YBSRiXZApC_ylPYUM4cwTU7FjVqMHwG3vPy-F6SA95k,3930
-schd/job.py,sha256=AoW-2W1hRY_O4nz_pKukgmEXYkjlP2XmYimyoGCs-Bw,614
-schd/scheduler.py,sha256=EYIU7aX8qs-RYS_eXJc-JZU3e1T-mTMzkEv51b-AXgM,12931
-schd/util.py,sha256=NH4EqIns1Y01yz1Rf3cw-tlKSLc-XNuS9hHbAdq5D_I,592
-schd/cmds/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-schd/cmds/base.py,sha256=ZnNcJozQFLbpYyNp8dhHzm3BzFQa0hm6KyCC6URfueY,122
-schd/cmds/daemon.py,sha256=MReUf8TDyE-zEUjJ1T1v4RBD8f2edpE7TeGdooaHD6Y,889
-schd/cmds/jobs.py,sha256=DwAuTxZHjqMsG952IpaReTzCjvBII44bZquriFncl1Q,411
-schd/cmds/run.py,sha256=Z-fO-Qk9RS9lBAszmPuuJbVPczIU7AA40Qnd0ngmgsI,752
-schd/cmds/schd.py,sha256=vOlfQCQT81KhLMvlP3tlymEWpxmqlBOa5vnJoeFXVlw,996
-schd/schedulers/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-schd/schedulers/remote.py,sha256=iaQmddf-g095jAIJAGAn0mQKrLRfu9gNZFvE0NkJVy0,8087
-schd-0.0.16.dist-info/METADATA,sha256=OUyzeY7EMMeUkGCW74DmnhYwJjrl_bBJbJCM6xOa6GI,195
-schd-0.0.16.dist-info/WHEEL,sha256=iAkIy5fosb7FzIOwONchHf19Qu7_1wCWyFNR5gu9nU0,91
-schd-0.0.16.dist-info/entry_points.txt,sha256=VvUhIaucvHlggoz-4lWtQgXbDwoWH9x-iT0QOUHEMyI,45
-schd-0.0.16.dist-info/top_level.txt,sha256=Vojim8xSOsYyQHrZBNhx7n0F7WqbEJ2SeBFAvEnrJ_U,5
-schd-0.0.16.dist-info/RECORD,,