pytaskwarrior 1.1.0__tar.gz → 1.2.0__tar.gz

{pytaskwarrior-1.1.0 → pytaskwarrior-1.2.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: pytaskwarrior
-Version: 1.1.0
+Version: 1.2.0
 Summary: Taskwarrior wrapper python module
 Author-email: sznicolas <sznicolas@users.noreply.github.com>
 License-Expression: MIT
@@ -34,15 +34,16 @@ Dynamic: license-file
 
 A modern Python wrapper for [TaskWarrior](https://taskwarrior.org/), the command-line task management tool.
 
-**v1.0.0**: Production-ready with 132 tests (96% coverage), strict type checking, and professional-grade code quality. Zero linting errors, full async-safe subprocess handling, and PEP 561 type hints for IDE support.
+Production-ready with 164 tests (96% coverage), strict type checking, and professional-grade code quality. Zero linting errors, full async-safe subprocess handling, PEP 561 type hints for IDE support, and a consistent exception hierarchy.
 
 ## Features
 
-- ✅ Full CRUD operations for tasks
-- ✅ Type-safe with Pydantic models
-- ✅ Context management
-- ✅ UDA (User Defined Attributes) support
-- ✅ Recurring tasks and annotations
+-  Full CRUD operations for tasks
+-  Type-safe with Pydantic models
+-  Context management
+-  UDA (User Defined Attributes) support
+-  Recurring tasks and annotations
+-  Consistent exception hierarchy (`TaskNotFound`, `TaskValidationError`, `TaskOperationError`, `TaskConfigurationError`, …)
 
 ## Requirements
 

{pytaskwarrior-1.1.0 → pytaskwarrior-1.2.0}/PYPI_README.md

@@ -9,15 +9,16 @@
 
 A modern Python wrapper for [TaskWarrior](https://taskwarrior.org/), the command-line task management tool.
 
-**v1.0.0**: Production-ready with 132 tests (96% coverage), strict type checking, and professional-grade code quality. Zero linting errors, full async-safe subprocess handling, and PEP 561 type hints for IDE support.
+Production-ready with 164 tests (96% coverage), strict type checking, and professional-grade code quality. Zero linting errors, full async-safe subprocess handling, PEP 561 type hints for IDE support, and a consistent exception hierarchy.
 
 ## Features
 
-- ✅ Full CRUD operations for tasks
-- ✅ Type-safe with Pydantic models
-- ✅ Context management
-- ✅ UDA (User Defined Attributes) support
-- ✅ Recurring tasks and annotations
+-  Full CRUD operations for tasks
+-  Type-safe with Pydantic models
+-  Context management
+-  UDA (User Defined Attributes) support
+-  Recurring tasks and annotations
+-  Consistent exception hierarchy (`TaskNotFound`, `TaskValidationError`, `TaskOperationError`, `TaskConfigurationError`, …)
 
 ## Requirements
 

{pytaskwarrior-1.1.0 → pytaskwarrior-1.2.0}/README.md

@@ -9,17 +9,17 @@
 
 A modern Python wrapper for [TaskWarrior](https://taskwarrior.org/) v3.4, the command-line task management tool.
 
-**v1.0.0**: Production-ready with 132 tests (96% coverage), strict type checking, and professional-grade code quality. Zero linting errors, full async-safe subprocess handling, and PEP 561 type hints for IDE support.
+**v1.2.0**: Production-ready with 164 tests (96% coverage), strict type checking, and professional-grade code quality. Zero linting errors, full async-safe subprocess handling, PEP 561 type hints for IDE support, and a consistent exception hierarchy.
 
 ## Features
 
-- ✅ **Full CRUD operations** - Create, read, update, delete tasks
-- ✅ **Type-safe** - Pydantic models with full type hints
-- ✅ **Context management** - Define, apply, and switch contexts
-- ✅ **UDA support** - User Defined Attributes
-- ✅ **Recurring tasks** - Full recurrence support
-- ✅ **Annotations** - Add notes to tasks
-- ✅ **Date calculations** - Use TaskWarrior's date expressions
+- **Full CRUD operations** - Create, read, update, delete tasks
+- **Type-safe** - Pydantic models with full type hints
+- **Context management** - Define, apply, and switch contexts
+- **UDA support** - User Defined Attributes
+- **Recurring tasks** - Full recurrence support
+- **Annotations** - Add notes to tasks
+- **Date calculations** - Use TaskWarrior's date expressions
 
 ## Requirements
 
@@ -31,7 +31,7 @@ A modern Python wrapper for [TaskWarrior](https://taskwarrior.org/) v3.4, the co
 ## Installation
 
 ```bash
-pip install pytaskwarrior==1.0.0
+pip install pytaskwarrior==1.2.0
 ```
 
 Or install from source:
@@ -140,6 +140,37 @@ tw = TaskWarrior(
 | `delete_context(name)` | Remove a context |
 | `has_context(name)` | Check if context exists |
 
+#### Synchronization Operations
+
+| Method | Description |
+|--------|-------------|
+| `is_sync_configured()` | Return `True` if any `sync.*` key is present in taskrc. |
+| `synchronize()` | Run `task sync`; raises `TaskSyncError` if not configured or sync fails. |
+
+### Exceptions
+
+All exceptions inherit from `TaskWarriorError` and are importable from the top-level package:
+
+```python
+from taskwarrior import (
+    TaskWarriorError,        # Base class — catch all library errors
+    TaskNotFound,            # Task does not exist
+    TaskValidationError,     # Invalid input data (empty description, etc.)
+    TaskOperationError,      # Operation failed on an existing task
+    TaskConfigurationError,  # Environment issue (binary not found, taskrc missing)
+    TaskSyncError,           # Synchronization failure
+)
+```
+
+| Exception | Raised when |
+|-----------|-------------|
+| `TaskWarriorError` | Base class; catch-all for any library error |
+| `TaskNotFound` | The requested task does not exist |
+| `TaskValidationError` | Input data is invalid (e.g., empty description) |
+| `TaskOperationError` | A write operation failed on an existing task (delete, done, start…) |
+| `TaskConfigurationError` | Environment error (binary not in PATH, taskrc missing/unreadable) |
+| `TaskSyncError` | Sync backend not configured or synchronization failed |
+
 ### Data Models
 
 #### TaskInputDTO
@@ -340,4 +371,3 @@ Contributions are welcome! Please feel free to submit a Pull Request.
 - [TaskWarrior](https://taskwarrior.org/) - The underlying task management tool
 - [GitHub Repository](https://github.com/sznicolas/pytaskwarrior/)
 - [PyPI Package](https://pypi.org/project/pytaskwarrior/)
-

{pytaskwarrior-1.1.0 → pytaskwarrior-1.2.0}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "pytaskwarrior"
-version = "1.1.0"
+version = "1.2.0"
 description = "Taskwarrior wrapper python module"
 readme = "PYPI_README.md"
 requires-python = ">=3.12"

{pytaskwarrior-1.1.0 → pytaskwarrior-1.2.0}/src/pytaskwarrior.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: pytaskwarrior
-Version: 1.1.0
+Version: 1.2.0
 Summary: Taskwarrior wrapper python module
 Author-email: sznicolas <sznicolas@users.noreply.github.com>
 License-Expression: MIT
@@ -34,15 +34,16 @@ Dynamic: license-file
 
 A modern Python wrapper for [TaskWarrior](https://taskwarrior.org/), the command-line task management tool.
 
-**v1.0.0**: Production-ready with 132 tests (96% coverage), strict type checking, and professional-grade code quality. Zero linting errors, full async-safe subprocess handling, and PEP 561 type hints for IDE support.
+Production-ready with 164 tests (96% coverage), strict type checking, and professional-grade code quality. Zero linting errors, full async-safe subprocess handling, PEP 561 type hints for IDE support, and a consistent exception hierarchy.
 
 ## Features
 
-- ✅ Full CRUD operations for tasks
-- ✅ Type-safe with Pydantic models
-- ✅ Context management
-- ✅ UDA (User Defined Attributes) support
-- ✅ Recurring tasks and annotations
+-  Full CRUD operations for tasks
+-  Type-safe with Pydantic models
+-  Context management
+-  UDA (User Defined Attributes) support
+-  Recurring tasks and annotations
+-  Consistent exception hierarchy (`TaskNotFound`, `TaskValidationError`, `TaskOperationError`, `TaskConfigurationError`, …)
 
 ## Requirements
 

{pytaskwarrior-1.1.0 → pytaskwarrior-1.2.0}/src/pytaskwarrior.egg-info/SOURCES.txt

@@ -15,6 +15,7 @@ src/taskwarrior/main.py
 src/taskwarrior/py.typed
 src/taskwarrior/adapters/__init__.py
 src/taskwarrior/adapters/taskwarrior_adapter.py
+src/taskwarrior/config/config_store.py
 src/taskwarrior/dto/__init__.py
 src/taskwarrior/dto/annotation_dto.py
 src/taskwarrior/dto/context_dto.py

{pytaskwarrior-1.1.0 → pytaskwarrior-1.2.0}/src/taskwarrior/__init__.py

@@ -39,6 +39,14 @@ from .dto.context_dto import ContextDTO
 from .dto.task_dto import TaskInputDTO, TaskOutputDTO
 from .dto.uda_dto import UdaConfig, UdaType
 from .enums import Priority, RecurrencePeriod, TaskStatus
+from .exceptions import (
+    TaskConfigurationError,
+    TaskNotFound,
+    TaskOperationError,
+    TaskSyncError,
+    TaskValidationError,
+    TaskWarriorError,
+)
 from .main import TaskWarrior
 from .registry.uda_registry import UdaRegistry
 from .utils.dto_converter import task_output_to_input
@@ -54,9 +62,15 @@ __all__ = [
     "Priority",
     "RecurrencePeriod",
     "TaskStatus",
+    "TaskConfigurationError",
     "TaskInputDTO",
+    "TaskNotFound",
+    "TaskOperationError",
     "TaskOutputDTO",
+    "TaskSyncError",
+    "TaskValidationError",
     "TaskWarrior",
+    "TaskWarriorError",
     "task_output_to_input",
     "UdaConfig",
     "UdaRegistry",

{pytaskwarrior-1.1.0 → pytaskwarrior-1.2.0}/src/taskwarrior/adapters/taskwarrior_adapter.py

@@ -5,37 +5,30 @@ This module provides the low-level interface to TaskWarrior CLI commands.
 
 import json
 import logging
-import os
 import re
 import shlex
 import shutil
 import subprocess
 from pathlib import Path
-from typing import TypedDict
 from uuid import UUID
 
+from ..config.config_store import ConfigStore
 from ..dto.task_dto import TaskInputDTO, TaskOutputDTO
 from ..enums import TaskStatus
-from ..exceptions import TaskNotFound, TaskValidationError, TaskWarriorError
+from ..exceptions import (
+    TaskConfigurationError,
+    TaskNotFound,
+    TaskOperationError,
+    TaskSyncError,
+    TaskValidationError,
+    TaskWarriorError,
+)
 
 logger = logging.getLogger(__name__)
 
-DEFAULT_OPTIONS = [
-    "rc.confirmation=off",
-    "rc.bulk=0",
-]
-
-
-class TaskWarriorInfo(TypedDict, total=False):
-    """Type definition for TaskWarrior configuration information."""
-
-    task_cmd: Path
-    taskrc_file: Path
-    options: list[str]
-    version: str
-
 
 class TaskWarriorAdapter:
+
     """Low-level adapter for TaskWarrior CLI commands.
 
     This class handles direct communication with the TaskWarrior binary,
@@ -44,65 +37,42 @@ class TaskWarriorAdapter:
 
     Attributes:
         task_cmd: Path to the TaskWarrior binary.
-        taskrc_file: Path to the taskrc configuration file.
-        data_location: Path to the task data directory.
     """
 
     def __init__(
         self,
+        config_store: ConfigStore,
         task_cmd: str = "task",
-        taskrc_file: str = "~/.taskrc",
-        data_location: str | None = None
     ):
         """Initialize the adapter.
 
         Args:
             task_cmd: TaskWarrior binary name or path.
-            taskrc_file: Path to taskrc file.
-            data_location: Path to data directory (optional).
+            config_store: The configuration store instance (required).
 
         Raises:
-            TaskValidationError: If TaskWarrior binary not found.
+            TaskConfigurationError: If TaskWarrior binary not found.
         """
+
         self.task_cmd: Path = self._check_binary_path(task_cmd)
-        self._options: list[str] = []
-        self.taskrc_file = Path(os.path.expandvars(taskrc_file)).expanduser()
-        self._options.extend([f"rc:{self.taskrc_file}"])
-        if data_location:
-            self.data_location: Path | None = Path(os.path.expandvars(data_location)).expanduser()
-            self._options.extend([f"rc.data.location={self.data_location}"])
-        else:
-            self.data_location = None
-        self._check_or_create_taskfiles()
+        self._cli_options: list[str] = config_store.cli_options
+        self._sync_configured: bool = bool(config_store.get_sync_config())
 
-        self._options.extend(DEFAULT_OPTIONS)
+    @property
+    def cli_options(self) -> list[str]:
+        """Public accessor for CLI options."""
+        return self._cli_options
 
     def _check_binary_path(self, task_cmd: str) -> Path:
         """Verify TaskWarrior binary exists in PATH."""
         resolved_path = shutil.which(task_cmd)
         if not resolved_path:
-            raise TaskValidationError(
-                f"TaskWarrior command '{task_cmd}' not found in PATH"
-            )
+            raise TaskConfigurationError(f"TaskWarrior command '{task_cmd}' not found in PATH")
         return Path(resolved_path)
 
-    def _check_or_create_taskfiles(self) -> None:
-        """Create taskrc and data directory if they don't exist."""
-        if not self.taskrc_file.exists():
-            default_content = """# Taskwarrior configuration file
-# This file was automatically created by pytaskwarrior
-# Default data location
-rc.data.location={data_location}
-# Disable confirmation prompts
-rc.confirmation=off
-rc.bulk=0
-""".format(data_location=self.data_location or "~/.task")
-            self.taskrc_file.parent.mkdir(parents=True, exist_ok=True)
-            self.taskrc_file.write_text(default_content)
-            logger.info(f"Created Taskrc file '{self.taskrc_file}'")
-        if self.data_location and not self.data_location.exists():
-            self.data_location.mkdir(parents=True, exist_ok=True)
-            logger.info(f"Created Task data direcory '{self.data_location}'")
+    def is_sync_configured(self) -> bool:
+        """Return True if sync settings are present in taskrc (any ``sync.*`` key)."""
+        return self._sync_configured
 
     def run_task_command(
         self, args: list[str], no_opt: bool = False
@@ -119,7 +89,7 @@ rc.bulk=0
         cmd = [str(self.task_cmd)]
         # Options (rc:...) must come before command and filter arguments so they are applied properly.
         if not no_opt:
-            cmd.extend(self._options)
+            cmd.extend(self._cli_options)
         cmd.extend(args)
         logger.debug(f"Running command: {' '.join(cmd)}")
 
@@ -144,7 +114,29 @@ rc.bulk=0
 
         except (OSError, subprocess.SubprocessError) as e:
             logger.error(f"Exception while running '{cmd}': {e}")
-            raise
+            raise TaskWarriorError(f"Command execution failed: {e}") from e
+
+    def synchronize(self) -> None:
+        """Synchronize tasks by running ``task sync``.
+
+        Delegates to the TaskWarrior CLI's built-in sync command, which handles
+        both local (``sync.local.server_dir``) and remote (``sync.server.origin``)
+        synchronization based on the taskrc configuration.
+
+        Raises:
+            TaskSyncError: If no sync settings are configured, or if the sync
+                command exits with a non-zero return code.
+        """
+        if not self._sync_configured:
+            raise TaskSyncError(
+                "No sync server is configured. "
+                "Add sync.* settings to your taskrc (e.g. sync.local.server_dir)."
+            )
+        result = self.run_task_command(["sync"])
+        if result.returncode != 0:
+            raise TaskSyncError(
+                f"Synchronization failed: {result.stderr or result.stdout}"
+            )
 
     @staticmethod
     def _wrap_filter(f: str) -> str:
@@ -225,7 +217,7 @@ rc.bulk=0
             if not tasks:
                 error_msg = "Failed to retrieve added task"
                 logger.error(error_msg)
-                raise RuntimeError(error_msg)
+                raise TaskWarriorError(error_msg)
             added_task = tasks[0]
 
         if task.annotations:
@@ -235,9 +227,7 @@ rc.bulk=0
         logger.info(f"Successfully added task with UUID: {added_task.uuid}")
         return added_task
 
-    def modify_task(
-        self, task: TaskInputDTO, task_id_or_uuid: str | int | UUID
-    ) -> TaskOutputDTO:
+    def modify_task(self, task: TaskInputDTO, task_id_or_uuid: str | int | UUID) -> TaskOutputDTO:
         """Modify an existing task. Returns the updated task."""
         logger.info(f"Modifying task with UUID: {task_id_or_uuid}")
 
@@ -247,15 +237,13 @@ rc.bulk=0
         if result.returncode != 0:
             error_msg = f"Failed to modify task: {result.stderr}"
             logger.error(error_msg)
-            raise TaskValidationError(error_msg)
+            raise TaskWarriorError(error_msg)
 
         updated_task = self.get_task(task_id_or_uuid)
         logger.info(f"Successfully modified task with UUID: {task_id_or_uuid}")
         return updated_task
 
-    def get_task(
-        self, task_id_or_uuid: str | int | UUID, filter_args: str = ""
-    ) -> TaskOutputDTO:
+    def get_task(self, task_id_or_uuid: str | int | UUID, filter_args: str = "") -> TaskOutputDTO:
         """Retrieve a single task by ID or UUID."""
         task_id_or_uuid = str(task_id_or_uuid)
         logger.debug(f"Retrieving task with ID/UUID: {task_id_or_uuid}")
@@ -279,12 +267,12 @@ rc.bulk=0
                     )
             except json.JSONDecodeError as e:
                 logger.error(f"Failed to parse JSON response: {e}")
-                raise TaskValidationError(
+                raise TaskWarriorError(
                     f"Invalid response from TaskWarrior: {result.stdout}"
                 ) from e
         else:
-            raise TaskWarriorError(
-                f"Error while retrieving task ID/UUID {task_id_or_uuid} not found"
+            raise TaskNotFound(
+                f"Task ID/UUID {task_id_or_uuid} not found"
             )
 
     def get_tasks(
@@ -342,17 +330,12 @@ rc.bulk=0
 
         try:
             tasks_data = json.loads(result.stdout)
-            tasks = [
-                TaskOutputDTO.model_validate(task_data) for task_data in tasks_data
-            ]
+            tasks = [TaskOutputDTO.model_validate(task_data) for task_data in tasks_data]
             logger.debug(f"Retrieved {len(tasks)} tasks")
             return tasks
         except json.JSONDecodeError as e:
             logger.error(f"Failed to parse JSON response: {e}")
-            raise TaskValidationError(
-                f"Invalid response from TaskWarrior: {result.stdout}"
-            ) from e
-
+            raise TaskWarriorError(f"Invalid response from TaskWarrior: {result.stdout}") from e
 
     def get_recurring_task(self, task_id_or_uuid: str | int | UUID) -> TaskOutputDTO:
         """Get the parent recurring task template."""
@@ -364,7 +347,13 @@ rc.bulk=0
         )
 
         if result.returncode == 0:
-            tasks_data = json.loads(result.stdout)
+            try:
+                tasks_data = json.loads(result.stdout)
+            except json.JSONDecodeError as e:
+                logger.error(f"Failed to parse JSON response: {e}")
+                raise TaskWarriorError(
+                    f"Invalid response from TaskWarrior: {result.stdout}"
+                ) from e
             if tasks_data:
                 task = TaskOutputDTO.model_validate(tasks_data[0])
                 logger.debug(f"Successfully retrieved recurring task: {task.uuid}")
@@ -375,9 +364,7 @@ rc.bulk=0
         )
         return self.get_task(task_id_or_uuid)
 
-    def get_recurring_instances(
-        self, task_id_or_uuid: str | int | UUID
-    ) -> list[TaskOutputDTO]:
+    def get_recurring_instances(self, task_id_or_uuid: str | int | UUID) -> list[TaskOutputDTO]:
         """Get all instances of a recurring task."""
         task_id_or_uuid = str(task_id_or_uuid)
         logger.debug(f"Getting recurring instances for parent UUID: {task_id_or_uuid}")
@@ -393,7 +380,7 @@ rc.bulk=0
                 return []
             error_msg = f"Failed to get recurring instances: {result.stderr}"
             logger.error(error_msg)
-            raise TaskNotFound(error_msg)
+            raise TaskWarriorError(error_msg)
 
         if not result.stdout.strip():
             logger.debug("No recurring instances returned (empty response)")
@@ -401,14 +388,12 @@ rc.bulk=0
 
         try:
             tasks_data = json.loads(result.stdout)
-            tasks = [
-                TaskOutputDTO.model_validate(task_data) for task_data in tasks_data
-            ]
+            tasks = [TaskOutputDTO.model_validate(task_data) for task_data in tasks_data]
             logger.debug(f"Retrieved {len(tasks)} recurring instances")
             return tasks
         except json.JSONDecodeError as e:
             logger.error(f"Failed to parse JSON response: {e}")
-            raise TaskNotFound(f"Invalid response from TaskWarrior: {result.stdout}") from e
+            raise TaskWarriorError(f"Invalid response from TaskWarrior: {result.stdout}") from e
 
     def delete_task(self, task_id_or_uuid: str | int | UUID) -> None:
         """Mark a task as deleted."""
@@ -420,7 +405,7 @@ rc.bulk=0
         if result.returncode != 0:
             error_msg = f"Failed to delete task: {result.stderr}"
             logger.error(error_msg)
-            raise TaskNotFound(error_msg)
+            raise TaskOperationError(error_msg)
 
         logger.info(f"Successfully deleted task: {task_ref}")
 
@@ -434,7 +419,7 @@ rc.bulk=0
         if result.returncode != 0:
             error_msg = f"Failed to purge task: {result.stderr}"
             logger.error(error_msg)
-            raise TaskNotFound(error_msg)
+            raise TaskOperationError(error_msg)
 
         logger.info(f"Successfully purged task: {task_ref}")
 
@@ -448,7 +433,7 @@ rc.bulk=0
         if result.returncode != 0:
             error_msg = f"Failed to mark task as done: {result.stderr}"
             logger.error(error_msg)
-            raise TaskNotFound(error_msg)
+            raise TaskOperationError(error_msg)
 
         logger.info(f"Successfully completed task: {task_ref}")
 
@@ -462,7 +447,7 @@ rc.bulk=0
         if result.returncode != 0:
             error_msg = f"Failed to start task: {result.stderr}"
             logger.error(error_msg)
-            raise TaskNotFound(error_msg)
+            raise TaskOperationError(error_msg)
 
         logger.info(f"Successfully started task: {task_ref}")
 
@@ -476,7 +461,7 @@ rc.bulk=0
         if result.returncode != 0:
             error_msg = f"Failed to stop task: {result.stderr}"
             logger.error(error_msg)
-            raise TaskNotFound(error_msg)
+            raise TaskOperationError(error_msg)
 
         logger.info(f"Successfully stopped task: {task_ref}")
 
@@ -491,26 +476,10 @@ rc.bulk=0
         if result.returncode != 0:
             error_msg = f"Failed to annotate task: {result.stderr}"
             logger.error(error_msg)
-            raise TaskNotFound(error_msg)
+            raise TaskOperationError(error_msg)
 
         logger.info(f"Successfully annotated task: {task_ref}")
 
-    def get_info(self) -> TaskWarriorInfo:
-        """Get TaskWarrior configuration and version info."""
-        info: TaskWarriorInfo = {
-            "task_cmd": self.task_cmd,
-            "taskrc_file": self.taskrc_file,
-            "options": self._options,
-        }
-
-        try:
-            version_result = self.run_task_command(["--version"], no_opt=True)
-            if version_result.returncode == 0 and version_result.stdout:
-                info["version"] = version_result.stdout.strip()
-        except Exception:
-            info["version"] = "unknown"
-        return info
-
     def task_calc(self, date_str: str) -> str:
         """Calculate a TaskWarrior date expression."""
         try:
@@ -535,6 +504,13 @@ rc.bulk=0
         except subprocess.SubprocessError:
             return False
 
+    def get_version(self) -> str:
+        """Return the TaskWarrior CLI version as a string."""
+        version_result = self.run_task_command(["--version"], no_opt=True)
+        if version_result.returncode == 0 and version_result.stdout:
+            return version_result.stdout.strip()
+        return "unknown"
+
     def get_projects(self) -> list[str]:
         """Get all projects defined in TaskWarrior.
 

pytaskwarrior-1.2.0/src/taskwarrior/config/config_store.py

@@ -0,0 +1,130 @@
+import os
+import re
+from pathlib import Path
+from typing import TYPE_CHECKING
+
+from ..exceptions import TaskConfigurationError
+
+if TYPE_CHECKING:
+    from ..dto.context_dto import ContextDTO
+
+DEFAULT_OPTIONS = [
+    "rc.confirmation=off",
+    "rc.bulk=0",
+]
+
+class ConfigStore:
+    """
+    Loads and caches Taskwarrior config from taskrc. Provides access methods and refresh capability.
+    """
+
+    def __init__(self, taskrc_path: str, data_location: str | None = None) -> None:
+        self._taskrc_path: Path = Path(os.path.expandvars(taskrc_path)).expanduser()
+        self._data_location: Path | None = Path(os.path.expandvars(data_location)).expanduser() if data_location else None
+        self._check_or_create_taskfiles()
+        self._config: dict[str, str] | None = None
+        self._load_config()
+
+    def _load_config(self) -> None:
+        self._config = self._extract_taskrc_config(self._taskrc_path)
+
+    def _check_or_create_taskfiles(self) -> None:
+        """Create taskrc and data directory if they don't exist."""
+        if not self._taskrc_path.exists():
+            default_content = f"""# Taskwarrior configuration file
+# This file was automatically created by pytaskwarrior
+# Default data location
+rc.data.location={self._data_location or '~/.task'}
+# Disable confirmation prompts
+rc.confirmation=off
+rc.bulk=0
+"""
+            self._taskrc_path.parent.mkdir(parents=True, exist_ok=True)
+            self._taskrc_path.write_text(default_content)
+        if self._data_location and not self._data_location.exists():
+            self._data_location.mkdir(parents=True, exist_ok=True)
+
+    def _extract_taskrc_config(self, path: Path) -> dict[str, str]:
+        import configparser
+
+        config: dict[str, str] = {}
+        parser = configparser.ConfigParser()
+        # Accept .taskrc files without section headers by adding a dummy section
+        try:
+            with open(path, encoding="utf-8") as f:
+                lines = f.readlines()
+        except FileNotFoundError as e:
+            raise TaskConfigurationError(f"Taskrc file not found: {path}") from e
+        except PermissionError as e:
+            raise TaskConfigurationError(f"Cannot read taskrc file (permission denied): {path}") from e
+        except OSError as e:
+            raise TaskConfigurationError(f"Failed to read taskrc file: {path}: {e}") from e
+        # Only keep blank lines, comments, or lines containing '=' (key-value)
+        filtered = [line for line in lines if line.strip() == "" or line.strip().startswith("#") or "=" in line]
+        content = "[taskrc]\n" + "".join(filtered)
+        parser.read_string(content)
+        for section in parser.sections():
+            for key, value in parser.items(section):
+                config[key] = value
+        for key in parser.defaults():
+            config[key] = parser.defaults()[key]
+        return config
+
+    def refresh(self) -> None:
+        """Reloads the config from disk."""
+        self._load_config()
+
+    @property
+    def config(self) -> dict[str, str]:
+        if self._config is None:
+            self._load_config()
+        assert self._config is not None
+        return self._config
+
+    @property
+    def taskrc_path(self) -> Path:
+        """Return the path to the taskrc file."""
+        return self._taskrc_path
+
+    @property
+    def cli_options(self) -> list[str]:
+        """Return CLI options for Taskwarrior commands, including defaults."""
+        options = [f"rc:{self._taskrc_path}"]
+        if self._data_location:
+            options.append(f"rc.data.location={self._data_location}")
+        options.extend(DEFAULT_OPTIONS)
+        return options
+
+    def get_sync_config(self) -> dict[str, str]:
+        # Extract sync config directly from self.config
+        # Accept both 'sync.' and 'taskrc.sync.' keys for compatibility
+        return {k: v for k, v in self.config.items() if k.startswith("sync.")}
+
+    def get_contexts_config(self) -> dict[str, str]:
+        # Extract context config directly from self.config
+        return {k: v for k, v in self.config.items() if k.startswith("context.")}
+
+    def get_contexts(self, current_context: str | None = None) -> list["ContextDTO"]:
+        """
+        Returns a list of ContextDTO objects representing all defined contexts.
+        """
+        from ..dto.context_dto import ContextDTO
+
+        contexts_config = self.get_contexts_config()
+        names: dict[str, dict[str, str]] = {}
+
+        for k, v in contexts_config.items():
+            m = re.match(r"context\.([^\.]+)\.(read|write)", k)
+            if m:
+                ctx_name = m.group(1)
+                kind = m.group(2)
+                names.setdefault(ctx_name, {})[kind] = v
+        return [
+            ContextDTO(
+                name=n,
+                read_filter=filters.get("read", ""),
+                write_filter=filters.get("write", ""),
+                active=(n == current_context),
+            )
+            for n, filters in names.items()
+        ]

{pytaskwarrior-1.1.0 → pytaskwarrior-1.2.0}/src/taskwarrior/exceptions.py

@@ -21,6 +21,14 @@ class TaskWarriorError(Exception):
     pass
 
 
+class TaskSyncError(TaskWarriorError):
+    """Raised when a synchronization error occurs in TaskWarrior.
+
+    This exception is used to signal errors encountered during sync operations.
+    """
+    pass
+
+
 class TaskNotFound(TaskWarriorError):  # noqa: N818
     """Raised when a requested task does not exist.
 
@@ -55,3 +63,41 @@ class TaskValidationError(TaskWarriorError):
     """
 
     pass
+
+
+class TaskConfigurationError(TaskWarriorError):
+    """Raised when a configuration or environment error is detected.
+
+    This exception is raised when:
+    - The TaskWarrior binary is not found in PATH
+    - The taskrc configuration file is missing or unreadable
+    - Required environment setup is invalid
+
+    Example:
+        >>> try:
+        ...     tw = TaskWarrior(task_cmd="nonexistent-binary")
+        ... except TaskConfigurationError as e:
+        ...     print(f"Configuration error: {e}")
+    """
+
+    pass
+
+
+class TaskOperationError(TaskWarriorError):
+    """Raised when a task operation fails on an existing task.
+
+    This exception is raised when a write operation (delete, complete, start,
+    stop, annotate, purge, modify) fails, for reasons other than the task not
+    being found. Examples:
+    - Marking an already-completed task as done
+    - Starting a task that is already active
+    - Annotating with an empty annotation text
+
+    Example:
+        >>> try:
+        ...     tw.done_task(uuid)
+        ... except TaskOperationError as e:
+        ...     print(f"Operation failed: {e}")
+    """
+
+    pass

{pytaskwarrior-1.1.0 → pytaskwarrior-1.2.0}/src/taskwarrior/main.py

@@ -7,9 +7,10 @@ from __future__ import annotations
 
 import logging
 import os
+from typing import Any
 from uuid import UUID
 
-from .adapters.taskwarrior_adapter import TaskWarriorAdapter, TaskWarriorInfo
+from .adapters.taskwarrior_adapter import TaskWarriorAdapter
 from .dto.context_dto import ContextDTO
 from .dto.task_dto import TaskInputDTO, TaskOutputDTO
 from .dto.uda_dto import UdaConfig
@@ -69,22 +70,26 @@ class TaskWarrior:
             task_cmd: Path or name of the TaskWarrior binary. Defaults to "task".
             taskrc_file: Path to the taskrc configuration file. If None, uses
                 the TASKRC environment variable or defaults to ~/.taskrc.
-            data_location: Path to the task data directory. If None, uses
-                the TASKDATA environment variable or the value in taskrc.
+            data_location: Optional path to TaskWarrior data directory. If None,
+                TASKDATA environment variable or taskrc value will be used.
 
         Raises:
-            TaskValidationError: If the TaskWarrior binary is not found.
+            TaskConfigurationError: If the TaskWarrior binary is not found.
         """
         if taskrc_file is None:
             taskrc_file = os.environ.get("TASKRC", "$HOME/.taskrc")
+
         if data_location is None:
-            data_location = os.environ.get("TASKDATA")
+            data_location = os.environ.get("TASKDATA", None)
+
+        from .config.config_store import ConfigStore
 
+        self.config_store = ConfigStore(taskrc_file, data_location)
         self.adapter: TaskWarriorAdapter = TaskWarriorAdapter(
-            task_cmd=task_cmd, taskrc_file=taskrc_file, data_location=data_location
+            task_cmd=task_cmd, config_store=self.config_store
         )
-        self.context_service: ContextService = ContextService(self.adapter)
-        self.uda_service: UdaService = UdaService(self.adapter)
+        self.context_service: ContextService = ContextService(self.adapter, self.config_store)
+        self.uda_service: UdaService = UdaService(self.adapter, self.config_store)
 
         # Auto-load UDA definitions from taskrc
         self.uda_service.load_udas_from_taskrc()
@@ -108,9 +113,7 @@ class TaskWarrior:
         """
         return self.adapter.add_task(task)
 
-    def modify_task(
-        self, task: TaskInputDTO, task_id_or_uuid: str | int | UUID
-    ) -> TaskOutputDTO:
+    def modify_task(self, task: TaskInputDTO, task_id_or_uuid: str | int | UUID) -> TaskOutputDTO:
         """Modify an existing task.
 
         Args:
@@ -163,6 +166,9 @@ class TaskWarrior:
         Deleted and completed tasks are excluded by default; use
         *include_completed* / *include_deleted* to override.
 
+        If a context is active, its read_filter is applied in addition to the
+        provided filter (combined with AND).
+
         Args:
             filter: TaskWarrior filter expression.  Examples::
 
@@ -180,8 +186,25 @@ class TaskWarrior:
         Raises:
             TaskWarriorError: If the query fails.
         """
+        # Combine the user-provided filter with the active context's read_filter
+        combined_filter = filter or ""
+        try:
+            current_context = self.get_current_context()
+            if current_context:
+                contexts = self.context_service.get_contexts()
+                active = next((c for c in contexts if c.active or c.name == current_context), None)
+                if active and active.read_filter:
+                    ctx_read = active.read_filter.strip()
+                    if combined_filter.strip():
+                        combined_filter = f"{ctx_read} and ({combined_filter})"
+                    else:
+                        combined_filter = ctx_read
+        except Exception as e:
+            # Do not fail listing due to context lookup issues — log and proceed
+            logger.debug("Failed to apply context read_filter to get_tasks(): %s", e)
+
         return self.adapter.get_tasks(
-            filter=filter,
+            filter=combined_filter,
             include_completed=include_completed,
             include_deleted=include_deleted,
         )
@@ -200,9 +223,7 @@ class TaskWarrior:
         """
         return self.adapter.get_recurring_task(task_id_or_uuid)
 
-    def get_recurring_instances(
-        self, task_id_or_uuid: str | int | UUID
-    ) -> list[TaskOutputDTO]:
+    def get_recurring_instances(self, task_id_or_uuid: str | int | UUID) -> list[TaskOutputDTO]:
         """Get all instances of a recurring task.
 
         Args:
@@ -225,7 +246,7 @@ class TaskWarrior:
             task_id_or_uuid: The task ID or UUID to delete.
 
         Raises:
-            TaskNotFound: If the task doesn't exist.
+            TaskOperationError: If the operation fails (e.g., task already deleted).
         """
         self.adapter.delete_task(task_id_or_uuid)
 
@@ -238,7 +259,7 @@ class TaskWarrior:
             task_id_or_uuid: The task ID or UUID to purge.
 
         Raises:
-            TaskNotFound: If the task doesn't exist.
+            TaskOperationError: If the operation fails (e.g., task was not deleted first).
         """
         self.adapter.purge_task(task_id_or_uuid)
 
@@ -249,7 +270,7 @@ class TaskWarrior:
             task_id_or_uuid: The task ID or UUID to complete.
 
         Raises:
-            TaskNotFound: If the task doesn't exist.
+            TaskOperationError: If the operation fails (e.g., task is already completed).
 
         Example:
             >>> tw.done_task(1)
@@ -266,7 +287,7 @@ class TaskWarrior:
             task_id_or_uuid: The task ID or UUID to start.
 
         Raises:
-            TaskNotFound: If the task doesn't exist.
+            TaskOperationError: If the operation fails (e.g., task is already started).
         """
         self.adapter.start_task(task_id_or_uuid)
 
@@ -279,7 +300,7 @@ class TaskWarrior:
             task_id_or_uuid: The task ID or UUID to stop.
 
         Raises:
-            TaskNotFound: If the task doesn't exist.
+            TaskOperationError: If the operation fails (e.g., task was not started).
         """
         self.adapter.stop_task(task_id_or_uuid)
 
@@ -293,7 +314,7 @@ class TaskWarrior:
             annotation: The annotation text to add.
 
         Raises:
-            TaskNotFound: If the task doesn't exist.
+            TaskOperationError: If the operation fails (e.g., task not found).
 
         Example:
             >>> tw.annotate_task(1, "Discussed with team, need more info")
@@ -390,18 +411,72 @@ class TaskWarrior:
         """
         return self.context_service.has_context(context)
 
-    def get_info(self) -> TaskWarriorInfo:
+    def is_sync_configured(self) -> bool:
+        """Return True if synchronization is configured for this TaskWarrior instance."""
+        return self.adapter.is_sync_configured()
+
+    def synchronize(self) -> None:
+        """Run TaskWarrior synchronization via ``task sync``.
+
+        Delegates to the TaskWarrior CLI's built-in sync command. Synchronization
+        settings (server address, credentials, or local path) must be configured
+        in the taskrc file before calling this method.
+
+        Raises:
+            TaskSyncError: If no sync backend is configured or synchronization fails.
+
+        Example:
+            >>> tw = TaskWarrior(taskrc_file="/path/to/.taskrc")
+            >>> tw.synchronize()  # requires sync.* settings in taskrc
+        """
+        self.adapter.synchronize()
+
+    def get_info(self) -> dict[str, Any]:
         """Get comprehensive TaskWarrior configuration information.
 
         Returns:
             Dictionary containing task_cmd path, taskrc_file path,
-            options, and TaskWarrior version.
+            options, TaskWarrior version, and active context information.
 
         Example:
             >>> info = tw.get_info()
             >>> print(info["version"])
         """
-        return self.adapter.get_info()
+        # Compose info from TaskWarrior instance, not adapter
+        info: dict[str, Any] = {
+            "task_cmd": str(self.adapter.task_cmd),
+            "taskrc_file": str(self.config_store.taskrc_path),
+            "options": self.adapter.cli_options,
+            "version": self.adapter.get_version(),
+        }
+
+        # Add current context information (name and details) if available.
+        current_context: str | None = None
+        current_context_details: dict[str, Any] | None = None
+        try:
+            current_context = self.get_current_context()
+            if current_context:
+                contexts = self.context_service.get_contexts()
+                active = next((c for c in contexts if c.active or c.name == current_context), None)
+                if active:
+                    current_context_details = {
+                        "name": active.name,
+                        "read_filter": active.read_filter,
+                        "write_filter": active.write_filter,
+                        "active": active.active,
+                    }
+        except Exception as e:
+            # Do not fail get_info() for context lookup issues — log and return None fields
+            logger.debug("Failed to retrieve current context for get_info(): %s", e)
+            current_context = None
+            current_context_details = None
+
+        info.update({
+            "current_context": current_context,
+            "current_context_details": current_context_details,
+        })
+
+        return info
 
     def task_calc(self, date_str: str) -> str:
         """Calculate a TaskWarrior date expression.

{pytaskwarrior-1.1.0 → pytaskwarrior-1.2.0}/src/taskwarrior/registry/uda_registry.py

@@ -10,7 +10,7 @@ from pathlib import Path
 
 from ..adapters.taskwarrior_adapter import TaskWarriorAdapter
 from ..dto.uda_dto import UdaConfig, UdaType
-from ..exceptions import TaskWarriorError
+from ..exceptions import TaskConfigurationError, TaskWarriorError
 
 
 class UdaRegistry:
@@ -92,7 +92,7 @@ class UdaRegistry:
                     raise TaskWarriorError(f"Error while parsing {name}: {str(e)}") from e
 
         except FileNotFoundError as e:
-            raise TaskWarriorError(f"Taskrc file not found: {taskrc_file}") from e
+            raise TaskConfigurationError(f"Taskrc file not found: {taskrc_file}") from e
         except Exception as e:
             raise TaskWarriorError(f"Error reading taskrc: {str(e)}") from e
 

{pytaskwarrior-1.1.0 → pytaskwarrior-1.2.0}/src/taskwarrior/services/context_service.py

@@ -4,11 +4,15 @@ This module provides the ContextService class for managing TaskWarrior
 contexts (named filters).
 """
 
-import re
+
+from typing import TYPE_CHECKING
 
 from ..adapters.taskwarrior_adapter import TaskWarriorAdapter
 from ..dto.context_dto import ContextDTO
-from ..exceptions import TaskWarriorError
+from ..exceptions import TaskValidationError, TaskWarriorError
+
+if TYPE_CHECKING:
+    from ..config.config_store import ConfigStore
 
 
 class ContextService:
@@ -29,17 +33,19 @@ class ContextService:
             tw.apply_context("work")
     """
 
-    def __init__(self, adapter: TaskWarriorAdapter):
+    def __init__(self, adapter: TaskWarriorAdapter, config_store: 'ConfigStore') -> None:
         """Initialize the context service.
 
         Args:
             adapter: The TaskWarriorAdapter to use for CLI commands.
+            config_store: The configuration store instance (required).
         """
         self.adapter: TaskWarriorAdapter = adapter
+        self.config_store = config_store
 
     def _validate_name(self, name: str) -> None:
         if not name or not name.strip():
-            raise TaskWarriorError("Context name cannot be empty")
+            raise TaskValidationError("Context name cannot be empty")
 
     def define_context(
         self, name: str, read_filter: str, write_filter: str
@@ -72,6 +78,7 @@ class ContextService:
             raise TaskWarriorError(
                 f"Failed to set write filter for context '{name}': {result.stderr}"
             )
+        self.config_store.refresh()
 
     def apply_context(self, name: str) -> None:
         """Apply a context, making it the active filter.
@@ -100,10 +107,11 @@ class ContextService:
             raise TaskWarriorError(f"Failed to unset context: {result.stderr}")
 
     def get_contexts(self) -> list[ContextDTO]:
-        """List all defined contexts with their read and write filters.
+        """Return list of ContextDTO by delegating to ConfigStore and marking active state.
 
-        Reads context.*.read and context.*.write entries directly from
-        .taskrc to guarantee correctness regardless of CLI output format.
+        The ConfigStore returns ContextDTO instances; this wrapper simply forwards them.
+        """
+        """List all defined contexts with their read and write filters.
 
         Returns:
             List of ContextDTO objects (name, read_filter, write_filter, active).
@@ -113,30 +121,7 @@ class ContextService:
         """
         try:
             current = self.get_current_context()
-            taskrc_path = self.adapter.taskrc_file
-            content = taskrc_path.read_text(encoding="utf-8")
-
-            # Collect all context.*.read entries as canonical source of truth
-            names: dict[str, dict[str, str]] = {}
-            for m in re.finditer(
-                r"^\s*context\.([^.\s]+)\.(read|write)\s*=\s*(.*)",
-                content,
-                re.MULTILINE,
-            ):
-                ctx_name = m.group(1)
-                kind = m.group(2)
-                value = m.group(3).strip()
-                names.setdefault(ctx_name, {})[kind] = value
-
-            return [
-                ContextDTO(
-                    name=n,
-                    read_filter=filters.get("read", ""),
-                    write_filter=filters.get("write", ""),
-                    active=(n == current),
-                )
-                for n, filters in names.items()
-            ]
+            return self.config_store.get_contexts(current_context=current)
         except Exception as e:
             raise TaskWarriorError(f"Error retrieving contexts: {str(e)}") from e
 
@@ -173,6 +158,7 @@ class ContextService:
             raise TaskWarriorError(
                 f"Failed to delete context '{name}': {result.stderr}"
             )
+        self.config_store.refresh()
 
     def has_context(self, name: str) -> bool:
         """Check if a context with the given name exists.

{pytaskwarrior-1.1.0 → pytaskwarrior-1.2.0}/src/taskwarrior/services/uda_service.py

@@ -3,10 +3,15 @@
 This module provides the UdaService class for managing custom task attributes.
 """
 
+from typing import TYPE_CHECKING
+
 from ..adapters.taskwarrior_adapter import TaskWarriorAdapter
 from ..dto.uda_dto import UdaConfig
 from ..registry.uda_registry import UdaRegistry
 
+if TYPE_CHECKING:
+    from ..config.config_store import ConfigStore
+
 
 class UdaService:
     """Service for managing User Defined Attributes (UDAs).
@@ -27,13 +32,16 @@ class UdaService:
             tw.uda_service.define_uda(uda)
     """
 
-    def __init__(self, adapter: TaskWarriorAdapter):
+    def __init__(self, adapter: TaskWarriorAdapter, config_store: 'ConfigStore') -> None:
         """Initialize the UDA service.
 
         Args:
             adapter: The TaskWarriorAdapter to use for CLI commands.
+            config_store: The configuration store instance (required).
         """
+
         self.adapter = adapter
+        self.config_store = config_store
         self.registry = UdaRegistry()
 
     def load_udas_from_taskrc(self) -> None:
@@ -42,7 +50,7 @@ class UdaService:
         Parses the taskrc file to discover and register any UDAs
         that have been previously defined.
         """
-        self.registry.load_from_taskrc(self.adapter.taskrc_file)
+        self.registry.load_from_taskrc(self.config_store._taskrc_path)
 
     def define_uda(self, uda: UdaConfig) -> None:
         """Define a new UDA in TaskWarrior.

{pytaskwarrior-1.1.0 → pytaskwarrior-1.2.0}/src/taskwarrior/utils/conversions.py

@@ -41,6 +41,9 @@ def parse_taskwarrior_date(value: str) -> datetime:
             # Try standard parsing
             return datetime.fromisoformat(value.replace("Z", "+00:00"))
     except ValueError:
-        # If parsing fails, try to parse as ISO format
-        return datetime.fromisoformat(value)
+        # If parsing fails, try without timezone suffix
+        try:
+            return datetime.fromisoformat(value)
+        except ValueError as e:
+            raise ValueError(f"Cannot parse TaskWarrior date: {value!r}") from e