taskcheck 1.0.0.post2__tar.gz → 1.1.0__tar.gz

{taskcheck-1.0.0.post2 → taskcheck-1.1.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: taskcheck
-Version: 1.0.0.post2
+Version: 1.1.0
 Summary: Automatic scheduler for taskwarrior
 Requires-Python: >=3.11
 Description-Content-Type: text/markdown
@@ -32,6 +32,9 @@ This is a taskwarrior extension that automatically schedules your tasks based on
 estimated time, and calendar events, finding an optimal time to work on each task and match all your
 deadlines.
 
+> [!IMPORTANT]
+> This repo is actively maintained again
+
 ## Features
 
 - [x] **Use arbitrarily complex time maps for working hours**
@@ -44,7 +47,6 @@ deadlines.
 - [x] Simple, customizable reports for planned and unplanned tasks
 - [x] Emoji and attribute customization in reports
 - [ ] Use Google API to access calendars
-- [ ] Export tasks to iCal calendar and API calendars
 
 ## Install
 
@@ -138,6 +140,7 @@ expiration = 720          # In hours (720 hours = 30 days)
 include_unplanned = true
 additional_attributes = ["estimated", "due", "urgency"]           # Extra attributes to show in the report
 additional_attributes_unplanned = ["due", "urgency"]               # Extra attributes for unplanned tasks
+unplanned_max_due = "30d"       # Only show unplanned tasks due within this Taskwarrior-relative horizon; tasks without a due date are always shown
 emoji_keywords = {"meet"=":busts_in_silhouette:", "review"=":mag_right:"} # Map keywords to emoji
 ```
 
@@ -155,6 +158,7 @@ emoji_keywords = {"meet"=":busts_in_silhouette:", "review"=":mag_right:"} # Map
   - `include_unplanned`: Show unplanned tasks in a separate section.
   - `additional_attributes`: Extra columns to show in the report.
   - `additional_attributes_unplanned`: Extra columns for unplanned tasks.
+  - `unplanned_max_due`: Optional Taskwarrior-relative horizon (for example `30d`) for dated unplanned tasks. Tasks without a due date are always shown; omitting this setting applies no limit.
   - `emoji_keywords`: Map keywords in task descriptions to emoji.
 
 ## Algorithm

taskcheck-1.0.0.post2/taskcheck.egg-info/PKG-INFO → taskcheck-1.1.0/README.md

@@ -1,15 +1,3 @@
-Metadata-Version: 2.4
-Name: taskcheck
-Version: 1.0.0.post2
-Summary: Automatic scheduler for taskwarrior
-Requires-Python: >=3.11
-Description-Content-Type: text/markdown
-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
-
 <div align="center">
   
 ```
@@ -32,6 +20,9 @@ This is a taskwarrior extension that automatically schedules your tasks based on
 estimated time, and calendar events, finding an optimal time to work on each task and match all your
 deadlines.
 
+> [!IMPORTANT]
+> This repo is actively maintained again
+
 ## Features
 
 - [x] **Use arbitrarily complex time maps for working hours**
@@ -44,7 +35,6 @@ deadlines.
 - [x] Simple, customizable reports for planned and unplanned tasks
 - [x] Emoji and attribute customization in reports
 - [ ] Use Google API to access calendars
-- [ ] Export tasks to iCal calendar and API calendars
 
 ## Install
 
@@ -138,6 +128,7 @@ expiration = 720          # In hours (720 hours = 30 days)
 include_unplanned = true
 additional_attributes = ["estimated", "due", "urgency"]           # Extra attributes to show in the report
 additional_attributes_unplanned = ["due", "urgency"]               # Extra attributes for unplanned tasks
+unplanned_max_due = "30d"       # Only show unplanned tasks due within this Taskwarrior-relative horizon; tasks without a due date are always shown
 emoji_keywords = {"meet"=":busts_in_silhouette:", "review"=":mag_right:"} # Map keywords to emoji
 ```
 
@@ -155,6 +146,7 @@ emoji_keywords = {"meet"=":busts_in_silhouette:", "review"=":mag_right:"} # Map
   - `include_unplanned`: Show unplanned tasks in a separate section.
   - `additional_attributes`: Extra columns to show in the report.
   - `additional_attributes_unplanned`: Extra columns for unplanned tasks.
+  - `unplanned_max_due`: Optional Taskwarrior-relative horizon (for example `30d`) for dated unplanned tasks. Tasks without a due date are always shown; omitting this setting applies no limit.
   - `emoji_keywords`: Map keywords in task descriptions to emoji.
 
 ## Algorithm

{taskcheck-1.0.0.post2 → taskcheck-1.1.0}/pyproject.toml

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

{taskcheck-1.0.0.post2 → taskcheck-1.1.0}/taskcheck/__main__.py

@@ -24,18 +24,18 @@ arg_parser.add_argument(
     "-s",
     "--schedule",
     action="store_true",
-    help="Perform the scheduling algorithm, giving a schedule and a scheduling UDA and alerting for not completable tasks",
+    help="Perform the scheduling algorithm, giving a schedule and a scheduling UDA and alerting for not completable tasks.",
 )
 arg_parser.add_argument(
     "-f",
     "--force-update",
     action="store_true",
-    help="Force update of all ical calendars by ignoring cache expiration",
+    help="Force update of all ical calendars by ignoring cache expiration.",
 )
 arg_parser.add_argument(
     "--taskrc",
     action="store",
-    help="Set custom TASKRC directory for debugging purposes",
+    help="Set custom TASKRC directory for debugging purposes.",
 )
 arg_parser.add_argument(
     "--urgency-weight",
@@ -45,14 +45,14 @@ arg_parser.add_argument(
 arg_parser.add_argument(
     "--dry-run",
     action="store_true",
-    help="Perform scheduling without modifying the Taskwarrior database, useful for testing",
+    help="Perform scheduling without modifying the Taskwarrior database, useful for testing.",
 )
 arg_parser.add_argument(
     "--no-auto-adjust-urgency",
     dest="auto_adjust_urgency",
     action="store_false",
     default=True,
-    help="Disable automatic reduction of urgency weight … (default: enabled)",
+    help="Disable automatic reduction of urgency weight when tasks cannot be completed on time. (Enabled by default, meaning automatic reduction will occur.)",
 )
 
 

{taskcheck-1.0.0.post2 → taskcheck-1.1.0}/taskcheck/ical.py

@@ -40,17 +40,18 @@ def parse_ical_events(ical_text, days_ahead, all_day, tz_name=None, verbose=Fals
                 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)
+                    event_end = datetime(
+                        event_end.year,
+                        event_end.month,
+                        event_end.day,
+                    )
+                    if event_end <= event_start:
+                        event_end = event_start + timedelta(days=1)
             if recurrence_id:
                 if end_date >= recurrence_id.dt.date() >= today:
                     # this was an occurrence of a recurring event

{taskcheck-1.0.0.post2 → taskcheck-1.1.0}/taskcheck/install.py

@@ -19,12 +19,22 @@ weight_urgency = 1.0
 include_unplanned = true
 additional_attributes = []
 additional_attributes_unplanned = []
+# unplanned_max_due = "30d"
 emoji_keywords = {}
 """
 
 
 def apply_config(key, value):
-    subprocess.run(["task", "config", key, value], stdout=subprocess.DEVNULL)
+    subprocess.run(
+        [
+            "task",
+            "rc.confirmation=0",
+            "config",
+            key,
+            value,
+        ],
+        stdout=subprocess.DEVNULL,
+    )
 
 
 def install():

{taskcheck-1.0.0.post2 → taskcheck-1.1.0}/taskcheck/report.py

@@ -194,6 +194,7 @@ def get_tasks(config, tasks, year, month, day):
                         "id": task["id"],
                         "project": task.get("project", ""),
                         "description": task["description"],
+                        "urgency": task["urgency"],
                         "scheduling_day": f"{year}-{month}-{day}",
                         "scheduling_hours": m.group(1),
                         **{
@@ -265,22 +266,28 @@ def get_unplanned_tasks(config, tasks, taskrc=None):
         env=env,
     )
     tasks = json.loads(tasks.stdout)
-    return tasks
+    max_due = config.get("unplanned_max_due")
+    if not max_due:
+        return tasks
+
+    due_limit = get_taskwarrior_date(max_due, taskrc=taskrc)
+    return [
+        task
+        for task in tasks
+        if not task.get("due")
+        or datetime.strptime(task["due"], "%Y%m%dT%H%M%SZ") <= due_limit
+    ]
 
 
 def generate_report(config, constraint, verbose=False, force_update=False, taskrc=None, scheduling_results=None):
     config = config["report"]
     console = Console()
     
-    if scheduling_results is not None:
-        # Use provided scheduling results (from dry-run mode)
-        tasks = scheduling_results
-    else:
-        # Fetch tasks from Taskwarrior normally
-        tasks = fetch_tasks(taskrc)
+    original_tasks = fetch_tasks(taskrc)
+    tasks = scheduling_results if scheduling_results is not None else original_tasks
 
     if config.get("include_unplanned"):
-        unplanned_tasks = get_unplanned_tasks(config, tasks, taskrc=taskrc)
+        unplanned_tasks = get_unplanned_tasks(config, original_tasks, taskrc=taskrc)
         display_unplanned_tasks(console, config, unplanned_tasks)
 
     for year, month, day in get_days_in_constraint(constraint, taskrc=taskrc):

taskcheck-1.0.0.post2/README.md → taskcheck-1.1.0/taskcheck.egg-info/PKG-INFO

@@ -1,3 +1,15 @@
+Metadata-Version: 2.4
+Name: taskcheck
+Version: 1.1.0
+Summary: Automatic scheduler for taskwarrior
+Requires-Python: >=3.11
+Description-Content-Type: text/markdown
+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
+
 <div align="center">
   
 ```
@@ -20,6 +32,9 @@ This is a taskwarrior extension that automatically schedules your tasks based on
 estimated time, and calendar events, finding an optimal time to work on each task and match all your
 deadlines.
 
+> [!IMPORTANT]
+> This repo is actively maintained again
+
 ## Features
 
 - [x] **Use arbitrarily complex time maps for working hours**
@@ -32,7 +47,6 @@ deadlines.
 - [x] Simple, customizable reports for planned and unplanned tasks
 - [x] Emoji and attribute customization in reports
 - [ ] Use Google API to access calendars
-- [ ] Export tasks to iCal calendar and API calendars
 
 ## Install
 
@@ -126,6 +140,7 @@ expiration = 720          # In hours (720 hours = 30 days)
 include_unplanned = true
 additional_attributes = ["estimated", "due", "urgency"]           # Extra attributes to show in the report
 additional_attributes_unplanned = ["due", "urgency"]               # Extra attributes for unplanned tasks
+unplanned_max_due = "30d"       # Only show unplanned tasks due within this Taskwarrior-relative horizon; tasks without a due date are always shown
 emoji_keywords = {"meet"=":busts_in_silhouette:", "review"=":mag_right:"} # Map keywords to emoji
 ```
 
@@ -143,6 +158,7 @@ emoji_keywords = {"meet"=":busts_in_silhouette:", "review"=":mag_right:"} # Map
   - `include_unplanned`: Show unplanned tasks in a separate section.
   - `additional_attributes`: Extra columns to show in the report.
   - `additional_attributes_unplanned`: Extra columns for unplanned tasks.
+  - `unplanned_max_due`: Optional Taskwarrior-relative horizon (for example `30d`) for dated unplanned tasks. Tasks without a due date are always shown; omitting this setting applies no limit.
   - `emoji_keywords`: Map keywords in task descriptions to emoji.
 
 ## Algorithm

{taskcheck-1.0.0.post2 → taskcheck-1.1.0}/tests/test_common.py

@@ -80,6 +80,17 @@ class TestAvailableHours:
         available = get_available_hours(time_map, date, calendars)
         assert available == 0.0
 
+    def test_get_available_hours_multi_day_all_day_event(self, sample_config):
+        time_map = sample_config["time_maps"]["work"]
+        calendars = [[{
+            "start": datetime(2023, 12, 5, 0, 0),
+            "end": datetime(2023, 12, 7, 0, 0),
+        }]]
+
+        assert get_available_hours(time_map, datetime(2023, 12, 5).date(), calendars) == 0.0
+        assert get_available_hours(time_map, datetime(2023, 12, 6).date(), calendars) == 0.0
+        assert get_available_hours(time_map, datetime(2023, 12, 7).date(), calendars) == 8.0
+
 
 class TestLongRangeTimeMap:
     def test_get_long_range_time_map(self, sample_config, sample_calendar_events):

taskcheck-1.1.0/tests/test_ical.py

@@ -0,0 +1,189 @@
+import pytest
+from datetime import datetime, timedelta
+from unittest.mock import Mock, patch
+
+from taskcheck.ical import fetch_ical_data, parse_ical_events, ical_to_dict, get_cache_filename
+
+
+class TestIcalFetching:
+    @patch("requests.get")
+    def test_fetch_ical_data_success(self, mock_get, mock_ical_response):
+        mock_response = Mock()
+        mock_response.text = mock_ical_response
+        mock_response.raise_for_status = Mock()
+        mock_get.return_value = mock_response
+
+        assert fetch_ical_data("https://example.com/calendar.ics") == mock_ical_response
+
+    @patch("requests.get")
+    def test_fetch_ical_data_error(self, mock_get):
+        mock_response = Mock()
+        mock_response.raise_for_status.side_effect = Exception("HTTP Error")
+        mock_get.return_value = mock_response
+
+        with pytest.raises(Exception):
+            fetch_ical_data("https://example.com/calendar.ics")
+
+
+class TestIcalParsing:
+    @patch("taskcheck.ical.datetime")
+    def test_parse_ical_events_simple(self, mock_datetime, mock_ical_response):
+        mock_datetime.now.return_value = datetime(2023, 12, 1, 12, 0, 0)
+        mock_datetime.side_effect = lambda *args, **kw: datetime(*args, **kw)
+        events = parse_ical_events(mock_ical_response, days_ahead=7, all_day=False)
+        assert len(events) == 2
+
+    @patch("taskcheck.ical.datetime")
+    def test_parse_ical_events_with_timezone(self, mock_datetime, mock_ical_response):
+        mock_datetime.now.return_value = datetime(2023, 12, 1, 12, 0, 0)
+        mock_datetime.side_effect = lambda *args, **kw: datetime(*args, **kw)
+        events = parse_ical_events(mock_ical_response, days_ahead=7, all_day=False, tz_name="America/New_York")
+        assert events and events[0]["start"].endswith(("-05:00", "-04:00"))
+
+    @patch("taskcheck.ical.datetime")
+    def test_parse_ical_events_recurring(self, mock_datetime):
+        mock_datetime.now.return_value = datetime(2023, 12, 1, 12, 0, 0)
+        mock_datetime.side_effect = lambda *args, **kw: datetime(*args, **kw)
+        ical_text = """BEGIN:VCALENDAR
+VERSION:2.0
+PRODID:test
+BEGIN:VEVENT
+UID:recurring-event
+DTSTART:20231205T140000Z
+DTEND:20231205T150000Z
+SUMMARY:Weekly Meeting
+RRULE:FREQ=WEEKLY;COUNT=3
+END:VEVENT
+END:VCALENDAR"""
+        assert len(parse_ical_events(ical_text, days_ahead=21, all_day=False)) == 3
+
+    @patch("taskcheck.ical.datetime")
+    def test_parse_ical_events_all_day(self, mock_datetime):
+        mock_datetime.now.return_value = datetime(2023, 12, 1, 12, 0, 0)
+        mock_datetime.side_effect = lambda *args, **kw: datetime(*args, **kw)
+        ical_text = """BEGIN:VCALENDAR
+VERSION:2.0
+PRODID:test
+BEGIN:VEVENT
+UID:all-day-event
+DTSTART;VALUE=DATE:20231205
+DTEND;VALUE=DATE:20231206
+SUMMARY:All Day Event
+END:VEVENT
+END:VCALENDAR"""
+        assert len(parse_ical_events(ical_text, days_ahead=7, all_day=True)) == 1
+        assert parse_ical_events(ical_text, days_ahead=7, all_day=False) == []
+
+    @patch("taskcheck.ical.datetime")
+    def test_parse_multi_day_all_day_event_preserves_span(self, mock_datetime):
+        mock_datetime.now.return_value = datetime(2023, 12, 1, 12, 0, 0)
+        mock_datetime.side_effect = lambda *args, **kw: datetime(*args, **kw)
+        ical_text = """BEGIN:VCALENDAR
+VERSION:2.0
+PRODID:test
+BEGIN:VEVENT
+UID:multi-day-event
+DTSTART;VALUE=DATE:20231205
+DTEND;VALUE=DATE:20231207
+SUMMARY:Two Day Event
+END:VEVENT
+END:VCALENDAR"""
+        events = parse_ical_events(ical_text, days_ahead=7, all_day=True)
+        assert events == [{"start": "2023-12-05T00:00:00", "end": "2023-12-07T00:00:00"}]
+
+    @patch("taskcheck.ical.datetime")
+    def test_parse_ical_events_exdate_and_recurrence_id(self, mock_datetime):
+        mock_datetime.now.return_value = datetime(2023, 12, 1, 12, 0, 0)
+        mock_datetime.side_effect = lambda *args, **kw: datetime(*args, **kw)
+        ical_text = """BEGIN:VCALENDAR
+VERSION:2.0
+PRODID:test
+BEGIN:VEVENT
+UID:rrule-exdate
+DTSTART:20231205T140000Z
+DTEND:20231205T150000Z
+RRULE:FREQ=DAILY;COUNT=3
+EXDATE:20231206T140000Z
+END:VEVENT
+BEGIN:VEVENT
+UID:rrule-exception
+RECURRENCE-ID:20231207T140000Z
+DTSTART:20231207T160000Z
+DTEND:20231207T170000Z
+END:VEVENT
+END:VCALENDAR"""
+        events = parse_ical_events(ical_text, days_ahead=10, all_day=False)
+        starts = {e["start"] for e in events}
+        assert len(events) == 2
+        assert any("2023-12-05T14:00:00+00:00" in s for s in starts)
+        assert any("2023-12-07T16:00:00+00:00" in s for s in starts)
+
+    @patch("taskcheck.ical.datetime")
+    def test_parse_ical_events_past_until_skipped(self, mock_datetime):
+        mock_datetime.now.return_value = datetime(2023, 12, 10, 12, 0, 0)
+        mock_datetime.side_effect = lambda *args, **kw: datetime(*args, **kw)
+        ical_text = """BEGIN:VCALENDAR
+VERSION:2.0
+PRODID:test
+BEGIN:VEVENT
+UID:past-rule
+DTSTART:20231201T140000Z
+DTEND:20231201T150000Z
+RRULE:FREQ=DAILY;UNTIL=20231205T000000Z
+END:VEVENT
+END:VCALENDAR"""
+        assert parse_ical_events(ical_text, days_ahead=7, all_day=False) == []
+
+
+class TestIcalCaching:
+    def test_get_cache_filename(self):
+        filename = get_cache_filename("https://example.com/calendar.ics")
+        assert filename.suffix == ".json"
+        assert len(filename.stem) == 64
+
+    @patch("requests.get")
+    def test_ical_to_dict_with_cache(self, mock_get, temp_cache_dir, mock_ical_response):
+        mock_response = Mock()
+        mock_response.text = mock_ical_response
+        mock_response.raise_for_status = Mock()
+        mock_get.return_value = mock_response
+        url = "https://example.com/calendar.ics"
+        events1 = ical_to_dict(url, days_ahead=7, all_day=False, expiration=1.0)
+        events2 = ical_to_dict(url, days_ahead=7, all_day=False, expiration=1.0)
+        assert events1 == events2
+        assert mock_get.call_count == 1
+
+    @patch("requests.get")
+    def test_ical_to_dict_force_update(self, mock_get, temp_cache_dir, mock_ical_response):
+        mock_response = Mock()
+        mock_response.text = mock_ical_response
+        mock_response.raise_for_status = Mock()
+        mock_get.return_value = mock_response
+        url = "https://example.com/calendar.ics"
+        events1 = ical_to_dict(url, days_ahead=7, all_day=False, expiration=1.0)
+        events2 = ical_to_dict(url, days_ahead=7, all_day=False, expiration=1.0, force_update=True)
+        assert events1 == events2
+        assert mock_get.call_count == 2
+
+    @patch("requests.get")
+    def test_ical_to_dict_expired_cache_refreshes(self, mock_get, temp_cache_dir, mock_ical_response):
+        mock_response = Mock()
+        mock_response.text = mock_ical_response
+        mock_response.raise_for_status = Mock()
+        mock_get.return_value = mock_response
+        url = "https://example.com/calendar.ics"
+        ical_to_dict(url, days_ahead=7, all_day=False, expiration=1.0)
+        ical_to_dict(url, days_ahead=7, all_day=False, expiration=0.0)
+        assert mock_get.call_count == 2
+
+
+class TestExceptionHandling:
+    @patch("requests.get")
+    def test_ical_to_dict_malformed_ical(self, mock_get, temp_cache_dir):
+        mock_response = Mock()
+        mock_response.text = "INVALID ICAL DATA"
+        mock_response.raise_for_status = Mock()
+        mock_get.return_value = mock_response
+
+        with pytest.raises(Exception):
+            ical_to_dict("https://example.com/calendar.ics", days_ahead=7, all_day=False)

{taskcheck-1.0.0.post2 → taskcheck-1.1.0}/tests/test_parallel.py

@@ -1,4 +1,4 @@
-from datetime import datetime
+from datetime import datetime, timedelta
 from unittest.mock import patch
 
 from taskcheck.parallel import (
@@ -121,10 +121,43 @@ class TestTimeAllocation:
 
         allocate_time_for_day(task_info, 0, coeffs, verbose=True, weight_urgency=1.0)
 
-        # Should allocate time and update scheduling
         assert task_info["task-1"]["remaining_hours"] < 2.0
         assert len(task_info["task-1"]["scheduling"]) > 0
 
+    def test_allocate_time_for_day_wait_and_dependency_skip(self):
+        today = datetime.today().date()
+        wait_date = (today + timedelta(days=1)).strftime("%Y%m%dT%H%M%SZ")
+        task_info = {
+            "task-1": {
+                "task": {"id": 1, "uuid": "task-1", "estimated": "P2H", "wait": wait_date},
+                "remaining_hours": 2.0,
+                "task_time_map": [8.0],
+                "today_used_hours": 0.0,
+                "scheduling": {},
+                "urgency": 10.0,
+                "estimated_urgency": 8.0,
+                "due_urgency": 0.0,
+                "age_urgency": 1.0,
+                "started": False,
+            },
+            "task-2": {
+                "task": {"id": 2, "uuid": "task-2", "estimated": "P2H", "depends": ["task-1"]},
+                "remaining_hours": 2.0,
+                "task_time_map": [8.0],
+                "today_used_hours": 0.0,
+                "scheduling": {},
+                "urgency": 9.0,
+                "estimated_urgency": 8.0,
+                "due_urgency": 0.0,
+                "age_urgency": 1.0,
+                "started": False,
+            },
+        }
+        coeffs = UrgencyCoefficients({"P2H": 8.0}, False, 4.0, 365, 12, 2)
+        allocate_time_for_day(task_info, 0, coeffs, verbose=False, weight_urgency=1.0)
+        assert task_info["task-1"]["remaining_hours"] == 2.0
+        assert task_info["task-2"]["remaining_hours"] == 2.0
+
 
 class TestDependencies:
     def test_task_with_dependencies(self, sample_config):
@@ -237,7 +270,6 @@ class TestWeightConfiguration:
         mock_tasks.assert_called_once()
 
     def test_recompute_urgencies_with_weights(self):
-        """Test that recompute_urgencies applies weights correctly."""
         tasks_remaining = {
             "task-1": {
                 "task": {"uuid": "task-1", "id": 1},
@@ -250,29 +282,19 @@ class TestWeightConfiguration:
             }
         }
 
-        coeffs = UrgencyCoefficients({"P1H": 5.0, "P2H": 8.0}, False, 0, 365, 12, 2)
+        coeffs = UrgencyCoefficients({"P2H": 8.0}, False, 0, 365, 12, 2)
         date = datetime.now().date()
-        weight_urgency = 0.7
-
-        # Store original urgency to calculate base
+        recompute_urgencies(tasks_remaining, coeffs, date, 0.7)
+        assert tasks_remaining["task-1"]["urgency"] >= tasks_remaining["task-1"]["due_urgency"]
 
-        recompute_urgencies(tasks_remaining, coeffs, date, weight_urgency)
-
-        # Check that weights were applied to the NEW urgency values (after recomputation)
-        task_info = tasks_remaining["task-1"]
-
-        # The function recomputes all urgency components, so we must use the new values after recomputation.
-        # The actual implementation does:
-        # base_urgency = new_urgency - new_due_urgency
-        # weighted_urgency = base_urgency * weight_urgency + new_due_urgency
-        base_urgency = (
-            (task_info["urgency"] - task_info["due_urgency"]) / weight_urgency
-            if weight_urgency != 0
-            else 0
-        )
-        expected_urgency = base_urgency * weight_urgency + task_info["due_urgency"]
-
-        assert abs(task_info["urgency"] - expected_urgency) < 0.01
+    def test_recompute_urgencies_inherit_and_cycle(self):
+        tasks_remaining = {
+            "a": {"task": {"uuid": "a", "depends": ["b"]}, "urgency": 1.0, "estimated_urgency": 0.0, "due_urgency": 0.0, "age_urgency": 0.0, "remaining_hours": 1.0, "started": False},
+            "b": {"task": {"uuid": "b", "depends": ["a"]}, "urgency": 2.0, "estimated_urgency": 0.0, "due_urgency": 0.0, "age_urgency": 0.0, "remaining_hours": 1.0, "started": False},
+        }
+        coeffs = UrgencyCoefficients({"P1H": 5.0}, True, 0, 365, 12, 2)
+        recompute_urgencies(tasks_remaining, coeffs, datetime.now().date(), 1.0)
+        assert tasks_remaining["a"]["urgency"] == tasks_remaining["b"]["urgency"]
 
 
 class TestMainSchedulingFunction:
@@ -468,69 +490,52 @@ class TestAutoAdjustUrgency:
         sample_config,
         test_taskrc,
     ):
-        """Test that the final urgency weight message is printed when auto-adjust is used."""
-        # Use relative dates based on current date
-        from datetime import datetime, timedelta
-
         now = datetime.now()
-        future_date_near = now + timedelta(days=3)
-        future_date_far = now + timedelta(days=7)
-
-        # Create tasks that will require at least one reduction in urgency weight
+        future_date = now + timedelta(days=3)
         overdue_tasks = [
-            {
-                "id": 1,
-                "uuid": "task-1",
-                "description": "Tight deadline",
-                "estimated": "P16H",  # 2 working days, due in 7 days
-                "time_map": "work",
-                "urgency": 20.0,
-                "due": future_date_far.strftime(
-                    "%Y%m%dT%H%M%SZ"
-                ),  # Due in 7 days - tight deadline
-                "status": "pending",
-                "entry": now.strftime("%Y%m%dT%H%M%SZ"),  # Created today
-            },
-            {
-                "id": 2,
-                "uuid": "task-2",
-                "description": "Competing task",
-                "estimated": "P16H",  # 2 working days, due in 3 days
-                "time_map": "work",
-                "urgency": 15.0,
-                "due": future_date_near.strftime(
-                    "%Y%m%dT%H%M%SZ"
-                ),  # Same deadline to create conflict
-                "status": "pending",
-                "entry": now.strftime("%Y%m%dT%H%M%SZ"),  # Created today
-            },
+            {"id": 1, "uuid": "task-1", "description": "Tight deadline", "estimated": "P16H", "time_map": "work", "urgency": 20.0, "due": future_date.strftime("%Y%m%dT%H%M%SZ"), "status": "pending", "entry": now.strftime("%Y%m%dT%H%M%SZ")},
+            {"id": 2, "uuid": "task-2", "description": "Competing task", "estimated": "P16H", "time_map": "work", "urgency": 15.0, "due": future_date.strftime("%Y%m%dT%H%M%SZ"), "status": "pending", "entry": now.strftime("%Y%m%dT%H%M%SZ")},
         ]
-
         mock_tasks.return_value = overdue_tasks
-        mock_coeffs.return_value = UrgencyCoefficients(
-            {"P16H": 10.0, "P8H": 8.0}, False, 4.0, 365, 12, 2
-        )
+        mock_coeffs.return_value = UrgencyCoefficients({"P16H": 10.0, "P8H": 8.0}, False, 4.0, 365, 12, 2)
         mock_calendars.return_value = []
-        # Mock enough available time that the task CAN be completed with weight reduction
-        mock_long_range.return_value = ([4.0] * 7, 0.0)  # 28 total hours available
-
+        mock_long_range.return_value = ([4.0] * 7, 0.0)
         with patch("taskcheck.parallel.console.print") as mock_console_print:
-            check_tasks_parallel(
-                sample_config,
-                verbose=True,
-                taskrc=test_taskrc,
-                auto_adjust_urgency=True,
-            )
+            check_tasks_parallel(sample_config, verbose=True, taskrc=test_taskrc, auto_adjust_urgency=True)
+            messages = [" ".join(str(arg).lower() for arg in call.args) for call in mock_console_print.call_args_list]
+            assert any("final urgency weight" in msg or "cannot find a solution" in msg for msg in messages)
 
-            # Should print the final urgency weight used
-            # Print all captured calls for debugging if the assertion fails
-            found_final_weight = any(
-                "final urgency weight"
-                in " ".join(str(arg).lower() for arg in call.args)
-                for call in mock_console_print.call_args_list
-            )
-            if not found_final_weight:
-                print("Captured console.print calls for debug:")
-                for call in mock_console_print.call_args_list:
-                    print(str(call))
-            assert found_final_weight
+    @patch("taskcheck.parallel.get_calendars")
+    @patch("taskcheck.parallel.get_tasks")
+    @patch("taskcheck.parallel.get_urgency_coefficients")
+    @patch("taskcheck.parallel.get_long_range_time_map")
+    def test_check_tasks_parallel_dry_run_and_warning(
+        self,
+        mock_long_range,
+        mock_coeffs,
+        mock_tasks,
+        mock_calendars,
+        sample_config,
+        test_taskrc,
+    ):
+        now = datetime.now()
+        due = (now + timedelta(days=1)).strftime("%Y%m%dT%H%M%SZ")
+        mock_tasks.return_value = [{"id": 1, "uuid": "task-1", "description": "x", "estimated": "P2H", "time_map": "work", "urgency": 1.0, "due": due, "status": "pending", "entry": now.strftime("%Y%m%dT%H%M%SZ") }]
+        mock_coeffs.return_value = UrgencyCoefficients({"P2H": 8.0}, False, 4.0, 365, 12, 2)
+        mock_calendars.return_value = []
+        mock_long_range.return_value = ([0.5] * 7, 0.0)
+        with patch("taskcheck.parallel.console.print") as mock_print:
+            result = check_tasks_parallel(sample_config, verbose=False, taskrc=test_taskrc, dry_run=True, auto_adjust_urgency=False)
+        assert isinstance(result, list)
+        assert result
+        assert any("warning" in " ".join(str(a).lower() for a in call.args) for call in mock_print.call_args_list)
+
+    def test_update_tasks_with_scheduling_info_warns_when_late(self):
+        task_info = {
+            "u": {"task": {"id": 1, "description": "late", "due": "20231201T000000Z"}, "scheduling": {"2023-12-05": 2.0}}
+        }
+        with patch("taskcheck.parallel.subprocess.run") as mock_run, patch("taskcheck.parallel.console.print") as mock_print:
+            from taskcheck.parallel import update_tasks_with_scheduling_info
+            update_tasks_with_scheduling_info(task_info, verbose=False, taskrc="/tmp/taskrc")
+        mock_run.assert_called_once()
+        assert mock_print.called

{taskcheck-1.0.0.post2 → taskcheck-1.1.0}/tests/test_report.py

@@ -111,6 +111,24 @@ class TestTaskFiltering:
         assert 'env' in call_args.kwargs
         assert call_args.kwargs['env']['TASKRC'] == test_taskrc
 
+    @patch('taskcheck.report.get_taskwarrior_date')
+    @patch('subprocess.run')
+    def test_get_unplanned_tasks_filters_due_horizon(self, mock_run, mock_date, sample_config, test_taskrc):
+        config = {**sample_config["report"], "unplanned_max_due": "30d"}
+        mock_date.return_value = datetime(2023, 12, 31)
+        mock_result = Mock()
+        mock_result.stdout = json.dumps([
+            {"id": 1, "description": "No deadline"},
+            {"id": 2, "description": "Due soon", "due": "20231215T120000Z"},
+            {"id": 3, "description": "Due later", "due": "20240115T120000Z"},
+        ])
+        mock_run.return_value = mock_result
+
+        result = get_unplanned_tasks(config, [], taskrc=test_taskrc)
+
+        assert [task["id"] for task in result] == [1, 2]
+        mock_date.assert_called_once_with("30d", taskrc=test_taskrc)
+
 
 class TestStringFormatting:
     def test_tostring_boolean(self):
@@ -197,7 +215,25 @@ class TestReportGeneration:
             }
         ]
         
-        # Should run without error
         generate_report(sample_config, "today", verbose=True, taskrc=test_taskrc)
         
         mock_unplanned.assert_called_once_with(sample_config["report"], [], taskrc=test_taskrc)
+
+    @patch('taskcheck.report.display_unplanned_tasks')
+    @patch('taskcheck.report.get_unplanned_tasks')
+    @patch('taskcheck.report.get_days_in_constraint')
+    @patch('taskcheck.report.fetch_tasks')
+    def test_generate_report_dry_run_keeps_unplanned_block(self, mock_fetch, mock_days, mock_unplanned, mock_display, sample_config, test_taskrc):
+        mock_fetch.return_value = [
+            {"id": 1, "description": "Planned", "scheduling": "2023-12-05 - PT2H", "urgency": 1.0, "project": "x"},
+            {"id": 2, "description": "No plan", "estimated": "", "urgency": 2.0, "project": "y"},
+        ]
+        mock_days.return_value = [(2023, 12, 5)]
+        mock_unplanned.return_value = [{"id": 2, "description": "No plan", "urgency": 2.0, "project": "y"}]
+        scheduling_results = [{"id": 1, "description": "Planned", "scheduling_hours": "PT2H", "project": "x", "urgency": 1.0, "scheduling": "2023-12-05 - PT2H"}]
+
+        generate_report(sample_config, "today", verbose=False, taskrc=test_taskrc, scheduling_results=scheduling_results)
+
+        mock_fetch.assert_called_once_with(test_taskrc)
+        mock_unplanned.assert_called_once_with(sample_config["report"], mock_fetch.return_value, taskrc=test_taskrc)
+        mock_display.assert_called_once()

taskcheck-1.0.0.post2/tests/test_ical.py

@@ -1,171 +0,0 @@
-import pytest
-from datetime import datetime, timedelta
-from unittest.mock import patch, Mock
-import json
-import tempfile
-
-from taskcheck.ical import (
-    fetch_ical_data,
-    parse_ical_events,
-    ical_to_dict,
-    get_cache_filename
-)
-
-
-class TestIcalFetching:
-    @patch('requests.get')
-    def test_fetch_ical_data_success(self, mock_get, mock_ical_response):
-        mock_response = Mock()
-        mock_response.text = mock_ical_response
-        mock_response.raise_for_status = Mock()
-        mock_get.return_value = mock_response
-        
-        result = fetch_ical_data("https://example.com/calendar.ics")
-        
-        assert result == mock_ical_response
-        mock_get.assert_called_once_with("https://example.com/calendar.ics")
-        
-    @patch('requests.get')
-    def test_fetch_ical_data_error(self, mock_get):
-        mock_response = Mock()
-        mock_response.raise_for_status.side_effect = Exception("HTTP Error")
-        mock_get.return_value = mock_response
-        
-        with pytest.raises(Exception):
-            fetch_ical_data("https://example.com/calendar.ics")
-
-
-class TestIcalParsing:
-    @patch('taskcheck.ical.datetime')
-    def test_parse_ical_events_simple(self, mock_datetime, mock_ical_response):
-        # Mock datetime.now() to return a date that makes the test events valid
-        mock_datetime.now.return_value = datetime(2023, 12, 1, 12, 0, 0)
-        mock_datetime.side_effect = lambda *args, **kw: datetime(*args, **kw)
-        
-        events = parse_ical_events(mock_ical_response, days_ahead=7, all_day=False)
-        
-        assert len(events) >= 1
-        for event in events:
-            assert "start" in event
-            assert "end" in event
-            assert isinstance(event["start"], str)
-            assert isinstance(event["end"], str)
-            
-    @patch('taskcheck.ical.datetime')
-    def test_parse_ical_events_with_timezone(self, mock_datetime, mock_ical_response):
-        mock_datetime.now.return_value = datetime(2023, 12, 1, 12, 0, 0)
-        mock_datetime.side_effect = lambda *args, **kw: datetime(*args, **kw)
-        
-        events = parse_ical_events(
-            mock_ical_response, 
-            days_ahead=7, 
-            all_day=False, 
-            tz_name="America/New_York"
-        )
-        
-        assert len(events) >= 0
-        
-    @patch('taskcheck.ical.datetime')
-    def test_parse_ical_events_recurring(self, mock_datetime):
-        mock_datetime.now.return_value = datetime(2023, 12, 1, 12, 0, 0)
-        mock_datetime.side_effect = lambda *args, **kw: datetime(*args, **kw)
-        
-        ical_with_recurring = """BEGIN:VCALENDAR
-VERSION:2.0
-PRODID:test
-BEGIN:VEVENT
-UID:recurring-event
-DTSTART:20231205T140000Z
-DTEND:20231205T150000Z
-SUMMARY:Weekly Meeting
-RRULE:FREQ=WEEKLY;COUNT=3
-END:VEVENT
-END:VCALENDAR"""
-        
-        events = parse_ical_events(ical_with_recurring, days_ahead=21, all_day=False)
-        
-        # Should have 3 occurrences
-        assert len(events) == 3
-        
-    @patch('taskcheck.ical.datetime')
-    def test_parse_ical_events_all_day(self, mock_datetime):
-        mock_datetime.now.return_value = datetime(2023, 12, 1, 12, 0, 0)
-        mock_datetime.side_effect = lambda *args, **kw: datetime(*args, **kw)
-        
-        ical_all_day = """BEGIN:VCALENDAR
-VERSION:2.0
-PRODID:test
-BEGIN:VEVENT
-UID:all-day-event
-DTSTART;VALUE=DATE:20231205
-DTEND;VALUE=DATE:20231206
-SUMMARY:All Day Event
-END:VEVENT
-END:VCALENDAR"""
-        
-        events_include = parse_ical_events(ical_all_day, days_ahead=7, all_day=True)
-        events_exclude = parse_ical_events(ical_all_day, days_ahead=7, all_day=False)
-        
-        assert len(events_include) >= len(events_exclude)
-
-
-class TestIcalCaching:
-    def test_get_cache_filename(self):
-        url = "https://example.com/calendar.ics"
-        filename = get_cache_filename(url)
-        
-        assert filename.suffix == ".json"
-        assert len(filename.stem) == 64  # SHA256 hash length
-        
-    @patch('requests.get')
-    def test_ical_to_dict_with_cache(self, mock_get, temp_cache_dir, mock_ical_response):
-        mock_response = Mock()
-        mock_response.text = mock_ical_response
-        mock_response.raise_for_status = Mock()
-        mock_get.return_value = mock_response
-        
-        url = "https://example.com/calendar.ics"
-        
-        # First call should fetch and cache
-        events1 = ical_to_dict(url, days_ahead=7, all_day=False, expiration=1.0)
-        
-        # Second call should use cache
-        events2 = ical_to_dict(url, days_ahead=7, all_day=False, expiration=1.0)
-        
-        assert events1 == events2
-        # Should only make one HTTP request
-        assert mock_get.call_count == 1
-        
-    @patch('requests.get')
-    def test_ical_to_dict_force_update(self, mock_get, temp_cache_dir, mock_ical_response):
-        mock_response = Mock()
-        mock_response.text = mock_ical_response
-        mock_response.raise_for_status = Mock()
-        mock_get.return_value = mock_response
-        
-        url = "https://example.com/calendar.ics"
-        
-        # First call
-        events1 = ical_to_dict(url, days_ahead=7, all_day=False, expiration=1.0)
-        
-        # Force update should bypass cache
-        events2 = ical_to_dict(url, days_ahead=7, all_day=False, expiration=1.0, force_update=True)
-        
-        assert events1 == events2
-        # Should make two HTTP requests
-        assert mock_get.call_count == 2
-
-
-class TestExceptionHandling:
-    @patch('requests.get')
-    def test_ical_to_dict_malformed_ical(self, mock_get, temp_cache_dir):
-        mock_response = Mock()
-        mock_response.text = "INVALID ICAL DATA"
-        mock_response.raise_for_status = Mock()
-        mock_get.return_value = mock_response
-        
-        url = "https://example.com/calendar.ics"
-        
-        # Should handle malformed iCal gracefully
-        with pytest.raises(Exception):
-            ical_to_dict(url, days_ahead=7, all_day=False)