taskcheck 0.3.1__tar.gz → 0.3.2.post1__tar.gz

{taskcheck-0.3.1/taskcheck.egg-info → taskcheck-0.3.2.post1}/PKG-INFO

@@ -1,12 +1,13 @@
 Metadata-Version: 2.1
 Name: taskcheck
-Version: 0.3.1
+Version: 0.3.2.post1
 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: random-unicode-emoji>=2.8
 Requires-Dist: requests>=2.32.3
 Requires-Dist: rich>=13.9.4
 
@@ -75,29 +76,9 @@ instance:
 - `taskcheck -r today` will show the tasks planned for today
 - `taskcheck -r 1w` will show the tasks planned for the next week,
 
-## Algorithms
+## Algorithm
 
-Taskcheck provides two scheduling algorithms: `parallel` and `sequential`.
-
-#### Sequential
-
-The `sequential` algorithm schedules tasks one after the other. It is the simplest algorithm.
-It looks at your tasks one by one, computes the time slots available for that task, and fills them
-as soon as possible.
-
-While it sounds logical, it has a problem.
-While you're working on a task, its remaining estimated time is decreasing, and if your urgency
-depends on the estimated time left, the urgency of the task will decrease as well.
-This is especially problematic for long tasks: imagine if you block your whole week for a single
-task and all the other small tasks, even if urgent, don't get scheduled. After a few days, the
-urgency of the first long task should have decreased.
-
-#### Parallel
-
-The `parallel` algorithm tries to solve the problem of the `sequential` algorithm.
-
-Instead of allocating all the available time for a task until the task is finished, the `parallel`
-algorithm allocates a fixed amount of time for each task (e.g. 1 hour) and then recomputes the
+The algorithm allocates a fixed amount of time for each task (e.g. 1 hour) and then recomputes the
 urgency and restart the allocation procedure.
 
 If after 1 hour the long task has decreased urgency, that will be noticed and the newer most urgent
@@ -106,8 +87,6 @@ task will get scheduled in its place.
 The minimum time for a task is by default 2 hours, but you can change it by tuning the `min_block`
 taskwarrior UDA.
 
-The `parallel` algorithm is the default algorithm.
-
 ## Configuration
 
 `taskcheck --install` allows you to create required and recommended configurations for
@@ -131,7 +110,6 @@ saturday = [[9, 12.30], ]
 sunday = [[9, 12.30], ]
 
 [scheduler]
-algorithm = "parallel" # or "sequential", see above
 days_ahead = 1000 # how far go with the schedule (lower values make the computation faster)
 
 [calendars]
@@ -145,6 +123,13 @@ timezone = "Europe/Rome" # if set, force timezone for this calendar; timezone va
 url = "https://www.officeholidays.com/ics-clean/italy/milan"
 event_all_day_is_blocking = true
 expiration = 720 # in hours (720 hours = 30 days)
+
+[report]
+additional_attributes = ["estimated", "due", "urgency"] # additional attributes to show in the report
+# when these words are matched in the task description, the corresponding emoji is used
+emoji_keywords = {"meet"=":busts_in_silhouette:", "review"=":mag_right:"}
+include_unplanned = true # include unplanned tasks in the report in an ad-hoc section
+additional_attributes_unplanned = ["due", "urgency"] # additional attributes to show in the report for unplanned tasks
 ```
 
 ## Tips and Tricks

{taskcheck-0.3.1 → taskcheck-0.3.2.post1}/README.md

@@ -63,29 +63,9 @@ instance:
 - `taskcheck -r today` will show the tasks planned for today
 - `taskcheck -r 1w` will show the tasks planned for the next week,
 
-## Algorithms
+## Algorithm
 
-Taskcheck provides two scheduling algorithms: `parallel` and `sequential`.
-
-#### Sequential
-
-The `sequential` algorithm schedules tasks one after the other. It is the simplest algorithm.
-It looks at your tasks one by one, computes the time slots available for that task, and fills them
-as soon as possible.
-
-While it sounds logical, it has a problem.
-While you're working on a task, its remaining estimated time is decreasing, and if your urgency
-depends on the estimated time left, the urgency of the task will decrease as well.
-This is especially problematic for long tasks: imagine if you block your whole week for a single
-task and all the other small tasks, even if urgent, don't get scheduled. After a few days, the
-urgency of the first long task should have decreased.
-
-#### Parallel
-
-The `parallel` algorithm tries to solve the problem of the `sequential` algorithm.
-
-Instead of allocating all the available time for a task until the task is finished, the `parallel`
-algorithm allocates a fixed amount of time for each task (e.g. 1 hour) and then recomputes the
+The algorithm allocates a fixed amount of time for each task (e.g. 1 hour) and then recomputes the
 urgency and restart the allocation procedure.
 
 If after 1 hour the long task has decreased urgency, that will be noticed and the newer most urgent
@@ -94,8 +74,6 @@ task will get scheduled in its place.
 The minimum time for a task is by default 2 hours, but you can change it by tuning the `min_block`
 taskwarrior UDA.
 
-The `parallel` algorithm is the default algorithm.
-
 ## Configuration
 
 `taskcheck --install` allows you to create required and recommended configurations for
@@ -119,7 +97,6 @@ saturday = [[9, 12.30], ]
 sunday = [[9, 12.30], ]
 
 [scheduler]
-algorithm = "parallel" # or "sequential", see above
 days_ahead = 1000 # how far go with the schedule (lower values make the computation faster)
 
 [calendars]
@@ -133,6 +110,13 @@ timezone = "Europe/Rome" # if set, force timezone for this calendar; timezone va
 url = "https://www.officeholidays.com/ics-clean/italy/milan"
 event_all_day_is_blocking = true
 expiration = 720 # in hours (720 hours = 30 days)
+
+[report]
+additional_attributes = ["estimated", "due", "urgency"] # additional attributes to show in the report
+# when these words are matched in the task description, the corresponding emoji is used
+emoji_keywords = {"meet"=":busts_in_silhouette:", "review"=":mag_right:"}
+include_unplanned = true # include unplanned tasks in the report in an ad-hoc section
+additional_attributes_unplanned = ["due", "urgency"] # additional attributes to show in the report for unplanned tasks
 ```
 
 ## Tips and Tricks

{taskcheck-0.3.1 → taskcheck-0.3.2.post1}/pyproject.toml

@@ -1,12 +1,13 @@
 [project]
 name = "taskcheck"
-version = "0.3.1"
+version = "0.3.2-1"
 description = "Automatic scheduler for taskwarrior"
 readme = "README.md"
 requires-python = ">=3.11"
 dependencies = [
   "appdirs>=1.4.4",
   "icalendar>=6.0.1",
+  "random-unicode-emoji>=2.8",
   "requests>=2.32.3",
   "rich>=13.9.4",
 ]

{taskcheck-0.3.1 → taskcheck-0.3.2.post1}/taskcheck/__main__.py

@@ -2,7 +2,6 @@ import tomllib
 import argparse
 
 from taskcheck.parallel import check_tasks_parallel
-from taskcheck.sequential import check_tasks_sequentially
 from taskcheck.common import config_dir
 
 arg_parser = argparse.ArgumentParser()
@@ -48,13 +47,7 @@ def main():
         return
 
     config = load_config()
-    algo = config["scheduler"].get("algorithm", "parallel")
-    if algo == "parallel":
-        check_tasks_parallel(config, verbose=args.verbose)
-    elif algo == "sequential":
-        check_tasks_sequentially(config, verbose=args.verbose)
-    else:
-        raise ValueError(f"Unknown algorithm: {algo}")
+    check_tasks_parallel(config, verbose=args.verbose)
 
 
 if __name__ == "__main__":

{taskcheck-0.3.1 → taskcheck-0.3.2.post1}/taskcheck/install.py

@@ -12,7 +12,6 @@ thursday = [[9, 12.30], [14, 17]]
 friday = [[9, 12.30], [14, 17]]
 
 [scheduler]
-algorithm = "parallel"
 days_ahead = 365
 """
 

{taskcheck-0.3.1 → taskcheck-0.3.2.post1}/taskcheck/parallel.py

@@ -64,9 +64,7 @@ def compute_estimated_urgency(remaining_hours, urgency_coefficients):
         key=lambda x: abs(pdth_to_hours(x) - remaining_hours),
     )
     coefficient = urgency_coefficients.estimated[closest_match]
-    # Compute the urgency
-    estimated_urgency = coefficient * remaining_hours
-    return estimated_urgency
+    return coefficient
 
 
 def check_tasks_parallel(config, verbose=False):
@@ -122,8 +120,8 @@ def initialize_task_info(tasks, time_maps, days_ahead, urgency_coefficients, cal
 
 def allocate_time_for_day(task_info, day_offset, date, urgency_coefficients, verbose):
     total_available_hours = compute_total_available_hours(task_info, day_offset)
-    if verbose:
-        print(f"Day {date}, total available hours: {total_available_hours:.2f}")
+    # if verbose:
+    #     print(f"Day {date}, total available hours: {total_available_hours:.2f}")
     if total_available_hours <= 0:
         return
 
@@ -134,7 +132,7 @@ def allocate_time_for_day(task_info, day_offset, date, urgency_coefficients, ver
         recompute_urgencies(tasks_remaining, urgency_coefficients)
         sorted_task_ids = sorted(
             tasks_remaining.keys(),
-            key=lambda x: (tasks_remaining[x]["urgency"], x),
+            key=lambda x: tasks_remaining[x]["urgency"],
             reverse=True,
         )
 
@@ -146,6 +144,17 @@ def allocate_time_for_day(task_info, day_offset, date, urgency_coefficients, ver
             info = tasks_remaining[uuid]
             if any(d in tasks_remaining for d in info["task"].get("depends", [])):
                 # cannot execute this task until all its dependencies are completed
+                if verbose:
+                    print(
+                        "Skipping task",
+                        info["task"]["id"],
+                        "due to dependency on:",
+                        [
+                            tasks_remaining[_d]["task"]["id"]
+                            for _d in info["task"].get("depends", [])
+                            if _d in tasks_remaining
+                        ],
+                    )
                 continue
             allocation = allocate_time_to_task(info, day_offset, day_remaining_hours)
             if allocation > 0:
@@ -155,7 +164,7 @@ def allocate_time_for_day(task_info, day_offset, date, urgency_coefficients, ver
                 update_task_scheduling(info, allocation, date_str)
                 if verbose:
                     print(
-                        f"Allocated {allocation:.2f} hours to task {info['task']['id']} on {date}"
+                        f"Allocated {allocation:.2f} hours to task {info['task']['id']} on {date} with urgency {info['urgency']:.2f} and estimated-related urgency {info['estimated_urgency']:.2f}"
                     )
                 if (
                     info["remaining_hours"] <= 0
@@ -166,8 +175,8 @@ def allocate_time_for_day(task_info, day_offset, date, urgency_coefficients, ver
                 break
         if not allocated:
             break
-    if verbose and day_remaining_hours > 0:
-        print(f"Unused time on {date}: {day_remaining_hours:.2f} hours")
+    # if verbose and day_remaining_hours > 0:
+    #     print(f"Unused time on {date}: {day_remaining_hours:.2f} hours")
 
 
 def compute_total_available_hours(task_info, day_offset):

{taskcheck-0.3.1 → taskcheck-0.3.2.post1}/taskcheck/report.py

@@ -1,3 +1,4 @@
+import random
 import sys
 from datetime import timedelta
 from datetime import datetime
@@ -12,6 +13,170 @@ from rich.table import Table
 from rich.text import Text
 from rich.panel import Panel
 
+from random_unicode_emoji import random_emoji
+
+
+DEFAULT_EMOJI_KEYWORDS = {
+    "meet": ":busts_in_silhouette:",
+    "incontr": ":busts_in_silhouette:",
+    "rencontr": ":busts_in_silhouette:",
+    "reun": ":busts_in_silhouette:",
+    "treff": ":busts_in_silhouette:",
+    "review": ":mag_right:",
+    "revis": ":mag_right:",
+    "révis": ":mag_right:",
+    "überprüf": ":mag_right:",
+    "write": ":pencil2:",
+    "scriv": ":pencil2:",
+    "écri": ":pencil2:",
+    "escrib": ":pencil2:",
+    "schreib": ":pencil2:",
+    "read": ":books:",
+    "legg": ":books:",
+    "lis": ":books:",
+    "le": ":books:",
+    "les": ":books:",
+    "posta": ":email:",
+    "courri": ":email:",
+    "corre": ":email:",
+    "mail": ":email:",
+    "call": ":telephone_receiver:",
+    "chiam": ":telephone_receiver:",
+    "appel": ":telephone_receiver:",
+    "llam": ":telephone_receiver:",
+    "ruf": ":telephone_receiver:",
+    "présent": ":chart_with_upwards_trend:",
+    "present": ":chart_with_upwards_trend:",
+    "präsent": ":chart_with_upwards_trend:",
+    "learn": ":mortar_board:",
+    "impar": ":mortar_board:",
+    "appren": ":mortar_board:",
+    "aprend": ":mortar_board:",
+    "lern": ":mortar_board:",
+    "search": ":mag:",
+    "cerc": ":mag:",
+    "cherch": ":mag:",
+    "busc": ":mag:",
+    "such": ":mag:",
+    "idea": ":bulb:",
+    "idé": ":bulb:",
+    "ide": ":bulb:",
+    "break": ":coffee:",
+    "paus": ":coffee:",
+    "descans": ":coffee:",
+    "lunch": ":fork_and_knife:",
+    "pranz": ":fork_and_knife:",
+    "déjeun": ":fork_and_knife:",
+    "almorz": ":fork_and_knife:",
+    "mittag": ":fork_and_knife:",
+    "test": ":test_tube:",
+    "develop": ":hammer_and_wrench:",
+    "svilupp": ":hammer_and_wrench:",
+    "développ": ":hammer_and_wrench:",
+    "desarroll": ":hammer_and_wrench:",
+    "entwickl": ":hammer_and_wrench:",
+    "disegn": ":art:",
+    "diseñ": ":art:",
+    "design": ":art:",
+    "dafar": ":memo:",
+    "tarea": ":memo:",
+    "todo": ":memo:",
+    "bug": ":beetle:",
+    "käfer": ":beetle:",
+    "fix": ":wrench:",
+    "corregg": ":wrench:",
+    "répar": ":wrench:",
+    "beheb": ":wrench:",
+    "urgent": ":exclamation:",
+    "dringend": ":exclamation:",
+    "deadlin": ":hourglass_flowing_sand:",
+    "scadenz": ":hourglass_flowing_sand:",
+    "délais": ":hourglass_flowing_sand:",
+    "fechalim": ":hourglass_flowing_sand:",
+    "frist": ":hourglass_flowing_sand:",
+    "updat": ":arrows_counterclockwise:",
+    "aggiorn": ":arrows_counterclockwise:",
+    "mett": ":arrows_counterclockwise:",
+    "actualiz": ":arrows_counterclockwise:",
+    "aktualisier": ":arrows_counterclockwise:",
+    "clean": ":broom:",
+    "pul": ":broom:",
+    "nettoy": ":broom:",
+    "limpi": ":broom:",
+    "reinig": ":broom:",
+    "deploy": ":rocket:",
+    "rilasc": ":rocket:",
+    "déploy": ":rocket:",
+    "despleg": ":rocket:",
+    "bereitstell": ":rocket:",
+    "festegg": ":tada:",
+    "célébr": ":tada:",
+    "celebr": ":tada:",
+    "feier": ":tada:",
+    "research": ":microscope:",
+    "ricerc": ":microscope:",
+    "recherch": ":microscope:",
+    "investig": ":microscope:",
+    "forsch": ":microscope:",
+    "shop": ":shopping_cart:",
+    "achet": ":shopping_cart:",
+    "compr": ":shopping_cart:",
+    "einkauf": ":shopping_cart:",
+    "social": ":handshake:",
+    "sozial": ":handshake:",
+    "exercis": ":running_shoe:",
+    "eserciz": ":running_shoe:",
+    "exercic": ":running_shoe:",
+    "ejerc": ":running_shoe:",
+    "übun": ":running_shoe:",
+    "évènement": ":calendar:",
+    "event": ":calendar:",
+    "movie": ":clapper:",
+    "pelicul": ":clapper:",
+    "film": ":clapper:",
+    "music": ":musical_note:",
+    "musik": ":musical_note:",
+    "travel": ":airplane:",
+    "viagg": ":airplane:",
+    "voyag": ":airplane:",
+    "viaj": ":airplane:",
+    "reis": ":airplane:",
+    "home": ":house:",
+    "mais": ":house:",
+    "cas": ":house:",
+    "haus": ":house:",
+    "docu": ":notebook:",
+    "dokum": ":notebook:",
+    "backup": ":floppy_disk:",
+    "salvat": ":floppy_disk:",
+    "sauveg": ":floppy_disk:",
+    "copiaseg": ":floppy_disk:",
+    "sicher": ":floppy_disk:",
+    "debug": ":bug:",
+    "débug": ":bug:",
+    "note": ":spiral_notepad:",
+    "not": ":spiral_notepad:",
+    "focus": ":dart:",
+    "concentr": ":dart:",
+    "konzentrier": ":dart:",
+    "codic": ":computer:",
+    "cod": ":computer:",
+    "code": ":computer:",
+    "serveur": ":cloud:",
+    "servidor": ":cloud:",
+    "server": ":cloud:",
+    "client": ":briefcase:",
+    "priorid": ":bangbang:",
+    "priorit": ":bangbang:",
+    "star": ":star:",
+    "stell": ":star:",
+    "étoil": ":star:",
+    "estrell": ":star:",
+    "stern": ":star:",
+    "critic": ":fire:",
+    "kritisch": ":fire:",
+}
+
 
 def get_tasks(config, tasks, year, month, day):
     regex = re.compile(rf"{year}-{month}-{day} - ([PDTHM0-9]+)")
@@ -172,7 +337,21 @@ def get_task_emoji(config, task):
     for keyword in config.get("emoji_keywords", []):
         if keyword in task["description"].lower():
             return config["emoji_keywords"][keyword]
-    return ":pushpin:"
+    for keyword, emoji in DEFAULT_EMOJI_KEYWORDS.items():
+        if keyword in task["description"].lower():
+            return emoji
+    # sum the unicode numbers of each letter in the description and use it as seed to get a random unicode
+    # emoji
+    seed = sum(ord(char) for char in task["description"])
+    emoji = ""
+    # seed the next call to random.choice
+    random.seed(seed)
+    emoji = random_emoji()[0]
+    # some emoji coutn for more than one character and misbehave the tables of rich
+    if len(emoji) > 1:
+        while len(emoji) != 1:
+            emoji = random_emoji()[0]
+    return emoji
 
 
 def display_unplanned_tasks(console, config, tasks):
@@ -197,6 +376,8 @@ def build_unplanned_tasks_table(config, tasks):
     table.add_column("Task", style="dim", width=12)
     table.add_column("Project", style="dim", width=12)
     table.add_column("Description")
+    for attr in config.get("additional_attributes_unplanned", []):
+        table.add_column(attr.capitalize(), justify="right")
 
     for task in tasks:
         task_id = f"[bold green]#{task['id']}[/bold green]"
@@ -208,5 +389,9 @@ def build_unplanned_tasks_table(config, tasks):
             f"{emoji} {task_id}",
             project,
             description,
+            *[
+                tostring(task.get(attr, ""))
+                for attr in config.get("additional_attributes_unplanned", [])
+            ],
         )
     return table

{taskcheck-0.3.1 → taskcheck-0.3.2.post1/taskcheck.egg-info}/PKG-INFO

@@ -1,12 +1,13 @@
 Metadata-Version: 2.1
 Name: taskcheck
-Version: 0.3.1
+Version: 0.3.2.post1
 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: random-unicode-emoji>=2.8
 Requires-Dist: requests>=2.32.3
 Requires-Dist: rich>=13.9.4
 
@@ -75,29 +76,9 @@ instance:
 - `taskcheck -r today` will show the tasks planned for today
 - `taskcheck -r 1w` will show the tasks planned for the next week,
 
-## Algorithms
+## Algorithm
 
-Taskcheck provides two scheduling algorithms: `parallel` and `sequential`.
-
-#### Sequential
-
-The `sequential` algorithm schedules tasks one after the other. It is the simplest algorithm.
-It looks at your tasks one by one, computes the time slots available for that task, and fills them
-as soon as possible.
-
-While it sounds logical, it has a problem.
-While you're working on a task, its remaining estimated time is decreasing, and if your urgency
-depends on the estimated time left, the urgency of the task will decrease as well.
-This is especially problematic for long tasks: imagine if you block your whole week for a single
-task and all the other small tasks, even if urgent, don't get scheduled. After a few days, the
-urgency of the first long task should have decreased.
-
-#### Parallel
-
-The `parallel` algorithm tries to solve the problem of the `sequential` algorithm.
-
-Instead of allocating all the available time for a task until the task is finished, the `parallel`
-algorithm allocates a fixed amount of time for each task (e.g. 1 hour) and then recomputes the
+The algorithm allocates a fixed amount of time for each task (e.g. 1 hour) and then recomputes the
 urgency and restart the allocation procedure.
 
 If after 1 hour the long task has decreased urgency, that will be noticed and the newer most urgent
@@ -106,8 +87,6 @@ task will get scheduled in its place.
 The minimum time for a task is by default 2 hours, but you can change it by tuning the `min_block`
 taskwarrior UDA.
 
-The `parallel` algorithm is the default algorithm.
-
 ## Configuration
 
 `taskcheck --install` allows you to create required and recommended configurations for
@@ -131,7 +110,6 @@ saturday = [[9, 12.30], ]
 sunday = [[9, 12.30], ]
 
 [scheduler]
-algorithm = "parallel" # or "sequential", see above
 days_ahead = 1000 # how far go with the schedule (lower values make the computation faster)
 
 [calendars]
@@ -145,6 +123,13 @@ timezone = "Europe/Rome" # if set, force timezone for this calendar; timezone va
 url = "https://www.officeholidays.com/ics-clean/italy/milan"
 event_all_day_is_blocking = true
 expiration = 720 # in hours (720 hours = 30 days)
+
+[report]
+additional_attributes = ["estimated", "due", "urgency"] # additional attributes to show in the report
+# when these words are matched in the task description, the corresponding emoji is used
+emoji_keywords = {"meet"=":busts_in_silhouette:", "review"=":mag_right:"}
+include_unplanned = true # include unplanned tasks in the report in an ad-hoc section
+additional_attributes_unplanned = ["due", "urgency"] # additional attributes to show in the report for unplanned tasks
 ```
 
 ## Tips and Tricks

{taskcheck-0.3.1 → taskcheck-0.3.2.post1}/taskcheck.egg-info/SOURCES.txt

@@ -7,7 +7,6 @@ taskcheck/ical.py
 taskcheck/install.py
 taskcheck/parallel.py
 taskcheck/report.py
-taskcheck/sequential.py
 taskcheck.egg-info/PKG-INFO
 taskcheck.egg-info/SOURCES.txt
 taskcheck.egg-info/dependency_links.txt

{taskcheck-0.3.1 → taskcheck-0.3.2.post1}/taskcheck.egg-info/requires.txt

@@ -1,4 +1,5 @@
 appdirs>=1.4.4
 icalendar>=6.0.1
+random-unicode-emoji>=2.8
 requests>=2.32.3
 rich>=13.9.4

taskcheck-0.3.1/taskcheck/sequential.py

@@ -1,150 +0,0 @@
-from datetime import datetime, timedelta
-from taskcheck.common import (
-    get_calendars,
-    get_long_range_time_map,
-    get_tasks,
-    mark_end_date,
-    pdth_to_hours,
-    hours_to_pdth,
-    AVOID_STATUS,
-)
-
-
-def schedule_task_on_day(
-    is_starting,
-    day_offset,
-    start_date,
-    end_date,
-    task_remaining_hours,
-    task_time_map,
-    today,
-    used_hours,
-    wait,
-    scheduling_note,
-    verbose=False,
-):
-    # we can schedule task on this day
-    employable_hours = task_time_map[day_offset] - used_hours[day_offset]
-    # avoid using too small values
-    employable_hours = 0.01 if 0.01 > employable_hours > 0 else employable_hours
-    current_date = today + timedelta(days=day_offset)
-    if wait and current_date <= wait:
-        if verbose:
-            print(f"Skipping date {current_date} because of wait date {wait}")
-        return start_date, end_date, task_remaining_hours, is_starting, scheduling_note
-
-    if is_starting:
-        if verbose:
-            print(f"Starting task on {current_date}")
-        is_starting = False
-        start_date = current_date
-
-    # minimum value we admit is 0.01 (1 minute)
-    if task_remaining_hours <= employable_hours + 0.01:
-        # consume all the remaining task's hours
-        if scheduling_note != "":
-            scheduling_note += "\n"
-        scheduling_note += f"{current_date} - {hours_to_pdth(task_remaining_hours)}\n"
-        used_hours[day_offset] += task_remaining_hours
-        task_remaining_hours = 0
-        end_date = current_date
-        if verbose:
-            print(f"Task can be completed on {current_date}")
-            print(f"Used hours on {current_date}: {used_hours[day_offset]}")
-    else:
-        # consume all the available hours on this task
-        if scheduling_note != "":
-            scheduling_note += "\n"
-        scheduling_note += f"{current_date} - {hours_to_pdth(employable_hours)}\n"
-        task_remaining_hours -= employable_hours
-        used_hours[day_offset] += employable_hours
-        if verbose:
-            print(f"Working for {employable_hours} hours on task on {current_date}")
-    return start_date, end_date, task_remaining_hours, is_starting, scheduling_note
-
-
-# Check if tasks can be completed on time sequentially
-def check_tasks_sequentially(config, verbose=False):
-    tasks = get_tasks()
-    time_maps = config["time_maps"]
-    today = datetime.today().date()
-    todo = [True if t["status"] not in AVOID_STATUS else False for t in tasks]
-    used_hours = [0] * (config["scheduler"]["days_ahead"] + 1)
-    calendars = get_calendars(config)
-
-    while any(todo):
-        for i, task in enumerate(tasks):
-            if not todo[i]:
-                # skipping tasks already completed
-                continue
-
-            due_date = (
-                datetime.strptime(task["due"], "%Y%m%dT%H%M%SZ").date()
-                if "due" in task
-                else None
-            )
-            wait_date = (
-                datetime.strptime(task["wait"], "%Y%m%dT%H%M%SZ").date()
-                if "wait" in task
-                else None
-            )
-            estimated_hours = (
-                pdth_to_hours(task["estimated"]) if "estimated" in task else None
-            )  # Remove trailing "PT" and "H"
-            time_map_names = (
-                task.get("time_map").split(",") if "time_map" in task else None
-            )
-            if estimated_hours is None or time_map_names is None:
-                todo[i] = False
-                if verbose:
-                    print(
-                        f"Task {task['id']} ('{task['description']}') has no estimated time or time map: {estimated_hours}, {time_map_names}"
-                    )
-                continue
-            if 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, today_used_hours = get_long_range_time_map(
-                time_maps, time_map_names, config["scheduler"]["days_ahead"], calendars
-            )
-            used_hours[0] += today_used_hours
-
-            # Simulate work day-by-day until task is complete or past due
-            is_starting = True
-            scheduling_note = ""
-            start_date = end_date = None
-            for offset in range(len(task_time_map)):
-                if task_time_map[offset] > used_hours[offset]:
-                    (
-                        start_date,
-                        end_date,
-                        task_remaining_hours,
-                        is_starting,
-                        scheduling_note,
-                    ) = schedule_task_on_day(
-                        is_starting,
-                        offset,
-                        start_date,
-                        end_date,
-                        task_remaining_hours,
-                        task_time_map,
-                        today,
-                        used_hours,
-                        wait_date,
-                        scheduling_note,
-                    )
-
-                if end_date is not None:
-                    todo[i] = False
-                    mark_end_date(
-                        due_date,
-                        end_date,
-                        start_date,
-                        scheduling_note,
-                        task["id"],
-                        task["description"],
-                    )
-                    break