taskcheck 0.1.0.post1__tar.gz → 0.1.2__tar.gz

{taskcheck-0.1.0.post1/taskcheck.egg-info → taskcheck-0.1.2}/PKG-INFO

@@ -1,13 +1,12 @@
 Metadata-Version: 2.1
 Name: taskcheck
-Version: 0.1.0.post1
+Version: 0.1.2
 Summary: Automatic scheduler for taskwarrior
 Requires-Python: >=3.11
 Description-Content-Type: text/markdown
 License-File: LICENSE
 Requires-Dist: appdirs>=1.4.4
 Requires-Dist: icalendar>=6.0.1
-Requires-Dist: requests-cache>=1.2.1
 Requires-Dist: requests>=2.32.3
 
 
@@ -72,6 +71,7 @@ days_ahead = 1000 # how far go with the schedule (lower values make the computat
 [calendars.1]
 url = "https://your/url/to/calendar.ics"
 expiration = 0.08 # in hours (0.08 hours =~ 5 minutes)
+timezone = "Europe/Rome" # if set, force timezone for this calendar; timezone values are TZ identifiers (https://en.wikipedia.org/wiki/List_of_tz_database_time_zones)
 
 [calendars.holidays]
 url = "https://www.officeholidays.com/ics-clean/italy/milan"
@@ -92,16 +92,21 @@ uda.completion_date.type = date
 uda.completion_date.label = Expected Completion Date
 
 # Adjust urgency for taskcheck
-urgency.uda.estimated.coefficient = 1.0   # Increase urgency for tasks with longer estimated durations
-urgency.waiting.coefficient = 0.0 # you will use `wait:` to avoid scheduling tasks too much sooner
+# you will use `wait:` to avoid scheduling tasks too much sooner
+urgency.waiting.coefficient = 0.0
+# you will use `active:` to prioritize tasks already started even if the estimated amount is decreased
+urgency.active.coefficient = 3.0 
+urgency.scheduled.coefficient = 0.0 # tasks that are not scheduled may still be urgent
 
 # we need to be able to modify recurrent tasks without prompt
 recurrence.confirmation=no
 
 # suggested
-urgency.inherit=1
+urgency.inherit=1 # use dependencies to automatically prioritize tasks
 urgency.blocking.coefficient=2
 
+# give urgeny values to the estimated time
+# this is ln(estimation)
 urgency.uda.estimated.PT1H.coefficient = 1
 urgency.uda.estimated.PT2H.coefficient = 2.32
 urgency.uda.estimated.PT3H.coefficient = 3.67
@@ -138,11 +143,15 @@ urgency.uda.estimated.PT33H.coefficient = 11.73
 urgency.uda.estimated.PT34H.coefficient = 11.81
 urgency.uda.estimated.PT35H.coefficient = 11.89
 urgency.uda.estimated.PT36H.coefficient = 11.96
+# maximum duration is 36 hours
+
 ```
 
 ## CLI Options
 
 ```
+
 -v, --verbose: increase output verbosity
 -t, --today: how much time has been already used today (default: 0)
+
 ```

{taskcheck-0.1.0.post1 → taskcheck-0.1.2}/README.md

@@ -60,6 +60,7 @@ days_ahead = 1000 # how far go with the schedule (lower values make the computat
 [calendars.1]
 url = "https://your/url/to/calendar.ics"
 expiration = 0.08 # in hours (0.08 hours =~ 5 minutes)
+timezone = "Europe/Rome" # if set, force timezone for this calendar; timezone values are TZ identifiers (https://en.wikipedia.org/wiki/List_of_tz_database_time_zones)
 
 [calendars.holidays]
 url = "https://www.officeholidays.com/ics-clean/italy/milan"
@@ -80,16 +81,21 @@ uda.completion_date.type = date
 uda.completion_date.label = Expected Completion Date
 
 # Adjust urgency for taskcheck
-urgency.uda.estimated.coefficient = 1.0   # Increase urgency for tasks with longer estimated durations
-urgency.waiting.coefficient = 0.0 # you will use `wait:` to avoid scheduling tasks too much sooner
+# you will use `wait:` to avoid scheduling tasks too much sooner
+urgency.waiting.coefficient = 0.0
+# you will use `active:` to prioritize tasks already started even if the estimated amount is decreased
+urgency.active.coefficient = 3.0 
+urgency.scheduled.coefficient = 0.0 # tasks that are not scheduled may still be urgent
 
 # we need to be able to modify recurrent tasks without prompt
 recurrence.confirmation=no
 
 # suggested
-urgency.inherit=1
+urgency.inherit=1 # use dependencies to automatically prioritize tasks
 urgency.blocking.coefficient=2
 
+# give urgeny values to the estimated time
+# this is ln(estimation)
 urgency.uda.estimated.PT1H.coefficient = 1
 urgency.uda.estimated.PT2H.coefficient = 2.32
 urgency.uda.estimated.PT3H.coefficient = 3.67
@@ -126,11 +132,15 @@ urgency.uda.estimated.PT33H.coefficient = 11.73
 urgency.uda.estimated.PT34H.coefficient = 11.81
 urgency.uda.estimated.PT35H.coefficient = 11.89
 urgency.uda.estimated.PT36H.coefficient = 11.96
+# maximum duration is 36 hours
+
 ```
 
 ## CLI Options
 
 ```
+
 -v, --verbose: increase output verbosity
 -t, --today: how much time has been already used today (default: 0)
+
 ```

{taskcheck-0.1.0.post1 → taskcheck-0.1.2}/pyproject.toml

@@ -1,15 +1,10 @@
 [project]
 name = "taskcheck"
-version = "0.1.0-1"
+version = "0.1.2"
 description = "Automatic scheduler for taskwarrior"
 readme = "README.md"
 requires-python = ">=3.11"
-dependencies = [
-  "appdirs>=1.4.4",
-  "icalendar>=6.0.1",
-  "requests-cache>=1.2.1",
-  "requests>=2.32.3",
-]
+dependencies = ["appdirs>=1.4.4", "icalendar>=6.0.1", "requests>=2.32.3"]
 
 [project.scripts]
 taskcheck = "taskcheck.__main__:main"

{taskcheck-0.1.0.post1 → taskcheck-0.1.2}/taskcheck/__main__.py

@@ -54,11 +54,11 @@ def _hours_to_decimal(hour):
 
 def _hours_to_time(hour):
     hours = int(hour)
-    minutes = int((hour - hours) * 60)
+    minutes = int((hour - hours) * 100)
     return datetime.strptime(f"{hours}:{minutes}", "%H:%M").time()
 
 
-def _time_to_hours(time):
+def _time_to_decimal(time):
     return time.hour + time.minute / 60
 
 
@@ -75,19 +75,37 @@ def get_available_hours(time_map, date, calendars):
         # so let's convert them to datetime.time objects
         schedule_start = _hours_to_time(schedule_start)
         schedule_end = _hours_to_time(schedule_end)
+        schedule_blocked_hours = 0
         for calendar in calendars:
             for event in calendar:
+                # we use str to make object serializable as jsons
+                if isinstance(event["start"], str):
+                    event["start"] = datetime.fromisoformat(event["start"])
+                if isinstance(event["end"], str):
+                    event["end"] = datetime.fromisoformat(event["end"])
+
                 if event["start"].date() > date:
                     break
                 elif event["end"].date() < date:
                     continue
+
                 # check if the event overlaps with one of the working hours
                 event_start = event["start"].time()
                 event_end = event["end"].time()
+                if event["start"].date() < date:
+                    event_start = datetime(date.year, date.month, date.day, 0, 0).time()
+                if event["end"].date() > date:
+                    event_end = datetime(date.year, date.month, date.day, 23, 59).time()
+
                 if event_start < schedule_end and event_end > schedule_start:
-                    blocked_hours += _time_to_hours(
+                    schedule_blocked_hours += _time_to_decimal(
                         min(schedule_end, event_end)
-                    ) - _time_to_hours(max(schedule_start, event_start))
+                    ) - _time_to_decimal(max(schedule_start, event_start))
+        if args.verbose and schedule_blocked_hours > 0:
+            print(
+                f"Blocked hours on {date} between {schedule_start} and {schedule_end}: {schedule_blocked_hours}"
+            )
+        blocked_hours += schedule_blocked_hours
     available_hours -= blocked_hours
     return available_hours
 
@@ -141,7 +159,7 @@ def schedule_task_on_day(
     # we can schedule task on this day
     employable_hours = task_time_map[day_offset] - used_hours[day_offset]
     current_date = today + timedelta(days=day_offset)
-    if wait and current_date < wait:
+    if wait and current_date <= wait:
         if args.verbose:
             print(f"Skipping date {current_date} because of wait date {wait}")
         return start_date, end_date, task_remaining_hours, is_starting
@@ -198,6 +216,7 @@ def get_calendars(config):
             all_day=calendar["event_all_day_is_blocking"],
             expiration=calendar["expiration"],
             verbose=args.verbose,
+            tz_name=calendar.get("timezone"),
         )
         calendar.sort(key=lambda e: e["start"])
         calendars.append(calendar)
@@ -243,10 +262,10 @@ def check_tasks_sequentially(tasks, config):
                         f"Task {task['id']} ('{task['description']}') has no estimated time or time map: {estimated_hours}, {time_map_names}"
                     )
                 continue
-            # if args.verbose:
-            #     print(
-            #         f"Checking task {task['id']} ('{task['description']}') with estimated hours: {estimated_hours} and wait date: {wait_date}"
-            #     )
+            if args.verbose:
+                print(
+                    f"Checking task {task['id']} ('{task['description']}') with estimated hours: {estimated_hours} and wait date: {wait_date}"
+                )
 
             task_remaining_hours = estimated_hours
             task_time_map = get_long_range_time_map(

taskcheck-0.1.2/taskcheck/ical.py

@@ -0,0 +1,153 @@
+import hashlib
+import json
+from icalendar import Calendar
+from datetime import datetime, timedelta
+from dateutil.rrule import rruleset, rrulestr
+import requests
+from pathlib import Path
+import appdirs
+import zoneinfo
+
+import time
+
+CACHE = Path(appdirs.user_cache_dir("taskcheck"))
+
+
+def fetch_ical_data(url):
+    response = requests.get(url)
+    response.raise_for_status()
+    return response.text
+
+
+def parse_ical_events(ical_text, days_ahead, all_day, tz_name=None, verbose=False):
+    cal = Calendar.from_ical(ical_text)
+    today = datetime.now().date()
+    end_date = today + timedelta(days=days_ahead)
+
+    events = []
+    exceptions = set()
+
+    for component in cal.walk():
+        if component.name == "VEVENT":
+            event_start = component.get("dtstart").dt
+            event_end = component.get("dtend").dt
+            recurrence_rule = component.get("rrule")
+            recurrence_id = component.get("recurrence-id")
+
+            # skip all-day events if not requested
+            is_all_day = not hasattr(event_start, "hour") or event_start == event_end
+            if is_all_day:
+                if not all_day:
+                    continue
+                else:
+                    # all-day events should block since 00:00 and end at 23:59:59
+                    event_start = datetime(
+                        event_start.year,
+                        event_start.month,
+                        event_start.day,
+                        0,
+                        0,
+                        0,
+                        0,
+                    )
+                    event_end = event_start + timedelta(days=1) - timedelta(seconds=1)
+            if recurrence_id:
+                if end_date >= recurrence_id.dt.date() >= today:
+                    # this was an occurrence of a recurring event
+                    # but has been moved, let's record the exception that must be removed
+                    exceptions.add(recurrence_id.dt.isoformat())
+
+            occurrences = rruleset()
+            if recurrence_rule:
+                # avoid handling rules that are already ended
+                # and don't create events beyond end_date
+                until = recurrence_rule.get("UNTIL")
+                if until is not None:
+                    until = until[0].date()
+                    if until < today:
+                        continue
+                rrule = rrulestr(
+                    str(recurrence_rule.to_ical(), "utf-8"),
+                    dtstart=event_start,
+                )
+                occurrences.rrule(rrule)  # type: ignore
+                # exceptions to recurring events
+                excdates = component.get("exdate")
+                if excdates is not None:
+                    if isinstance(excdates, list):
+                        # concatenate all the .dts into one list
+                        excdates = [e for exdate in excdates for e in exdate.dts]
+                    else:
+                        excdates = excdates.dts
+                    for excdate in excdates:
+                        if end_date >= excdate.dt.date() >= today:
+                            exceptions.add(excdate.dt.isoformat())
+            else:
+                # if event is not recurring, add it as a single event
+                if event_start.date() >= today and event_end.date() <= end_date:
+                    occurrences.rdate(event_start)
+
+            for occurrence in occurrences:
+                if tz_name is not None:
+                    occurrence = occurrence.astimezone(zoneinfo.ZoneInfo(tz_name))
+                end = occurrence + (event_end - event_start)
+                if occurrence.date() >= today and end.date() <= end_date:
+                    events.append(
+                        {
+                            # "summary": component.get("summary"),
+                            "start": occurrence.isoformat(),
+                            "end": end.isoformat(),
+                        }
+                    )
+                elif end.date() > end_date:
+                    break
+
+    with_exc_len = len(events)
+    events = [event for event in events if event["start"] not in exceptions]
+    if verbose:
+        print(
+            f"Removed {with_exc_len - len(events)} events that are exceptions to recurring events"
+        )
+    events.sort(key=lambda x: x["start"])
+    return events
+
+
+def get_cache_filename(url):
+    hash_object = hashlib.sha256(url.encode())
+    return CACHE / f"{hash_object.hexdigest()}.json"
+
+
+def ical_to_dict(
+    url, days_ahead=7, all_day=False, expiration=0.25, verbose=False, tz_name=None
+):
+    CACHE.mkdir(exist_ok=True, parents=True)
+    cache_file = CACHE / get_cache_filename(url)
+    current_time = time.time()
+
+    # Check if cache file exists and is not expired
+    if cache_file.exists():
+        cache_mtime = cache_file.stat().st_mtime
+        if current_time - cache_mtime < expiration * 3600:
+            with open(cache_file, "r") as f:
+                events = json.load(f)
+            if verbose:
+                print("Loaded events from cache")
+            return events
+
+    # Fetch and parse iCal data
+    ttt = time.time()
+    ical_text = fetch_ical_data(url)
+    if verbose:
+        print("Time taken to fetch ical data: ", time.time() - ttt)
+    ttt = time.time()
+    events = parse_ical_events(
+        ical_text, days_ahead, all_day, tz_name=tz_name, verbose=verbose
+    )
+    if verbose:
+        print("Time taken to parse ical data: ", time.time() - ttt)
+
+    # Save events to cache
+    with open(cache_file, "w") as f:
+        json.dump(events, f)
+
+    return events

{taskcheck-0.1.0.post1 → taskcheck-0.1.2/taskcheck.egg-info}/PKG-INFO

@@ -1,13 +1,12 @@
 Metadata-Version: 2.1
 Name: taskcheck
-Version: 0.1.0.post1
+Version: 0.1.2
 Summary: Automatic scheduler for taskwarrior
 Requires-Python: >=3.11
 Description-Content-Type: text/markdown
 License-File: LICENSE
 Requires-Dist: appdirs>=1.4.4
 Requires-Dist: icalendar>=6.0.1
-Requires-Dist: requests-cache>=1.2.1
 Requires-Dist: requests>=2.32.3
 
 
@@ -72,6 +71,7 @@ days_ahead = 1000 # how far go with the schedule (lower values make the computat
 [calendars.1]
 url = "https://your/url/to/calendar.ics"
 expiration = 0.08 # in hours (0.08 hours =~ 5 minutes)
+timezone = "Europe/Rome" # if set, force timezone for this calendar; timezone values are TZ identifiers (https://en.wikipedia.org/wiki/List_of_tz_database_time_zones)
 
 [calendars.holidays]
 url = "https://www.officeholidays.com/ics-clean/italy/milan"
@@ -92,16 +92,21 @@ uda.completion_date.type = date
 uda.completion_date.label = Expected Completion Date
 
 # Adjust urgency for taskcheck
-urgency.uda.estimated.coefficient = 1.0   # Increase urgency for tasks with longer estimated durations
-urgency.waiting.coefficient = 0.0 # you will use `wait:` to avoid scheduling tasks too much sooner
+# you will use `wait:` to avoid scheduling tasks too much sooner
+urgency.waiting.coefficient = 0.0
+# you will use `active:` to prioritize tasks already started even if the estimated amount is decreased
+urgency.active.coefficient = 3.0 
+urgency.scheduled.coefficient = 0.0 # tasks that are not scheduled may still be urgent
 
 # we need to be able to modify recurrent tasks without prompt
 recurrence.confirmation=no
 
 # suggested
-urgency.inherit=1
+urgency.inherit=1 # use dependencies to automatically prioritize tasks
 urgency.blocking.coefficient=2
 
+# give urgeny values to the estimated time
+# this is ln(estimation)
 urgency.uda.estimated.PT1H.coefficient = 1
 urgency.uda.estimated.PT2H.coefficient = 2.32
 urgency.uda.estimated.PT3H.coefficient = 3.67
@@ -138,11 +143,15 @@ urgency.uda.estimated.PT33H.coefficient = 11.73
 urgency.uda.estimated.PT34H.coefficient = 11.81
 urgency.uda.estimated.PT35H.coefficient = 11.89
 urgency.uda.estimated.PT36H.coefficient = 11.96
+# maximum duration is 36 hours
+
 ```
 
 ## CLI Options
 
 ```
+
 -v, --verbose: increase output verbosity
 -t, --today: how much time has been already used today (default: 0)
+
 ```

{taskcheck-0.1.0.post1 → taskcheck-0.1.2}/taskcheck.egg-info/requires.txt

@@ -1,4 +1,3 @@
 appdirs>=1.4.4
 icalendar>=6.0.1
-requests-cache>=1.2.1
 requests>=2.32.3

taskcheck-0.1.0.post1/taskcheck/ical.py

@@ -1,88 +0,0 @@
-from icalendar import Calendar
-from datetime import datetime, timedelta
-from dateutil.rrule import rruleset, rrulestr
-from requests_cache import CachedSession
-
-import time
-
-
-def fetch_ical_data(url, expiration, verbose):
-    session = CachedSession(
-        "taskcheck",
-        use_cache_dir=True,  # Save files in the default user cache dir
-        cache_control=True,  # Use Cache-Control response headers for expiration, if available
-        urls_expire_after={url: expiration},  # Set expiration time
-        allowable_codes=[
-            200,
-        ],
-        allowable_methods=["GET", "POST"],  # Cache whatever HTTP methods you want
-        stale_if_error=True,  # In case of request errors, use stale cache data if possible
-    )
-    ttt = time.time()
-    response = session.get(url)
-    if verbose:
-        print("Time taken to fetch ical data: ", time.time() - ttt)
-    response.raise_for_status()
-    return response.text
-
-
-def parse_ical_events(ical_text, days_ahead, all_day):
-    cal = Calendar.from_ical(ical_text)
-    today = datetime.now().date()
-    end_date = today + timedelta(days=days_ahead)
-
-    events = []
-
-    for component in cal.walk():
-        if component.name == "VEVENT":
-            event_start = component.get("dtstart").dt
-            event_end = component.get("dtend").dt
-            recurrence_rule = component.get("rrule")
-            recurrence_id = component.get("recurrence-id")
-
-            # skip all-day events if not requested
-            is_all_day = not hasattr(event_start, "hour") or event_start == event_end
-            if is_all_day:
-                if not all_day:
-                    continue
-                else:
-                    # all-day events should block since 00:00 and end at 23:59:59
-                    event_start = datetime(
-                        event_start.year,
-                        event_start.month,
-                        event_start.day,
-                        0,
-                        0,
-                        0,
-                        0,
-                    )
-                    event_end = event_start + timedelta(days=1) - timedelta(seconds=1)
-            if recurrence_id:
-                continue  # Ignore recurrence exceptions here for simplicity
-
-            event_dates = rruleset()
-            if recurrence_rule:
-                rrule = rrulestr(
-                    str(recurrence_rule.to_ical(), "utf-8"), dtstart=event_start
-                )
-                event_dates.rrule(rrule)  # type: ignore
-            else:
-                event_dates.rdate(event_start)
-
-            for event_date in event_dates:
-                if today <= event_date.date() <= end_date:
-                    events.append(
-                        {
-                            "summary": component.get("summary"),
-                            "start": event_date,
-                            "end": event_end,
-                        }
-                    )
-
-    return events
-
-
-def ical_to_dict(url, days_ahead=7, all_day=False, expiration=0.25, verbose=False):
-    ical_text = fetch_ical_data(url, expiration * 3600, verbose)
-    events = parse_ical_events(ical_text, days_ahead, all_day)
-    return events