schd 0.0.9__py3-none-any.whl → 0.0.11__py3-none-any.whl

schd/__init__.py

@@ -1 +1 @@
-__version__ = '0.0.9'
+__version__ = '0.0.11'

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/config.py

@@ -0,0 +1,99 @@
+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)
+
+
+@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/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/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,100 @@ 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, cron_expression: str, job_name: str) -> 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_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)
+        scheduler = RemoteScheduler(worker_name=config.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 +297,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_cron, job_name=job_name)
         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 +329,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/schedulers/remote.py

@@ -0,0 +1,150 @@
+import asyncio
+from contextlib import redirect_stdout
+import io
+import json
+import os
+from typing import Dict
+from urllib.parse import urljoin
+import aiohttp
+import aiohttp.client_exceptions
+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):
+        url = urljoin(self._base_url, f'/api/workers/{worker_name}/jobs/{job_name}')
+        post_data = {
+            'cron': cron,
+        }
+        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,Job]" = {}
+        self._loop_task = None
+        self._loop = asyncio.get_event_loop()
+
+    async def init(self):
+        await self.client.register_worker(self._worker_name)
+
+    async def add_job(self, job:Job, cron, job_name):
+        await self.client.register_job(self._worker_name, job_name=job_name, cron=cron)
+        self._jobs[job_name] = job
+
+    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)
+                    await self.execute_task(event['data']['job_name'], event['data']['id'])
+            except aiohttp.client_exceptions.ClientPayloadError:
+                logger.info('connection lost')
+            except aiohttp.client_exceptions.SocketTimeoutError:
+                logger.info('SocketTimeoutError')
+            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)

schd/util.py

@@ -1,10 +1,17 @@
-import distutils
+from typing import Union
 
-def ensure_bool(s):
-    if s is None:
-        return s
-    
+def ensure_bool(s: Union[bool, int, float, str]) -> bool:
     if isinstance(s, bool):
         return s
-    
-    return bool(distutils.util.strtobool(s))
+    if isinstance(s, (int, float)):
+        return bool(s)
+    if isinstance(s, str):
+        truthy_values = {"true", "1", "yes", "on"}
+        falsy_values = {"false", "0", "no", "off"}
+        lower_s = s.strip().lower()
+        if lower_s in truthy_values:
+            return True
+        if lower_s in falsy_values:
+            return False
+        raise ValueError(f"Cannot convert string '{s}' to bool")
+    raise TypeError(f"Unsupported type: {type(s)}")

schd-0.0.11.dist-info/METADATA

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

schd-0.0.11.dist-info/RECORD

@@ -0,0 +1,18 @@
+schd/__init__.py,sha256=PJtUBAnQMxYDTqpslqeXmCybtsqQwT54QhX5X07AO50,24
+schd/config.py,sha256=21KpKPOwa7sAu4m2YS7kd644M2Lxnx2HuU_Czqs-R48,3873
+schd/job.py,sha256=AoW-2W1hRY_O4nz_pKukgmEXYkjlP2XmYimyoGCs-Bw,614
+schd/scheduler.py,sha256=YtfF8YRdSNjQvxOig7aCjh9EaRWzjmP34ThPeccfbs0,12706
+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=843M6rcMjqmm8yevHF4QsJxc0fw8LQfSX7OEA_OH0Dg,590
+schd/cmds/run.py,sha256=T7WeTMf6-crmC8fD6YoMsp0nQbKemNTf4_Q9a-b789w,853
+schd/cmds/schd.py,sha256=vOlfQCQT81KhLMvlP3tlymEWpxmqlBOa5vnJoeFXVlw,996
+schd/schedulers/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+schd/schedulers/remote.py,sha256=m9UiHE8TziBzzOGHwdCOnOraOiy-78bFAQJ-m21fOtg,6567
+schd-0.0.11.dist-info/METADATA,sha256=DQsIwXYzT_MKtlkgf7qZ6cfeWF1biMcZRMdFbmOcb-w,195
+schd-0.0.11.dist-info/WHEEL,sha256=iAkIy5fosb7FzIOwONchHf19Qu7_1wCWyFNR5gu9nU0,91
+schd-0.0.11.dist-info/entry_points.txt,sha256=VvUhIaucvHlggoz-4lWtQgXbDwoWH9x-iT0QOUHEMyI,45
+schd-0.0.11.dist-info/top_level.txt,sha256=Vojim8xSOsYyQHrZBNhx7n0F7WqbEJ2SeBFAvEnrJ_U,5
+schd-0.0.11.dist-info/RECORD,,

{schd-0.0.9.dist-info → schd-0.0.11.dist-info}/WHEEL

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

{schd-0.0.9.dist-info → schd-0.0.11.dist-info}/entry_points.txt

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

schd-0.0.9.dist-info/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.9.dist-info/METADATA

@@ -1,15 +0,0 @@
-Metadata-Version: 2.1
-Name: schd
-Version: 0.0.9
-Summary: UNKNOWN
-Home-page: https://github.com/kevenli/schd
-Author: UNKNOWN
-Author-email: UNKNOWN
-License: UNKNOWN
-Platform: UNKNOWN
-Requires-Dist: apscheduler (<4.0)
-Requires-Dist: pyaml
-
-UNKNOWN
-
-

schd-0.0.9.dist-info/RECORD

@@ -1,15 +0,0 @@
-schd/__init__.py,sha256=4ukFAowTgOAqlpFDjOAtStXzhYme45DBxYlRkSUyE7c,23
-schd/scheduler.py,sha256=Y1JKEB5VAZ9ziaR9Z9_QNkAVhBlMIkwrb4vRZhOF7QA,8555
-schd/util.py,sha256=r8gfrosXmyHX30El0L_OUZzYjLKFStUiigz27xZ065I,173
-schd/cmds/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-schd/cmds/base.py,sha256=ZnNcJozQFLbpYyNp8dhHzm3BzFQa0hm6KyCC6URfueY,122
-schd/cmds/daemon.py,sha256=xeQlG6zG0Z_6IrY1Aod4Zm7F0CNkfVaGWX8GBGVSv4c,860
-schd/cmds/jobs.py,sha256=843M6rcMjqmm8yevHF4QsJxc0fw8LQfSX7OEA_OH0Dg,590
-schd/cmds/run.py,sha256=T7WeTMf6-crmC8fD6YoMsp0nQbKemNTf4_Q9a-b789w,853
-schd/cmds/schd.py,sha256=vOlfQCQT81KhLMvlP3tlymEWpxmqlBOa5vnJoeFXVlw,996
-schd-0.0.9.dist-info/LICENSE,sha256=xx0jnfkXJvxRnG63LTGOxlggYnIysveWIZ6H3PNdCrQ,11357
-schd-0.0.9.dist-info/METADATA,sha256=-aNNCfnoeHUBVTe9fcsUf3ROKy2sYUMO4eOV41JnUVc,262
-schd-0.0.9.dist-info/WHEEL,sha256=2wepM1nk4DS4eFpYrW1TTqPcoGNfHhhO_i5m4cOimbo,92
-schd-0.0.9.dist-info/entry_points.txt,sha256=iVyQSrYOYw0BclgHg9SUeNg9hDg_jeDuUxhvKIcKeSY,46
-schd-0.0.9.dist-info/top_level.txt,sha256=Vojim8xSOsYyQHrZBNhx7n0F7WqbEJ2SeBFAvEnrJ_U,5
-schd-0.0.9.dist-info/RECORD,,