taskcheck 0.3.2.post1__tar.gz → 0.3.3__tar.gz

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: taskcheck
-Version: 0.3.2.post1
+Version: 0.3.3
 Summary: Automatic scheduler for taskwarrior
 Requires-Python: >=3.11
 Description-Content-Type: text/markdown
@@ -144,3 +144,7 @@ additional_attributes_unplanned = ["due", "urgency"] # additional attributes to
 -i, --install: install taskcheck configuration
 -r, --report: show tasks planned until a certain time
 ```
+
+## TODO
+
+- [ ] Consider due dates are nearer while planning in the future

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

@@ -131,3 +131,7 @@ additional_attributes_unplanned = ["due", "urgency"] # additional attributes to
 -i, --install: install taskcheck configuration
 -r, --report: show tasks planned until a certain time
 ```
+
+## TODO
+
+- [ ] Consider due dates are nearer while planning in the future

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

@@ -1,6 +1,6 @@
 [project]
 name = "taskcheck"
-version = "0.3.2-1"
+version = "0.3.3"
 description = "Automatic scheduler for taskwarrior"
 readme = "README.md"
 requires-python = ">=3.11"

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

@@ -20,6 +20,9 @@ class UrgencyCoefficients:
     estimated: dict
     inherit: bool
     active: float
+    age_max: int
+    urgency_due: int
+    urgency_age: int
 
 
 def get_urgency_coefficients():
@@ -31,16 +34,22 @@ def get_urgency_coefficients():
     result = subprocess.run(["task", "_show"], capture_output=True, text=True)
     inherit_urgency = False
     active_task_coefficient = 0
-    coefficients = {}
+    est_coeffs = {}
+    urgency_age_max = 0
+    urgency_age = 0
+    urgency_due = 0
     pattern1 = re.compile(r"^urgency\.uda\.estimated\.(.+)\.coefficient=(.+)$")
     pattern2 = re.compile(r"^urgency\.inherit=(.+)$")
-    pattern3 = re.compile(r"^urgency\.active.coefficient=(.+)$")
+    pattern3 = re.compile(r"^urgency\.active\.coefficient=(.+)$")
+    pattern4 = re.compile(r"^urgency\.age\.max=(.+)$")
+    pattern5 = re.compile(r"^urgency\.due\.coefficient=(.+)$")
+    pattern6 = re.compile(r"^urgency\.age\.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
+            est_coeffs[estimated_value] = coefficient
 
         match = pattern2.match(line)
         if match:
@@ -51,20 +60,26 @@ def get_urgency_coefficients():
             active_coefficient = float(match.group(1))
             active_task_coefficient = active_coefficient
 
-    return UrgencyCoefficients(coefficients, inherit_urgency, active_task_coefficient)
+        match = pattern4.match(line)
+        if match:
+            urgency_age_max = int(match.group(1))
 
+        match = pattern5.match(line)
+        if match:
+            urgency_due = int(match.group(1))
 
-def compute_estimated_urgency(remaining_hours, urgency_coefficients):
-    """
-    Computes the estimated urgency for the given remaining hours using the coefficients.
-    """
-    # Find the closest match (e.g., if '2h' is not available, use '1h' or '3h')
-    closest_match = min(
-        urgency_coefficients.estimated.keys(),
-        key=lambda x: abs(pdth_to_hours(x) - remaining_hours),
+        match = pattern6.match(line)
+        if match:
+            urgency_age = int(match.group(1))
+
+    return UrgencyCoefficients(
+        est_coeffs,
+        inherit_urgency,
+        active_task_coefficient,
+        urgency_age_max,
+        urgency_due,
+        urgency_age,
     )
-    coefficient = urgency_coefficients.estimated[closest_match]
-    return coefficient
 
 
 def check_tasks_parallel(config, verbose=False):
@@ -72,7 +87,6 @@ def check_tasks_parallel(config, verbose=False):
     time_maps = config["time_maps"]
     days_ahead = config["scheduler"]["days_ahead"]
     calendars = get_calendars(config)
-    today = datetime.today().date()
     urgency_coefficients = get_urgency_coefficients()
 
     task_info = initialize_task_info(
@@ -80,16 +94,14 @@ 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, verbose
-        )
+        allocate_time_for_day(task_info, day_offset, urgency_coefficients, verbose)
 
     update_tasks_with_scheduling_info(task_info, verbose)
 
 
 def initialize_task_info(tasks, time_maps, days_ahead, urgency_coefficients, calendars):
     task_info = {}
+    today = datetime.today().date()
     for task in tasks:
         if task.get("status") in AVOID_STATUS:
             continue
@@ -102,9 +114,11 @@ def initialize_task_info(tasks, time_maps, days_ahead, urgency_coefficients, cal
         )
         task_uuid = task["uuid"]
         initial_urgency = float(task.get("urgency", 0))
-        estimated_urgency = compute_estimated_urgency(
-            estimated_hours, urgency_coefficients
+        estimated_urgency = urgency_estimated(
+            {"remaining_hours": estimated_hours}, None, urgency_coefficients
         )
+        due_urgency = urgency_due({"task": task}, today, urgency_coefficients)
+        age_urgency = urgency_age({"task": task}, today, urgency_coefficients)
         task_info[task_uuid] = {
             "task": task,
             "remaining_hours": estimated_hours,
@@ -113,12 +127,15 @@ def initialize_task_info(tasks, time_maps, days_ahead, urgency_coefficients, cal
             "scheduling": {},
             "urgency": initial_urgency,
             "estimated_urgency": estimated_urgency,
+            "due_urgency": due_urgency,
+            "age_urgency": age_urgency,
             "started": False,
         }
     return task_info
 
 
-def allocate_time_for_day(task_info, day_offset, date, urgency_coefficients, verbose):
+def allocate_time_for_day(task_info, day_offset, urgency_coefficients, verbose):
+    date = datetime.today().date() + timedelta(days=day_offset)
     total_available_hours = compute_total_available_hours(task_info, day_offset)
     # if verbose:
     #     print(f"Day {date}, total available hours: {total_available_hours:.2f}")
@@ -129,7 +146,7 @@ def allocate_time_for_day(task_info, day_offset, date, urgency_coefficients, ver
     tasks_remaining = prepare_tasks_remaining(task_info, day_offset)
 
     while day_remaining_hours > 0 and tasks_remaining:
-        recompute_urgencies(tasks_remaining, urgency_coefficients)
+        recompute_urgencies(tasks_remaining, urgency_coefficients, date)
         sorted_task_ids = sorted(
             tasks_remaining.keys(),
             key=lambda x: tasks_remaining[x]["urgency"],
@@ -156,6 +173,12 @@ def allocate_time_for_day(task_info, day_offset, date, urgency_coefficients, ver
                         ],
                     )
                 continue
+
+            wait = info["task"].get("wait")
+            if wait and date <= datetime.strptime(wait, "%Y%m%dT%H%M%SZ").date():
+                if verbose:
+                    print(f"Skipping task {info['task']['id']} due to wait date {wait}")
+                continue
             allocation = allocate_time_to_task(info, day_offset, day_remaining_hours)
             if allocation > 0:
                 day_remaining_hours -= allocation
@@ -201,23 +224,88 @@ def prepare_tasks_remaining(task_info, day_offset):
     }
 
 
-def recompute_urgencies(tasks_remaining, urgency_coefficients):
+def urgency_due(info, date, urgency_coefficients):
+    lfs = 0
+    task = info["task"]
+    if "due" in task:
+        due = datetime.strptime(task["due"], "%Y%m%dT%H%M%SZ").date()
+        # Map a range of 21 days to the value 0.2 - 1.0
+        days_overdue = (date - due).days
+        if days_overdue >= 7.0:
+            lfs = 1.0  # < 1 wk ago
+        elif days_overdue >= -14.0:
+            lfs = ((days_overdue + 14.0) * 0.8 / 21.0) + 0.2
+        else:
+            lfs = 0.2  # 2 wks
+    return lfs * urgency_coefficients.urgency_due
+
+
+def urgency_age(info, date, urgency_coefficients):
+    urgency_age_max = urgency_coefficients.age_max
+    lfs = 1.0
+    task = info["task"]
+    if "entry" not in task:
+        return 1.0
+    entry = datetime.strptime(task["entry"], "%Y%m%dT%H%M%SZ").date()
+    age = (date - entry).days  # in days
+    if urgency_age_max == 0 or age >= urgency_age_max:
+        lfs = 1.0
+    return lfs * age / urgency_age_max * urgency_coefficients.urgency_age
+
+
+def urgency_estimated(info, date, urgency_coefficients):
+    """
+    Computes the estimated urgency for the given remaining hours using the coefficients.
+    """
+    # Find the closest match (e.g., if '2h' is not available, use '1h' or '3h')
+    closest_match = min(
+        urgency_coefficients.estimated.keys(),
+        key=lambda x: abs(pdth_to_hours(x) - info["remaining_hours"]),
+    )
+    coefficient = urgency_coefficients.estimated[closest_match]
+    return coefficient
+
+
+def update_urgency(info, urgency_key, urgency_compute_fn, urgency_coefficients, date):
+    urgency_value = urgency_compute_fn(info, date, urgency_coefficients)
+    old_urgency = info[urgency_key]
+    if old_urgency != urgency_value:
+        print(
+            f"new urgency value for task {info['task']['id']}: {urgency_key}: {urgency_value}"
+        )
+    info[urgency_key] = urgency_value
+    info["urgency"] = info["urgency"] - old_urgency + urgency_value
+
+
+def recompute_urgencies(tasks_remaining, urgency_coefficients, date):
+    """Recompute urgency simulating that today is `date`"""
     # Recompute estimated urgencies as before
     for info in tasks_remaining.values():
-        remaining_hours = info["remaining_hours"]
-        estimated_urgency = compute_estimated_urgency(
-            remaining_hours, urgency_coefficients
+        # Update estimated urgency
+        update_urgency(
+            info, "estimated_urgency", urgency_estimated, urgency_coefficients, date
         )
-        _old_estimated_urgency = info["estimated_urgency"]
-        info["estimated_urgency"] = estimated_urgency
-        info["urgency"] = info["urgency"] - _old_estimated_urgency + estimated_urgency
+        # Update due partial urgency
+        update_urgency(info, "due_urgency", urgency_due, urgency_coefficients, date)
+        # Update age partial urgency
+        update_urgency(info, "age_urgency", urgency_age, urgency_coefficients, date)
+
         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
+            info["started"] = False
 
     if urgency_coefficients.inherit:
+        # Build reverse dependencies mapping
+        reverse_deps = {}  # Map from task_uuid to list of tasks that depend on it
+        for task_uuid, info in tasks_remaining.items():
+            for dep_uuid in info["task"].get("depends", []):
+                if dep_uuid not in reverse_deps:
+                    reverse_deps[dep_uuid] = []
+                reverse_deps[dep_uuid].append(task_uuid)
+
         # Define a recursive function to compute the maximum urgency
         def get_max_urgency(info, visited):
             task_uuid = info["task"]["uuid"]
@@ -226,8 +314,8 @@ def recompute_urgencies(tasks_remaining, urgency_coefficients):
             # Start with the current task's urgency
             urgency = info["urgency"]
             visited[task_uuid] = urgency  # Mark as visited
-            # Recursively compute urgencies of dependents
-            for dep_uuid in info["task"].get("depends", []):
+            # Recursively compute urgencies of tasks that depend on this task
+            for dep_uuid in reverse_deps.get(task_uuid, []):
                 if dep_uuid in tasks_remaining:
                     dep_info = tasks_remaining[dep_uuid]
                     dep_urgency = get_max_urgency(dep_info, visited)
@@ -235,7 +323,7 @@ def recompute_urgencies(tasks_remaining, urgency_coefficients):
             visited[task_uuid] = urgency  # Update with the maximum urgency found
             return urgency
 
-        # Update urgencies based on dependents
+        # Update urgencies based on tasks that depend on them
         for info in tasks_remaining.values():
             visited = {}  # Reset visited dictionary for each task
             max_urgency = get_max_urgency(info, visited)
@@ -257,9 +345,10 @@ def allocate_time_to_task(info, day_offset, day_remaining_hours):
     if allocation <= 0.05:
         return 0
 
+    if info["remaining_hours"] == info["task"]["estimated"]:
+        info["started"] = True
     info["remaining_hours"] -= allocation
     info["task_time_map"][day_offset] -= allocation
-    info["started"] = True
 
     return allocation
 

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: taskcheck
-Version: 0.3.2.post1
+Version: 0.3.3
 Summary: Automatic scheduler for taskwarrior
 Requires-Python: >=3.11
 Description-Content-Type: text/markdown
@@ -144,3 +144,7 @@ additional_attributes_unplanned = ["due", "urgency"] # additional attributes to
 -i, --install: install taskcheck configuration
 -r, --report: show tasks planned until a certain time
 ```
+
+## TODO
+
+- [ ] Consider due dates are nearer while planning in the future