taskcheck 0.2.0__tar.gz → 0.3.0__tar.gz

{taskcheck-0.2.0/taskcheck.egg-info → taskcheck-0.3.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: taskcheck
-Version: 0.2.0
+Version: 0.3.0
 Summary: Automatic scheduler for taskwarrior
 Requires-Python: >=3.11
 Description-Content-Type: text/markdown
@@ -8,6 +8,7 @@ License-File: LICENSE
 Requires-Dist: appdirs>=1.4.4
 Requires-Dist: icalendar>=6.0.1
 Requires-Dist: requests>=2.32.3
+Requires-Dist: rich>=13.9.4
 
 
 > _A non-AI automatic scheduler for taskwarrior (i.e. alternative to skedpal/timehero/flowsavvy/reclaim/trevor/motion)_
@@ -19,7 +20,8 @@ This is a taskwarrior extension checks if tasks can be completed on time, consid
 - [x] Use arbitrarily complex time maps
 - [x] Use ical to block time from scheduling (e.g. for meetings, vacations, etc.)
 - [x] Implement scheduling algorithm for parallely working on multiple tasks
-- [ ] Use Google/Microsoft/Apple API to access calendars
+- [ ] Use Google API to access calendars
+- [ ] Export tasks to iCal calendar and API calendars
 
 ## Install
 
@@ -31,29 +33,45 @@ This is a taskwarrior extension checks if tasks can be completed on time, consid
 This extension parses your pending and waiting tasks sorted decreasingly by urgency and tries to schedule them in the future.
 It considers their estimated time to schedule all tasks starting from the most urgent one.
 
-You will need to add the `estimated` and `time_map` UDAs to your tasks. The `estimated` attribute is
+#### UDAs
+
+Taskcheck leverages to UDAs, `estimated` and `time_map`. The `estimated` attribute is
 the expected time to complete the task in hours. The `time_map` is a comma-separated list of strings
 that indicates the hours per day in which you will work on a task (e.g. `work`, `weekend`, etc.).
 The exact correspondence between the `time_map` and the hours of the day is defined in the configuration
-file of taskcheck.
+file of taskcheck. For instance:
+
+```toml
+[time_maps]
+# get an error)
+[time_maps.work]
+monday = [[9, 12.30], [14, 17]]
+tuesday = [[9, 12.30], [14, 17]]
+# ...
+```
+
+#### They say it's an "AI"
 
-`taskcheck` will modify the Taskwarrior tasks by adding the `completion_date` attribute with the expected
+Taskcheck will also parse online iCal calendars (Google, Apple, etc.) and will match them with your time maps.
+It will then modify the Taskwarrior tasks by adding the `completion_date` attribute with the expected
 date of completion and the `scheduled` attribute with the date in which the task is expected to
 start.
 
 It will also print a red line for every task whose `completion_date` is after its `due_date`.
 
-You can exclude a task from being scheduled by removing the `time_map` or `estimated` attributes.
+In general, it is recommended to run taskcheck rather frequently and at least once at the beginning
+of your working day.
 
-You can see tasks that you can execute now with the `task ready` report.
+#### Reports
 
-You can see the schedule for a task in the `scheduling` UDA, e.g. `task scheduling:$(task calc
-tomorrow)` will show you the tasks that include a scheduling for tomorrow.
+You can also print simple reports that exploit the `scheduling` UDA filled by Taskcheck to grasp
+how much time you have to work on which task in which day. For
+instance:
 
-In general, it is recommended to run taskcheck rather frequently and at least once at the beginning
-of your working day.
+- `taskcheck -r today` will show the tasks planned for today
+- `taskcheck -r 1w` will show the tasks planned for the next week,
 
-### Algorithms
+## Algorithms
 
 Taskcheck provides two scheduling algorithms: `parallel` and `sequential`.
 
@@ -125,9 +143,15 @@ event_all_day_is_blocking = true
 expiration = 720 # in hours (720 hours = 30 days)
 ```
 
+## Tips and Tricks
+
+- You can exclude a task from being scheduled by removing the `time_map` or `estimated` attributes.
+- You can see tasks that you can execute now with the `task ready` report.
+
 ## CLI Options
 
 ```
 -v, --verbose: increase output verbosity
 -i, --install: install taskcheck configuration
+-r, --report: show tasks planned until a certain time
 ```

{taskcheck-0.2.0 → taskcheck-0.3.0}/README.md

@@ -8,7 +8,8 @@ This is a taskwarrior extension checks if tasks can be completed on time, consid
 - [x] Use arbitrarily complex time maps
 - [x] Use ical to block time from scheduling (e.g. for meetings, vacations, etc.)
 - [x] Implement scheduling algorithm for parallely working on multiple tasks
-- [ ] Use Google/Microsoft/Apple API to access calendars
+- [ ] Use Google API to access calendars
+- [ ] Export tasks to iCal calendar and API calendars
 
 ## Install
 
@@ -20,29 +21,45 @@ This is a taskwarrior extension checks if tasks can be completed on time, consid
 This extension parses your pending and waiting tasks sorted decreasingly by urgency and tries to schedule them in the future.
 It considers their estimated time to schedule all tasks starting from the most urgent one.
 
-You will need to add the `estimated` and `time_map` UDAs to your tasks. The `estimated` attribute is
+#### UDAs
+
+Taskcheck leverages to UDAs, `estimated` and `time_map`. The `estimated` attribute is
 the expected time to complete the task in hours. The `time_map` is a comma-separated list of strings
 that indicates the hours per day in which you will work on a task (e.g. `work`, `weekend`, etc.).
 The exact correspondence between the `time_map` and the hours of the day is defined in the configuration
-file of taskcheck.
+file of taskcheck. For instance:
+
+```toml
+[time_maps]
+# get an error)
+[time_maps.work]
+monday = [[9, 12.30], [14, 17]]
+tuesday = [[9, 12.30], [14, 17]]
+# ...
+```
+
+#### They say it's an "AI"
 
-`taskcheck` will modify the Taskwarrior tasks by adding the `completion_date` attribute with the expected
+Taskcheck will also parse online iCal calendars (Google, Apple, etc.) and will match them with your time maps.
+It will then modify the Taskwarrior tasks by adding the `completion_date` attribute with the expected
 date of completion and the `scheduled` attribute with the date in which the task is expected to
 start.
 
 It will also print a red line for every task whose `completion_date` is after its `due_date`.
 
-You can exclude a task from being scheduled by removing the `time_map` or `estimated` attributes.
+In general, it is recommended to run taskcheck rather frequently and at least once at the beginning
+of your working day.
 
-You can see tasks that you can execute now with the `task ready` report.
+#### Reports
 
-You can see the schedule for a task in the `scheduling` UDA, e.g. `task scheduling:$(task calc
-tomorrow)` will show you the tasks that include a scheduling for tomorrow.
+You can also print simple reports that exploit the `scheduling` UDA filled by Taskcheck to grasp
+how much time you have to work on which task in which day. For
+instance:
 
-In general, it is recommended to run taskcheck rather frequently and at least once at the beginning
-of your working day.
+- `taskcheck -r today` will show the tasks planned for today
+- `taskcheck -r 1w` will show the tasks planned for the next week,
 
-### Algorithms
+## Algorithms
 
 Taskcheck provides two scheduling algorithms: `parallel` and `sequential`.
 
@@ -114,9 +131,15 @@ event_all_day_is_blocking = true
 expiration = 720 # in hours (720 hours = 30 days)
 ```
 
+## Tips and Tricks
+
+- You can exclude a task from being scheduled by removing the `time_map` or `estimated` attributes.
+- You can see tasks that you can execute now with the `task ready` report.
+
 ## CLI Options
 
 ```
 -v, --verbose: increase output verbosity
 -i, --install: install taskcheck configuration
+-r, --report: show tasks planned until a certain time
 ```

{taskcheck-0.2.0 → taskcheck-0.3.0}/pyproject.toml

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

{taskcheck-0.2.0 → taskcheck-0.3.0}/taskcheck/__main__.py

@@ -7,13 +7,19 @@ from taskcheck.common import config_dir
 
 arg_parser = argparse.ArgumentParser()
 arg_parser.add_argument(
-    "-v", "--verbose", action="store_true", help="increase output verbosity"
+    "-v", "--verbose", action="store_true", help="increase output verbosity."
 )
 arg_parser.add_argument(
     "-i",
     "--install",
     action="store_true",
-    help="install the UDAs, required settings, and default config file",
+    help="install the UDAs, required settings, and default config file.",
+)
+arg_parser.add_argument(
+    "-r",
+    "--report",
+    action="store",
+    help="generate a report of the tasks based on the scheduling; can be any Taskwarrior datetime specification (e.g. today, tomorrow, eom, som, 1st, 2nd, etc.). It is considered as `by`, meaning that the report will be generated for all the days until the specified date and including it.",
 )
 
 args = arg_parser.parse_args()
@@ -34,6 +40,13 @@ def main():
         install()
         return
 
+    if args.report:
+        from taskcheck.report import generate_report
+
+        config = load_config()
+        generate_report(config, args.report, args.verbose)
+        return
+
     config = load_config()
     algo = config["scheduler"].get("algorithm", "parallel")
     if algo == "parallel":

{taskcheck-0.2.0 → taskcheck-0.3.0}/taskcheck/common.py

@@ -91,19 +91,36 @@ def pdth_to_hours(duration_str):
     # string format is P#DT#H
     # with D and H optional
     duration_str = duration_str[1:]  # Remove leading "P"
-    days, hours = 0, 0
+    days, hours, minutes = 0, 0, 0
     if "D" in duration_str:
         days, duration_str = duration_str.split("D")
         days = int(days)
     if "H" in duration_str:
         hours = int(duration_str.split("T")[1].split("H")[0])
-    return days * 24 + hours
+    if "M" in duration_str:
+        minutes = int(duration_str.split("H")[1].split("M")[0])
+    return days * 24 + hours + minutes / 60
 
 
 def hours_to_pdth(hours):
-    days = hours // 24
-    hours = hours % 24
-    return f"P{days}DT{hours}H"
+    days_ = hours / 24
+    hours_ = hours % 24
+    minutes_ = int(round((hours_ - int(hours_)) * 60))
+    days_ = int(days_)
+    hours_ = int(hours_)
+    minutes_ = int(minutes_)
+    ret = "P"
+    if days_ == 0:
+        ret += "T"
+    else:
+        ret += f"{days_}DT"
+    if hours_ > 0:
+        ret += f"{hours_}H"
+    if minutes_ > 0:
+        ret += f"{minutes_}M"
+    if ret == "PT":
+        print("Warning: hours_to_pdth() returned 'PT' for hours = ", hours)
+    return ret
 
 
 def get_long_range_time_map(

{taskcheck-0.2.0 → taskcheck-0.3.0}/taskcheck/install.py

@@ -88,26 +88,35 @@ def install():
         ),
         ("journal.info", "0"),
         ("urgency.inherit", "1"),
+        ("urgency.blocked.coefficient", "0"),
+        ("urgency.blocking.coefficient", "0"),
+        ("urgency.waiting.coefficient", "0"),
+        ("urgency.scheduled.coefficient", "0"),
     ]
 
     answer = input(
-        """Required configuration for taskcheck includes:
+        """
+_________________________________________________________________________________________
+Required configuration for taskcheck includes:
 - 3 UDA fields 
 - turning off confirmation for recurring tasks 
 
-Do you want to continue? [y/N]"""
+Do you want to continue? [y/N] """
     )
     if answer.lower() not in ["y", "yes"]:
         return
 
     answer = input(
-        """Optional configuration for taskcheck includes:
+        """
+_________________________________________________________________________________________
+Optional configuration for taskcheck includes:
 - urgency coefficients for estimated time (up to 36 hour duration)
 - better `ready` report columns
 - turning off printing journal logs in the task details
-- turning on urgency inheritance from dependant tasks 
+- turning on urgency inheritance from dependant tasks and disabling blocked and blocking urgency coefficients (as recommended by Taskwarrior documentation)
+- turning off urgency for waiting and scheduled tasks (taskcheck already take them into account)
 
-Do you want to apply optional configurations? [y/N]"""
+Do you want to apply optional configurations? [y/N] """
     )
     if answer.lower() not in ["y", "yes"]:
         configs = required_configs
@@ -123,7 +132,9 @@ Do you want to apply optional configurations? [y/N]"""
         print(f"Failed to apply configurations: {e}")
 
     answer = input(
-        """Do you want to create a default config file for taskcheck? [y/N]"""
+        """
+_________________________________________________________________________________________
+Do you want to create a default config file for taskcheck? [y/N] """
     )
     if answer.lower() not in ["y", "yes"]:
         return

{taskcheck-0.2.0 → taskcheck-0.3.0}/taskcheck/parallel.py

@@ -1,5 +1,6 @@
 import subprocess
 import re
+from dataclasses import dataclass
 
 from datetime import datetime, timedelta
 from taskcheck.common import (
@@ -13,6 +14,13 @@ from taskcheck.common import (
 )
 
 
+@dataclass
+class UrgencyCoefficients:
+    estimated: dict
+    inherit: bool
+    active: float
+
+
 def get_urgency_coefficients():
     """
     Retrieves urgency coefficients from Taskwarrior configurations.
@@ -21,34 +29,40 @@ def get_urgency_coefficients():
     """
     result = subprocess.run(["task", "_show"], capture_output=True, text=True)
     inherit_urgency = False
+    active_task_coefficient = 0
     coefficients = {}
     pattern1 = re.compile(r"^urgency\.uda\.estimated\.(.+)\.coefficient=(.+)$")
     pattern2 = re.compile(r"^urgency\.inherit=(.+)$")
+    pattern3 = re.compile(r"^urgency\.active.coefficient=(.+)$")
     for line in result.stdout.splitlines():
         match = pattern1.match(line)
         if match:
             estimated_value = match.group(1)
             coefficient = float(match.group(2))
             coefficients[estimated_value] = coefficient
+
         match = pattern2.match(line)
         if match:
             inherit_urgency = match.group(1) == "1"
 
-    return coefficients, inherit_urgency
+        match = pattern3.match(line)
+        if match:
+            active_coefficient = float(match.group(1))
+            active_task_coefficient = active_coefficient
+
+    return UrgencyCoefficients(coefficients, inherit_urgency, active_task_coefficient)
 
 
-def compute_estimated_urgency(remaining_hours, coefficients):
+def compute_estimated_urgency(remaining_hours, urgency_coefficients):
     """
     Computes the estimated urgency for the given remaining hours using the coefficients.
     """
-    # Convert remaining hours to PDTH format used in the coefficients
-    pdth_value = hours_to_pdth(remaining_hours)
     # Find the closest match (e.g., if '2h' is not available, use '1h' or '3h')
     closest_match = min(
-        coefficients.keys(),
-        key=lambda x: abs(int(pdth_value[1]) - int(pdth_to_hours(x[1]))),
+        urgency_coefficients.estimated.keys(),
+        key=lambda x: abs(pdth_to_hours(x) - remaining_hours),
     )
-    coefficient = coefficients[closest_match]
+    coefficient = urgency_coefficients.estimated[closest_match]
     # Compute the urgency
     estimated_urgency = coefficient * remaining_hours
     return estimated_urgency
@@ -60,7 +74,7 @@ def check_tasks_parallel(config, verbose=False):
     days_ahead = config["scheduler"]["days_ahead"]
     calendars = get_calendars(config)
     today = datetime.today().date()
-    urgency_coefficients, inherit_urgency = get_urgency_coefficients()
+    urgency_coefficients = get_urgency_coefficients()
 
     task_info = initialize_task_info(
         tasks, time_maps, days_ahead, urgency_coefficients, calendars
@@ -69,7 +83,7 @@ def check_tasks_parallel(config, verbose=False):
     for day_offset in range(days_ahead):
         date = today + timedelta(days=day_offset)
         allocate_time_for_day(
-            task_info, day_offset, date, urgency_coefficients, inherit_urgency, verbose
+            task_info, day_offset, date, urgency_coefficients, verbose
         )
 
     update_tasks_with_scheduling_info(task_info, verbose)
@@ -100,13 +114,12 @@ def initialize_task_info(tasks, time_maps, days_ahead, urgency_coefficients, cal
             "scheduling": {},
             "urgency": initial_urgency,
             "estimated_urgency": estimated_urgency,
+            "started": False,
         }
     return task_info
 
 
-def allocate_time_for_day(
-    task_info, day_offset, date, urgency_coefficients, inherit_urgency, verbose
-):
+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}")
@@ -117,7 +130,7 @@ def allocate_time_for_day(
     tasks_remaining = prepare_tasks_remaining(task_info, day_offset)
 
     while day_remaining_hours > 0 and tasks_remaining:
-        recompute_urgencies(tasks_remaining, urgency_coefficients, inherit_urgency)
+        recompute_urgencies(tasks_remaining, urgency_coefficients)
         sorted_task_ids = sorted(
             tasks_remaining.keys(),
             key=lambda x: (tasks_remaining[x]["urgency"], x),
@@ -125,10 +138,14 @@ def allocate_time_for_day(
         )
 
         allocated = False
-        for id in sorted_task_ids:
-            if id not in tasks_remaining:
+        for uuid in sorted_task_ids:
+            if uuid not in tasks_remaining:
+                # already completed
+                continue
+            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
                 continue
-            info = tasks_remaining[id]
             allocation = allocate_time_to_task(info, day_offset, day_remaining_hours)
             if allocation > 0:
                 day_remaining_hours -= allocation
@@ -143,7 +160,7 @@ def allocate_time_for_day(
                     info["remaining_hours"] <= 0
                     or info["task_time_map"][day_offset] <= 0
                 ):
-                    del tasks_remaining[id]
+                    del tasks_remaining[uuid]
                 # if day_remaining_hours <= 0:
                 break
         if not allocated:
@@ -168,13 +185,13 @@ def compute_total_available_hours(task_info, day_offset):
 
 def prepare_tasks_remaining(task_info, day_offset):
     return {
-        info["task"]["id"]: info
+        info["task"]["uuid"]: info
         for info in task_info.values()
         if info["remaining_hours"] > 0 and info["task_time_map"][day_offset] > 0
     }
 
 
-def recompute_urgencies(tasks_remaining, urgency_coefficients, inherit_urgency):
+def recompute_urgencies(tasks_remaining, urgency_coefficients):
     # Recompute estimated urgencies as before
     for info in tasks_remaining.values():
         remaining_hours = info["remaining_hours"]
@@ -184,23 +201,28 @@ def recompute_urgencies(tasks_remaining, urgency_coefficients, inherit_urgency):
         _old_estimated_urgency = info["estimated_urgency"]
         info["estimated_urgency"] = estimated_urgency
         info["urgency"] = info["urgency"] - _old_estimated_urgency + estimated_urgency
+        started_by_user = info["task"].get("start", "") != ""
+        started_by_scheduler = info["started"]
+        if started_by_scheduler and not started_by_user:
+            # If the task was started by the scheduler, apply the active task coefficient
+            info["urgency"] += urgency_coefficients.active
 
-    if inherit_urgency:
+    if urgency_coefficients.inherit:
         # Define a recursive function to compute the maximum urgency
         def get_max_urgency(info, visited):
-            task_id = info["task"]["id"]
-            if task_id in visited:
-                return visited[task_id]  # Return cached value to avoid cycles
+            task_uuid = info["task"]["uuid"]
+            if task_uuid in visited:
+                return visited[task_uuid]  # Return cached value to avoid cycles
             # Start with the current task's urgency
             urgency = info["urgency"]
-            visited[task_id] = urgency  # Mark as visited
+            visited[task_uuid] = urgency  # Mark as visited
             # Recursively compute urgencies of dependents
-            for dep_id in info["task"].get("depends", []):
-                if dep_id in tasks_remaining:
-                    dep_info = tasks_remaining[dep_id]
+            for dep_uuid in info["task"].get("depends", []):
+                if dep_uuid in tasks_remaining:
+                    dep_info = tasks_remaining[dep_uuid]
                     dep_urgency = get_max_urgency(dep_info, visited)
                     urgency = max(urgency, dep_urgency)
-            visited[task_id] = urgency  # Update with the maximum urgency found
+            visited[task_uuid] = urgency  # Update with the maximum urgency found
             return urgency
 
         # Update urgencies based on dependents
@@ -222,11 +244,12 @@ def allocate_time_to_task(info, day_offset, day_remaining_hours):
         hours_to_decimal(info["task"].get("min_block", 2)),
     )
 
-    if allocation <= 0:
+    if allocation <= 0.05:
         return 0
 
     info["remaining_hours"] -= allocation
     info["task_time_map"][day_offset] -= allocation
+    info["started"] = True
 
     return allocation
 
@@ -248,7 +271,7 @@ def update_tasks_with_scheduling_info(task_info, verbose):
         end_date = scheduled_dates[-1]
         for date_str in scheduled_dates:
             hours = info["scheduling"][date_str]
-            scheduling_note += f"{date_str}T00:00:00 - {hours:.2f} hours\n"
+            scheduling_note += f"{date_str} - {hours_to_pdth(hours)}\n"
 
         subprocess.run(
             [

taskcheck-0.3.0/taskcheck/report.py

@@ -0,0 +1,122 @@
+import sys
+from datetime import timedelta
+from datetime import datetime
+import json
+import re
+import subprocess
+
+
+from rich import print
+from rich.console import Console
+from rich.table import Table
+from rich.text import Text
+from rich.panel import Panel
+
+
+def get_tasks(tasks, year, month, day):
+    regex = re.compile(rf"{year}-{month}-{day} - ([PDTHM0-9]+)")
+    valid_tasks = []
+    for task in tasks:
+        for line in task["scheduling"].split("\n"):
+            m = regex.match(line)
+            if m:
+                due = task.get("due", "")
+                if due:
+                    due = datetime.strptime(due, "%Y%m%dT%H%M%SZ")
+                    due = due - datetime.today()
+                valid_tasks.append(
+                    {
+                        "id": task["id"],
+                        "project": task.get("project", ""),
+                        "description": task["description"],
+                        "scheduling_day": f"{year}-{month}-{day}",
+                        "scheduling_hours": m.group(1),
+                        "urgency": task["urgency"],
+                        "due": due,
+                    }
+                )
+    valid_tasks = sorted(valid_tasks, key=lambda x: x["urgency"], reverse=True)
+    return valid_tasks
+
+
+def get_taskwarrior_date(date, _retry=True):
+    date = subprocess.run(
+        ["task", "calc", date],
+        capture_output=True,
+        text=True,
+    )
+    date = date.stdout.strip()
+    try:
+        date = datetime.strptime(date, "%Y-%m-%dT%H:%M:%S")
+    except Exception as _:
+        if _retry:
+            return get_taskwarrior_date("today+" + date, False)
+        else:
+            print(
+                "Please provide a valid date. Check with `task calc` that your date is in the format YYYY-MM-DDTHH:MM:SS",
+                file=sys.stderr,
+            )
+            exit(2)
+    return date
+
+
+def get_days_in_constraint(constraint):
+    current_date = datetime.today().replace(hour=0, minute=0, second=0, microsecond=0)
+    constraint = get_taskwarrior_date(constraint)
+    while current_date <= constraint:
+        yield current_date.year, current_date.month, current_date.day
+        current_date += timedelta(days=1)
+
+
+def generate_report(config, constraint, verbose=False):
+    console = Console()
+    tasks = subprocess.run(
+        ["task", "scheduling~.", "export"], capture_output=True, text=True
+    )
+    tasks = json.loads(tasks.stdout)
+
+    for year, month, day in get_days_in_constraint(constraint):
+        this_day_tasks = get_tasks(tasks, year, month, day)
+
+        # Create a colorful date header with emojis and a panel
+        date_str = f":calendar: [bold cyan]{year}-{month}-{day}[/bold cyan]"
+        console.print(Panel(date_str, style="bold magenta", expand=False))
+
+        if this_day_tasks:
+            table = Table(show_header=True, header_style="bold blue")
+            table.add_column("Task", style="dim", width=12)
+            table.add_column("Project", style="dim", width=12)
+            table.add_column("Description")
+            table.add_column("Time", justify="right")
+            table.add_column("Urgency")
+            table.add_column("Due date")
+
+            for task in this_day_tasks:
+                task_id = f"[bold green]#{task['id']}[/bold green]"
+                project = task["project"]
+                description = Text(task["description"], style="white")
+                hours = f"[yellow]{task['scheduling_hours']}h[/yellow]"
+                urgency = f"[bold]{task['urgency']}[/bold]"
+                due = task["due"]
+                if due != "" and due < timedelta(days=5):
+                    due = f"[red]{due.days}d[/red]"
+                elif due != "":
+                    due = f"[green]{due.days}d[/green]"
+
+                # Add an emoji based on a keyword in the description
+                if "meeting" in task["description"].lower():
+                    emoji = ":busts_in_silhouette:"
+                elif "review" in task["description"].lower():
+                    emoji = ":mag_right:"
+                elif "write" in task["description"].lower():
+                    emoji = ":pencil:"
+                else:
+                    emoji = ":pushpin:"
+
+                table.add_row(
+                    f"{emoji} {task_id}", project, description, hours, urgency, due
+                )
+
+            console.print(table)
+        else:
+            console.print("[italic dim]No tasks scheduled for this day.[/italic dim]")

{taskcheck-0.2.0 → taskcheck-0.3.0}/taskcheck/sequential.py

@@ -5,6 +5,7 @@ from taskcheck.common import (
     get_tasks,
     mark_end_date,
     pdth_to_hours,
+    hours_to_pdth,
     AVOID_STATUS,
 )
 
@@ -43,7 +44,7 @@ def schedule_task_on_day(
         # consume all the remaining task's hours
         if scheduling_note != "":
             scheduling_note += "\n"
-        scheduling_note += f"{current_date}: {task_remaining_hours:.2f} hours"
+        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
@@ -54,7 +55,7 @@ def schedule_task_on_day(
         # consume all the available hours on this task
         if scheduling_note != "":
             scheduling_note += "\n"
-        scheduling_note += f"{current_date}T00:00:00 - {employable_hours:.2f} hours"
+        scheduling_note += f"{current_date} - {hours_to_pdth(employable_hours)}\n"
         task_remaining_hours -= employable_hours
         used_hours[day_offset] += employable_hours
         if verbose:

{taskcheck-0.2.0 → taskcheck-0.3.0/taskcheck.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: taskcheck
-Version: 0.2.0
+Version: 0.3.0
 Summary: Automatic scheduler for taskwarrior
 Requires-Python: >=3.11
 Description-Content-Type: text/markdown
@@ -8,6 +8,7 @@ License-File: LICENSE
 Requires-Dist: appdirs>=1.4.4
 Requires-Dist: icalendar>=6.0.1
 Requires-Dist: requests>=2.32.3
+Requires-Dist: rich>=13.9.4
 
 
 > _A non-AI automatic scheduler for taskwarrior (i.e. alternative to skedpal/timehero/flowsavvy/reclaim/trevor/motion)_
@@ -19,7 +20,8 @@ This is a taskwarrior extension checks if tasks can be completed on time, consid
 - [x] Use arbitrarily complex time maps
 - [x] Use ical to block time from scheduling (e.g. for meetings, vacations, etc.)
 - [x] Implement scheduling algorithm for parallely working on multiple tasks
-- [ ] Use Google/Microsoft/Apple API to access calendars
+- [ ] Use Google API to access calendars
+- [ ] Export tasks to iCal calendar and API calendars
 
 ## Install
 
@@ -31,29 +33,45 @@ This is a taskwarrior extension checks if tasks can be completed on time, consid
 This extension parses your pending and waiting tasks sorted decreasingly by urgency and tries to schedule them in the future.
 It considers their estimated time to schedule all tasks starting from the most urgent one.
 
-You will need to add the `estimated` and `time_map` UDAs to your tasks. The `estimated` attribute is
+#### UDAs
+
+Taskcheck leverages to UDAs, `estimated` and `time_map`. The `estimated` attribute is
 the expected time to complete the task in hours. The `time_map` is a comma-separated list of strings
 that indicates the hours per day in which you will work on a task (e.g. `work`, `weekend`, etc.).
 The exact correspondence between the `time_map` and the hours of the day is defined in the configuration
-file of taskcheck.
+file of taskcheck. For instance:
+
+```toml
+[time_maps]
+# get an error)
+[time_maps.work]
+monday = [[9, 12.30], [14, 17]]
+tuesday = [[9, 12.30], [14, 17]]
+# ...
+```
+
+#### They say it's an "AI"
 
-`taskcheck` will modify the Taskwarrior tasks by adding the `completion_date` attribute with the expected
+Taskcheck will also parse online iCal calendars (Google, Apple, etc.) and will match them with your time maps.
+It will then modify the Taskwarrior tasks by adding the `completion_date` attribute with the expected
 date of completion and the `scheduled` attribute with the date in which the task is expected to
 start.
 
 It will also print a red line for every task whose `completion_date` is after its `due_date`.
 
-You can exclude a task from being scheduled by removing the `time_map` or `estimated` attributes.
+In general, it is recommended to run taskcheck rather frequently and at least once at the beginning
+of your working day.
 
-You can see tasks that you can execute now with the `task ready` report.
+#### Reports
 
-You can see the schedule for a task in the `scheduling` UDA, e.g. `task scheduling:$(task calc
-tomorrow)` will show you the tasks that include a scheduling for tomorrow.
+You can also print simple reports that exploit the `scheduling` UDA filled by Taskcheck to grasp
+how much time you have to work on which task in which day. For
+instance:
 
-In general, it is recommended to run taskcheck rather frequently and at least once at the beginning
-of your working day.
+- `taskcheck -r today` will show the tasks planned for today
+- `taskcheck -r 1w` will show the tasks planned for the next week,
 
-### Algorithms
+## Algorithms
 
 Taskcheck provides two scheduling algorithms: `parallel` and `sequential`.
 
@@ -125,9 +143,15 @@ event_all_day_is_blocking = true
 expiration = 720 # in hours (720 hours = 30 days)
 ```
 
+## Tips and Tricks
+
+- You can exclude a task from being scheduled by removing the `time_map` or `estimated` attributes.
+- You can see tasks that you can execute now with the `task ready` report.
+
 ## CLI Options
 
 ```
 -v, --verbose: increase output verbosity
 -i, --install: install taskcheck configuration
+-r, --report: show tasks planned until a certain time
 ```

{taskcheck-0.2.0 → taskcheck-0.3.0}/taskcheck.egg-info/SOURCES.txt

@@ -6,6 +6,7 @@ taskcheck/common.py
 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-0.2.0 → taskcheck-0.3.0}/taskcheck.egg-info/requires.txt

@@ -1,3 +1,4 @@
 appdirs>=1.4.4
 icalendar>=6.0.1
 requests>=2.32.3
+rich>=13.9.4