clockwork 0.2.0__tar.gz → 0.2.2__tar.gz

{clockwork-0.2.0 → clockwork-0.2.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: clockwork
-Version: 0.2.0
+Version: 0.2.2
 Summary: Toolkit for time-related operations including scheduling, logging, date manipulation, and more.
 Home-page: https://github.com/zteinck/clockwork
 License: MIT
@@ -15,8 +15,8 @@ Classifier: Programming Language :: Python :: 3.10
 Classifier: Programming Language :: Python :: 3.11
 Classifier: Programming Language :: Python :: 3.12
 Requires-Dist: holidays
-Requires-Dist: iterlab
 Requires-Dist: numpy
+Requires-Dist: oddments
 Requires-Dist: pandas
 Requires-Dist: pathpilot
 Requires-Dist: schedule

clockwork-0.2.2/clockwork/__init__.py

@@ -0,0 +1,4 @@
+from .core import *
+
+__version__ = '0.2.2'
+__author__ = 'Zachary Einck <zacharyeinck@gmail.com>'

{clockwork-0.2.0 → clockwork-0.2.2}/clockwork/_base.py

@@ -7,7 +7,6 @@ import pandas as pd
 import numpy as np
 
 
-
 class DateBase(object):
     '''
     Description
@@ -71,7 +70,8 @@ class DateBase(object):
         Description
         ----------
         Returns the # of days in a month for a given year.
-        For example, if year=2024 and month=2, 29 days is returned since it's a leap year
+        For example, if year=2024 and month=2, 29 days is returned since
+        it's a leap year.
 
         Parameters
         ----------
@@ -172,15 +172,18 @@ class DateBase(object):
 
             def wrapper(self, weekday, delta=0):
                 '''
-                returns DateBase object representing the next or last day of the week relative to self. For example self.next('Mon')
+                returns DateBase object representing the next or last day of
+                the week relative to self. For example self.next('Mon')
                 would return the date of the following monday.
 
                 Attributes
                 -----------------------
                 weekday : str
-                    Day of the week either fully spelled out or the first three characters (e.g. 'Friday' or 'Fri') not case-sensitive.
+                    Day of the week either fully spelled out or the first three
+                    characters (e.g. 'Friday' or 'Fri') not case-sensitive.
                 delta : int
-                    Offset value +/- from the current week (e.g. 0 is the current week and -1 is last week).
+                    Offset value +/- from the current week (e.g. 0 is the current
+                    week and -1 is last week).
                 '''
                 day, desired_day = self.dt.weekday(), self.weekdays[weekday.title()]
                 delta += func(self, day - desired_day)
@@ -198,104 +201,132 @@ class DateBase(object):
         ''' returns normalized instance '''
         return self.normalize()
 
+
     @property
     def d(self):
         ''' converts datetime.datetime to datetime.date '''
         return self.datetime.date()
 
+
     @property
     def dt(self):
         ''' datetime alias '''
         return self.datetime
 
+
     @property
     def pandas(self):
         ''' pandas format '''
         return pd.to_datetime(self.dt)
 
+
     @property
     def ymd(self):
         ''' string in YYYY-MM-DD format '''
         return self.str('%Y-%m-%d')
 
+
     @property
     def sql_server(self):
         ''' ymd alias '''
         return self.ymd
 
+
     @property
     def oracle(self):
         ''' string in DD-%b-YY (e.g. 30-Sep-19) format '''
         return self.str('%d-%b-%y')
 
+
     @property
     def timestamp(self):
         ''' integer '''
         return self.to_timestamp(self.dt)
 
+
     @property
     def year(self):
         return self.dt.year
 
+
     @property
     def month(self):
         return self.dt.month
 
+
     @property
     def month_name(self):
         return self.dt.strftime('%B')
 
+
     @property
     def day(self):
         return self.dt.day
 
+
     @property
     def yesterday(self):
         return self - 1
 
+
     @property
     def tomorrow(self):
         return self + 1
 
+
     @property
     def month_start(self):
         ''' return date object representing the first day of the month '''
         return self.spawn(datetime.datetime(self.year, self.month, 1))
 
+
     @property
     def month_end(self):
         ''' last day of the month as a MonthEnd instance '''
         return self.last_day_of_month(self.year, self.month)
 
+
+    @property
+    def is_month_end(self):
+        ''' returns True if date aligns with a month-end date '''
+        return self.ymd == self.month_end.ymd
+
+
     @property
     def last_business_day_of_month(self):
         dt = self.month_end
         dt -= {'Saturday': 1, 'Sunday': 2}.get(dt.weekday, 0)
         return dt
 
+
     @property
     def weekday(self):
         return self.str('%A')
 
+
     @property
     def weekday_short(self):
         return self.str('%a')
 
+
     @property
     def is_weekend(self):
         ''' returns True if date does not fall on a weekend '''
         return self.weekday in ('Saturday','Sunday')
 
+
     @property
     def is_holiday(self):
         ''' returns True if date is a U.S. holiday '''
         return self.ymd in self.holidays
 
+
     @property
     def is_business_day(self):
         ''' returns True if date does not fall on a weekend '''
         return not (self.is_weekend or self.is_holiday)
 
+
     @property
     def is_business_hours(self):
         ''' returns True if date is within business hours (8am - 9pm) '''
@@ -303,11 +334,13 @@ class DateBase(object):
         out = self.is_business_day and self.dt >= set_hour(8) and self.dt <= set_hour(21)
         return out
 
+
     @property
     def is_today(self):
         ''' returns True if date is the current day '''
         return self.ymd == self.spawn().ymd
 
+
     @property
     def holiday(self):
         ''' returns the current holiday, if applicable '''
@@ -321,51 +354,62 @@ class DateBase(object):
     def __repr__(self):
         return str(self)
 
+
     def __str__(self):
         components = ['%Y-%m-%d']
         if self.dt.hour + self.dt.second + self.dt.microsecond > 0:
             components.append('%I:%M:%S.%f %p')
         return self.__class__.__name__ + '(%s)' % self.str(' '.join(components))
 
+
     def __int__(self):
         return self.timestamp
 
+
     @Decorators.other_to_dt
     def __eq__(self, other):
         return self.dt == other
 
+
     @Decorators.other_to_dt
     def __ne__(self, other):
         return self.dt != other
 
+
     @Decorators.other_to_dt
     def __lt__(self, other):
         return self.dt < other
 
+
     @Decorators.other_to_dt
     def __gt__(self, other):
         return self.dt > other
 
+
     @Decorators.other_to_dt
     def __le__(self, other):
         return self.dt <= other
 
+
     @Decorators.other_to_dt
     def __ge__(self, other):
         return self.dt >= other
 
+
     @Decorators.arithmetic_other
     def __add__(self, other):
-        ''' if other is date-like then implements default behavior for adding datetimes otherwise
-        other is treated as timedelta '''
+        ''' if other is date-like then implements default behavior for adding
+            datetimes otherwise other is treated as timedelta '''
         return self.dt + other
 
+
     @Decorators.arithmetic_other
     def __sub__(self, other):
-        ''' if other is date-like then implements default behavior for subtracting datetimes otherwise
-        other is treated as timedelta '''
+        ''' if other is date-like then implements default behavior for subtracting
+            datetimes otherwise other is treated as timedelta '''
         return self.dt - other
 
+
     @Decorators.other_to_dt
     def __contains__(self, item):
         return self.normalize(item).dt <= self.dt < (self.normalize(item) + 1).dt
@@ -447,5 +491,6 @@ class DateBase(object):
 
     @Decorators.spawn
     def normalize(self):
-        ''' the time component (hours, minutes, seconds, microseconds) is set to zero (midnight) '''
+        ''' the time component (hours, minutes, seconds, microseconds) is set to
+            zero (midnight) '''
         return datetime.datetime(self.year, self.month, self.day)

{clockwork-0.2.0 → clockwork-0.2.2}/clockwork/_month_end.py

@@ -1,7 +1,6 @@
 from ._base import DateBase
 
 
-
 class MonthEnd(DateBase):
 
     #╭-------------------------------------------------------------------------╮
@@ -9,7 +8,8 @@ class MonthEnd(DateBase):
     #╰-------------------------------------------------------------------------╯
 
     def __init__(self, dt):
-        super().__init__(dt.replace(day=self.n_days_in_month(dt.year, dt.month)))
+        day = self.n_days_in_month(dt.year, dt.month)
+        super().__init__(dt.replace(day=day))
 
 
     #╭-------------------------------------------------------------------------╮
@@ -20,21 +20,35 @@ class MonthEnd(DateBase):
     def long(self):
         return self.str('%Y-%m-%d')
 
+
     @property
     def compact(self):
         return self.str('%Y-%m')
 
+
     @property
     def short(self):
         return self.str('%b')
 
+
+    @property
+    def is_year_end(self):
+        return self.month == 12
+
+
+    @property
+    def is_quarter_end(self):
+        return self.month in {3, 6, 9, 12}
+
+
     @property
     def last_quarter_end(self):
         ''' returns most recent quarter end '''
         delta = 0
         while True:
-            obj = self.offset(delta=delta)
-            if hasattr(obj, 'quarter'): return obj
+            me = self.offset(delta=delta)
+            if me.is_quarter_end:
+                return me.to_quarter_end()
             delta -= 1
 
 
@@ -42,6 +56,17 @@ class MonthEnd(DateBase):
     #| Instance Methods                                                        |
     #╰-------------------------------------------------------------------------╯
 
+    def to_quarter_end(self):
+        from ._quarter_end import QuarterEnd
+        if self.is_quarter_end:
+            return QuarterEnd(self.dt)
+        else:
+            raise ValueError(
+                "Month-end date does not align with a quarter-end "
+                f"date: '{self.ymd}'"
+                )
+
+
     def offset(self, delta):
         ''' returns the month end 'delta' months away from the instance '''
         if not isinstance(delta, int):

{clockwork-0.2.0 → clockwork-0.2.2}/clockwork/_quarter_end.py

@@ -1,16 +1,20 @@
 from ._month_end import MonthEnd
 
 
-
 class QuarterEnd(MonthEnd):
 
+    #╭-------------------------------------------------------------------------╮
+    #| Class Attributes                                                        |
+    #╰-------------------------------------------------------------------------╯
+    scheme = (3, 6, 9, 12)
+
+
     #╭-------------------------------------------------------------------------╮
     #| Initialize Instance                                                     |
     #╰-------------------------------------------------------------------------╯
 
-    def __init__(self, dt, qtr, *args, **kwargs):
+    def __init__(self, dt):
         super().__init__(dt)
-        self.qtr = qtr
 
 
     #╭-------------------------------------------------------------------------╮
@@ -21,17 +25,26 @@ class QuarterEnd(MonthEnd):
     def long(self):
         return f'{self.year}Q{self.qtr}'
 
+
     @property
     def compact(self):
         return f'{self.qtr}Q' + self.str('%y')
 
+
     @property
     def short(self):
         return f'Q{self.qtr}'
 
+
     @property
     def quarter(self):
-        return self.qtr
+        return int(self.scheme.index(self.month) + 1)
+
+
+    @property
+    def qtr(self):
+        ''' quarter alias '''
+        return self.quarter
 
 
     #╭-------------------------------------------------------------------------╮
@@ -49,4 +62,4 @@ class QuarterEnd(MonthEnd):
         if delta == 0: return self
         dt = self.shift(months=delta * 3).dt
         qtr = ((self.qtr - 1 + delta) % 4) + 1
-        return self.__class__(dt, qtr)
+        return self.__class__(dt)

{clockwork-0.2.0 → clockwork-0.2.2}/clockwork/core.py

@@ -7,11 +7,6 @@ from ._quarter_end import QuarterEnd
 from ._month_end import MonthEnd
 
 
-
-#╭-------------------------------------------------------------------------╮
-#| Functions                                                               |
-#╰-------------------------------------------------------------------------╯
-
 def Date(arg=None, normalize=False, format=None, week_offset=0):
     '''
     Description
@@ -21,26 +16,31 @@ def Date(arg=None, normalize=False, format=None, week_offset=0):
     Parameters
     ------------
     arg : str | object
-        object to convert to DateBase object. Currently supported formats include:
+        object to convert to DateBase object. Currently supported formats
+        include:
             • None (the current date and time will be used)
             • pandas._libs.tslibs.timestamps.Timestamp
             • datetime.datetime
             • datetime.date
             • integer or float (in seconds)
             • string
-                ► day of the week fully spelled out or first 3 letters (not case sensitive)
-                  (e.g. 'Monday', 'monday', 'mon')
+                ► day of the week fully spelled out or first 3 letters
+                  (not case sensitive) (e.g. 'Monday', 'monday', 'mon')
                 ► quarter in #QYY, YYYYQ#, or Q# format
                 ► any string format supported by pd.to_datetime
             • DateBase object or DateBase polymorphism
     normalize : bool
-        if True, only the year, month, and day are retained (hours, minutes, seconds, microseconds are set to zero)
+        if True, only the year, month, and day are retained (hours, minutes,
+                 seconds, microseconds are set to zero)
     format : str
-        if 'arg' is a string, this format is used to parse it (e.g. '%Y%m%d %H%S').
+        if 'arg' is a string, this format is used to parse it
+        (e.g. '%Y%m%d %H%S').
     week_offset : int
-        by default, if a day of the week is supplied (e.g. 'Monday') then the date returned will be that day of the week
-        for the current week. This argument is used to override this behavior by shifting the week backwards or forwards
-        (e.g. if arg='Monday' and week_offset=-1 then the Monday of last week will be returned).
+        by default, if a day of the week is supplied (e.g. 'Monday') then
+        the date returned will be that day of the week for the current week.
+        This argument is used to override this behavior by shifting the week
+        backwards or forwards (e.g. if arg='Monday' and week_offset=-1 then
+        the Monday of last week will be returned).
 
     Returns
     ------------
@@ -48,7 +48,8 @@ def Date(arg=None, normalize=False, format=None, week_offset=0):
         DateBase object or polymorphism
     '''
 
-    qtr_map = {k: i for i,k in enumerate([(3,31), (6,30), (9,30), (12,31)], 1)}
+    qtr_scheme = [(3, 31), (6, 30), (9, 30), (12, 31)]
+    qtr_map = {k: i for i, k in enumerate(qtr_scheme, 1)}
 
     def qtr_label_to_dt(x):
         ''' attempts to convert quarter expressed as string to datetime.
@@ -74,7 +75,10 @@ def Date(arg=None, normalize=False, format=None, week_offset=0):
 
     if format is not None:
         if not isinstance(arg, str):
-            raise TypeError(f"When 'format' argument is not None, 'arg' must be a string, not {type(arg)}.")
+            raise TypeError(
+                "When 'format' argument is not None, 'arg' must be a "
+                f"string, not {type(arg).__name__}."
+                )
         arg = DateBase.to_datetime(arg, format=format)
         return Date(arg, normalize=normalize)
 
@@ -102,22 +106,21 @@ def Date(arg=None, normalize=False, format=None, week_offset=0):
     else:
         raise ValueError(f'date argument {arg} of type {type(arg)} is not supported.')
 
-    if normalize: dt = datetime.datetime(dt.year, dt.month, dt.day)
+    if normalize:
+        dt = datetime.datetime(dt.year, dt.month, dt.day)
 
     if dt.day == DateBase.n_days_in_month(dt.year, dt.month):
         qtr = qtr_map.get((dt.month, dt.day))
-        return QuarterEnd(dt, qtr) if qtr else MonthEnd(dt)
+        return QuarterEnd(dt) if qtr else MonthEnd(dt)
     else:
         return DateBase(dt)
 
 
-
 def day_of_week(day, delta=0):
     ''' see DateBase.first_last decorator for documentation '''
     return Date(normalize=True).last(day, delta)
 
 
-
 def month_end(delta=0):
     '''
     Description
@@ -127,21 +130,29 @@ def month_end(delta=0):
     Parameters
     ------------
     delta : int | str | DateBase
-        Offset value +/- from the most recent month end (e.g. 0 is the most recent month end and -1 is the 2nd most recent month end).
+        Offset value +/- from the most recent month end (e.g. 0 is the most
+        recent month end and -1 is the 2nd most recent month end).
 
     Returns
     ------------
     clockwork.MonthEnd object
     '''
-    if isinstance(delta, (DateBase, str)): return Date(delta)
-    y, m = divmod(datetime.date.today().year * 12 + datetime.date.today().month + delta - 1, 12)
+    if isinstance(delta, (DateBase, str)):
+        out = Date(delta)
+        if not isinstance(out, MonthEnd):
+            raise ValueError(
+                f"delta '{delta}' did not yield a month-end object: {out}"
+                )
+        return out
+
+    today = datetime.date.today()
+    y, m = divmod(today.year * 12 + today.month + delta - 1, 12)
     if m == 0:
         y -= 1
         m = 12
     return MonthEnd(datetime.datetime(y, m, 1))
 
 
-
 def quarter_end(delta=0, scheme=None):
     '''
     Description
@@ -151,10 +162,11 @@ def quarter_end(delta=0, scheme=None):
     Parameters
     ------------
     delta : int | str | DateBase
-        clockwork.date() -> 'date' argument.
-        Integer values are treated as offsets +/- from the most recent quarter end (e.g. 0 is the most recent quarter
-        end and -1 is the 2nd most recent quarter end).
-        String values represent specific quarters. Acceptable formats include: '#QYY' or 'YYYYQ#'
+        Integer values are treated as offsets (+/-) from the most recent quarter
+        end (e.g. 0 is the most recent quarter end and -1 is the 2nd most recent
+        quarter end).
+        String values represent specific quarters. Acceptable formats include:
+        '#QYY' or 'YYYYQ#'
     scheme : tuple
         Tuple listing the quarter end months. Defaults to calendar year-end.
 
@@ -162,18 +174,29 @@ def quarter_end(delta=0, scheme=None):
     ------------
     clockwork.QuarterEnd object
     '''
-    if isinstance(delta, (DateBase, str)): return Date(delta)
-    if scheme is not None: raise NotImplementedError
-    scheme = (3, 6, 9, 12)
+    if scheme is not None:
+        raise NotImplementedError(
+            'Only default quarter-end months are currently supported'
+            )
+
+    if isinstance(delta, (DateBase, str)):
+        out = Date(delta)
+        if not isinstance(out, QuarterEnd):
+            raise ValueError(
+                f"delta '{delta}' did not yield a quarter-end object: {out}"
+                )
+        return out
+
+    scheme = QuarterEnd.scheme
     today = datetime.datetime.now()
     cy, cm, cd = today.year, today.month, today.day
     if cd <= DateBase.n_days_in_month(cy, cm): cm -= 1
     candidates = [((cy * 12) + m) + (delta * 3) - 1 for m in scheme]
-    candidates.insert(0,((cy - 1) * 12) + scheme[-1] + (delta * 3) - 1)
-    y, m = divmod(candidates[np.digitize(((cy * 12) + cm + (delta * 3)), candidates, right=True) - 1], 12)
+    candidates.insert(0, ((cy - 1) * 12) + scheme[-1] + (delta * 3) - 1)
+    index = np.digitize(((cy * 12) + cm + (delta * 3)), candidates, right=True) - 1
+    y, m = divmod(candidates[index], 12)
     m += 1
-    return QuarterEnd(dt=datetime.datetime(y, m, 1), qtr=scheme.index(m) + 1)
-
+    return QuarterEnd(datetime.datetime(y, m, 1))
 
 
 def year_end(delta=0, **kwargs):
@@ -183,7 +206,6 @@ def year_end(delta=0, **kwargs):
     return quarter_end(delta, **kwargs)
 
 
-
 #╭-------------------------------------------------------------------------╮
 #| Assign Class Attribute                                                  |
 #╰-------------------------------------------------------------------------╯

clockwork-0.2.2/clockwork/decorators.py

@@ -0,0 +1,18 @@
+import time
+
+from .utils import elapsed_time, add_border
+
+
+def action_timer(func):
+
+    def wrapper(*args, **kwargs):
+        start_time = time.time()
+        print(add_border(func.__name__, width=75))
+        print()
+        out = func(*args, **kwargs)
+        et = elapsed_time(time.time() - start_time)
+        print(add_border(f'{func.__name__} complete in {et}', width=75))
+        print()
+        return out
+
+    return wrapper

clockwork-0.2.2/clockwork/taskmaster/_scheduler.py

@@ -0,0 +1,27 @@
+import datetime
+from schedule import Scheduler, CancelJob
+
+from .utils import ContinueFailedJob
+
+
+class TaskScheduler(Scheduler):
+
+    #╭-------------------------------------------------------------------------╮
+    #| Initialize Instance                                                     |
+    #╰-------------------------------------------------------------------------╯
+
+    def __init__(self, *args, **kwargs):
+        super().__init__(*args, **kwargs)
+
+
+    #╭-------------------------------------------------------------------------╮
+    #| Instance Methods                                                        |
+    #╰-------------------------------------------------------------------------╯
+
+    def _run_job(self, job):
+        ret = job.run()
+        if ret is CancelJob:
+            self.cancel_job(job)
+        elif ret is ContinueFailedJob:
+            job.last_run = datetime.datetime.now()
+            job._schedule_next_run()

{clockwork-0.2.0 → clockwork-0.2.2}/clockwork/taskmaster/_task.py

@@ -8,13 +8,12 @@ from ..utils import elapsed_time
 from .utils import PrerequisiteError, ContinueFailedJob
 
 
-
 class Task(object):
     '''
     Description
     --------------------
-    job object designed to be used in conjunction with TaskScheduler as the 'job' argument
-    in self._run_job()
+    job object designed to be used in conjunction with TaskScheduler as the
+    'job' argument in self._run_job()
 
     Class Attributes
     --------------------
@@ -23,7 +22,8 @@ class Task(object):
     verbose : bool
         If True, class content is printed to console.
     disable_print : bool
-        If True, printing is suppressed while func runs. Must be True if verbose is True.
+        If True, printing is suppressed while func runs. Must be True if verbose
+        is True.
     cascade_status : str
         cascade status
 
@@ -34,7 +34,8 @@ class Task(object):
     at : str
         at time string
     expiry : Date
-        If not None, job will be set inactive and stop running after this datetime
+        If not None, job will be set inactive and stop running after this
+        datetime
     func : func
         function to run
     args : tuple
@@ -44,24 +45,30 @@ class Task(object):
     cancel_on_failure : bool
         If True, the job will be cancelled if it raises an exception.
     cancel_on_completion : bool
-        If True, the job will be cancelled if it completed successfully (i.e. job will run only once).
+        If True, the job will be cancelled if it completed successfully
+        (i.e. job will run only once).
     notify_on_failure : bool
-        If True, an email notification is sent to my inbox that includes the traceback. cancel_on_failure
-        and cascade are automatically set to True if this argument is True (prevents endless spam).
+        If True, an email notification is sent to my inbox that includes the
+        traceback. cancel_on_failure and cascade are automatically set to True
+        if this argument is True (prevents endless spam).
     restrict_to_business_hours : bool
-        If True, the job will only execute during business hours. This is a more restrictive version of restrict_to_business_days.
+        If True, the job will only execute during business hours. This is a more
+        restrictive version of restrict_to_business_days.
     restrict_to_business_days : bool
         If True, the job will only execute during weekdays (i.e. not weekends).
     cascade : bool
-        If True, when the job (denoted by the 'name' argument) is reflected multiple times in the jobs table
-        due to having multiple 'at' values, changes in activiation in one will cascade to all others. For example,
-        consider the job named 'my job' which is scheduled at 8:00 AM and 5:00 PM that is cancelled on completion.
-        If the 8:00 AM completes successfully then the job with that 'at' time will be set to inactive and have its
-        status updated in the table accordingly. Under default behavior, the 5:00 PM run will be unaffected by the
-        completion of the 8:00 AM run, however, if cascade is set to True then the 5:00 PM run will also receive
-        the same updates.
+        If True, when the job (denoted by the 'name' argument) is reflected
+        multiple times in the jobs table due to having multiple 'at' values,
+        changes in activiation in one will cascade to all others. For example,
+        consider the job named 'my job' which is scheduled at 8:00 AM and 5:00
+        PM that is cancelled on completion. If the 8:00 AM completes successfully
+        then the job with that 'at' time will be set to inactive and have its status
+        updated in the table accordingly. Under default behavior, the 5:00 PM run
+        will be unaffected by the completion of the 8:00 AM run, however, if cascade
+        is set to True then the 5:00 PM run will also receive the same updates.
     attempts : int
-        If greater than 1, the job will be attempted this number of times before being cancelled.
+        If greater than 1, the job will be attempted this number of times before
+        being cancelled.
     status : str | None
         current status of the job
     '''
@@ -165,7 +172,8 @@ class Task(object):
                 print(f' @ {Date()} ->', end=' ')
                 print('Job Cancelled')
 
-        # cancel job if it was cancelled on cascasde or if it was set inactive after being scheduled
+        # cancel job if it was cancelled on cascasde or
+        # if it was set inactive after being scheduled
         if self.status == self.cascade_status or \
            not self.master.is_active(self.name, self.at):
             return CancelJob

{clockwork-0.2.0 → clockwork-0.2.2}/clockwork/taskmaster/file_monitor.py

@@ -1,14 +1,14 @@
 from .utils import PrerequisiteError
 
 
-
 class FileMonitor(object):
     '''
     Description
     --------------------
-    Monitors a folder for new files and passes latest and 2nd latest file names to
-    user-defined function. Class is intended to be used in conjunction with TaskMaster
-    as a func argument which allows for file monitoring at regular intervals.
+    Monitors a folder for new files and passes latest and 2nd latest file
+    names to user-defined function. Class is intended to be used in
+    conjunction with TaskMaster as a func argument which allows for file
+    monitoring at regular intervals.
 
     Class Attributes
     --------------------
@@ -17,8 +17,8 @@ class FileMonitor(object):
     Instance Attributes
     --------------------
     func : func
-        Custom function that takes the latest and second-latest file names in a folder as
-        the first and second arguments, respectively.
+        Custom function that takes the latest and second-latest file names
+        in a folder as the first and second arguments, respectively.
     folder : Folder object
         folder to monitor for new files.
     filter_kwargs : dict

{clockwork-0.2.0 → clockwork-0.2.2}/clockwork/taskmaster/logger.py

@@ -8,14 +8,17 @@ from pathpilot import Folder
 #╰-------------------------------------------------------------------------╯
 
 class CustomLogFormatter(logging.Formatter):
-    ''' the default implementation of logging.Formatter does not allow timestamps to be formatted how I want '''
+    ''' the default implementation of logging.Formatter does not allow
+        timestamps to be formatted how I want '''
 
     converter = datetime.datetime.fromtimestamp
 
     def formatTime(self, record, datefmt=None):
-        if datefmt is not None: raise TypeError('datefmt argument must be None')
-        return self.converter(record.created).strftime('%Y-%m-%d %I:%M:%S.{} %p').format('%03d' % record.msecs)
-
+        if datefmt is not None:
+            raise TypeError('datefmt argument must be None')
+        return self.converter(record.created)\
+                   .strftime('%Y-%m-%d %I:%M:%S.{} %p')\
+                   .format('%03d' % record.msecs)
 
 
 class Logger(object):
@@ -55,7 +58,9 @@ class Logger(object):
         #formatter = CustomLogFormatter(fmt='%(asctime)s %(name)s %(levelname)s %(message)s')
 
         # create file handler which logs even debug messages
-        self.file = Folder().parent.join('Data', 'Logger', read_only=False).join(f'{name}.log').path
+        self.file = Folder().parent\
+            .join('Data', 'Logger', read_only=False)\
+            .join(f'{name}.log').path
         if clear: self.clear()
         fh = logging.FileHandler(self.file)
         fh.setLevel(logging.DEBUG)
@@ -92,7 +97,6 @@ class Logger(object):
         open(self.file, 'w').close()
 
 
-
 #╭-------------------------------------------------------------------------╮
 #| Functions                                                               |
 #╰-------------------------------------------------------------------------╯

{clockwork-0.2.0 → clockwork-0.2.2}/clockwork/taskmaster/taskmaster.py

@@ -1,7 +1,7 @@
 import datetime
 import time
 import uuid
-from iterlab import to_iter
+from oddments import to_iter
 from pathpilot import Folder
 
 from ..core import Date
@@ -9,7 +9,6 @@ from ._scheduler import TaskScheduler
 from ._task import Task
 
 
-
 #╭-------------------------------------------------------------------------╮
 #| Classes                                                                 |
 #╰-------------------------------------------------------------------------╯
@@ -18,8 +17,8 @@ class TaskMaster(object):
     '''
     Description
     --------------------
-    Class provides a user-friendly means of using the TaskScheduler implementation of
-    schedule.Scheduler to schedule SmartJobs
+    Class provides a user-friendly means of using the TaskScheduler
+    implementation of schedule.Scheduler to schedule SmartJobs
 
     Class Attributes
     --------------------
@@ -75,9 +74,11 @@ class TaskMaster(object):
             Task.at
         active : binary
             If 1, the job is active and able to be scheduled.
-            If 0, the job is inactive and unable to be scheduled. This value is obtained via one of the following avenues
+            If 0, the job is inactive and unable to be scheduled. This value is
+                  obtained via one of the following avenues
                 1) job completed succesfully and was cancelled
-                2) job obained this status via cascade from a job that satisfied criteria in 1)
+                2) job obained this status via cascade from a job that satisfied
+                   criteria in 1)
                 3) job was manually set inactive via TaskMaster.set_inactive method
         expiry : str
             Task.expiry
@@ -105,7 +106,16 @@ class TaskMaster(object):
 
 
     @classmethod
-    def add(cls, func, every=None, at=None, interval=1, start=None, expiry=None, **kwargs):
+    def add(
+        cls,
+        func,
+        every=None,
+        at=None,
+        interval=1,
+        start=None,
+        expiry=None,
+        **kwargs
+        ):
         '''
         Description
         ------------
@@ -124,20 +134,23 @@ class TaskMaster(object):
         func : func
             Task func argument
         every : str
-            string representation of schedule.Job property (e.g. 'minutes', 'hour', 'day' etc.).
-            If None and cancel_on_completion kwarg is True, every and interval will be set to
-            'second' and 1, respectively, so that the job will run ASAP once the 'start' criteria
-            has been met (if applicable).
+            string representation of schedule.Job property (e.g. 'minutes',
+            'hour', 'day' etc.).
+            If None and cancel_on_completion kwarg is True, every and interval
+            will be set to 'second' and 1, respectively, so that the job will
+            run ASAP once the 'start' criteria has been met (if applicable).
         at : str | iter
-            time_str argument passed to schedule.Job.at(time_str). Times may be passed in
-            '%I:%M%p' format (e.g ['06:15 AM', '12:15 PM', '06:15 PM']). If argument is an
-            iterable then the job will be scheduled at each constituent time.
+            time_str argument passed to schedule.Job.at(time_str). Times may be
+            passed in '%I:%M%p' format (e.g ['06:15 AM', '12:15 PM', '06:15 PM']).
+            If argument is an iterable then the job will be scheduled at each
+            constituent time.
         interval : int
             schedule.Scheduler.every interval argument
         start : Date
             If not None, job will be not be added until this datetime
         expiry : Date
-            If not None, job will be set inactive and stop running after this datetime
+            If not None, job will be set inactive and stop running after this
+            datetime
         kwargs : keyword arguments
             keyword arguments passed to Task.__init__
 
@@ -147,7 +160,8 @@ class TaskMaster(object):
         '''
 
         if not hasattr(cls, 'db'):
-            cls.db = Folder().parent.join('Data', 'SQLite', read_only=False).join('taskmaster.sqlite')
+            cls.db = Folder().parent.join('Data', 'SQLite', read_only=False)\
+                                    .join('taskmaster.sqlite')
             cls.db.connect()
             cls.db.enable_foreign_keys()
 
@@ -215,7 +229,6 @@ class TaskMaster(object):
         return True
 
 
-
 #╭-------------------------------------------------------------------------╮
 #| Assign Class Attribute                                                  |
 #╰-------------------------------------------------------------------------╯

{clockwork-0.2.0 → clockwork-0.2.2}/clockwork/utils.py

@@ -1,16 +1,10 @@
 import re
-import time
 from textwrap import wrap as wrap_text
 
 
-
-#╭-------------------------------------------------------------------------╮
-#| Functions                                                               |
-#╰-------------------------------------------------------------------------╯
-
 def elapsed_time(seconds):
     out = []
-    for k,v in [('days', 86400), ('hours', 3600), ('minutes', 60)]:
+    for k, v in [('days', 86400), ('hours', 3600), ('minutes', 60)]:
         count = int(seconds / v)
         if count > 0:
             out.append(f'{count} {k}')
@@ -19,20 +13,6 @@ def elapsed_time(seconds):
     return ', '.join(out)
 
 
-def action_timer(func):
-
-    def wrapper(*args, **kwargs):
-        start_time = time.time()
-        print(add_border(func.__name__, width=75))
-        print()
-        out = func(*args, **kwargs)
-        print(add_border(f'{func.__name__} complete in {elapsed_time(time.time() - start_time)}', width=75))
-        print()
-        return out
-
-    return wrapper
-
-
 def month_year_iter(start_month, start_year, end_month=None, end_year=None, rng=None, step=0):
 
     start = 12 * start_year + start_month - 1

{clockwork-0.2.0 → clockwork-0.2.2}/pyproject.toml

@@ -1,6 +1,6 @@
 [tool.poetry]
 name = "clockwork"
-version = "0.2.0"
+version = "0.2.2"
 description = "Toolkit for time-related operations including scheduling, logging, date manipulation, and more."
 authors = ["Zachary Einck <zacharyeinck@gmail.com>"]
 license = "MIT"
@@ -12,7 +12,7 @@ homepage = "https://github.com/zteinck/clockwork"
 python = "^3.8"
 pandas = "*"
 numpy = "*"
-iterlab = "*"
+oddments = "*"
 pathpilot = "*"
 schedule = "*"
 holidays = "*"

clockwork-0.2.0/clockwork/__init__.py

@@ -1,4 +0,0 @@
-from .core import *
-
-__version__ = '0.2.0'
-__author__ = 'Zachary Einck <zacharyeinck@gmail.com>'

clockwork-0.2.0/clockwork/taskmaster/_scheduler.py

@@ -1,20 +0,0 @@
-import datetime
-from schedule import Scheduler, CancelJob
-
-from .utils import ContinueFailedJob
-
-
-
-class TaskScheduler(Scheduler):
-
-    def __init__(self):
-        super().__init__()
-
-
-    def _run_job(self, job):
-        ret = job.run()
-        if ret is CancelJob:
-            self.cancel_job(job)
-        elif ret is ContinueFailedJob:
-            job.last_run = datetime.datetime.now()
-            job._schedule_next_run()