pytaskwarrior 1.2.0__tar.gz → 2.0.0__tar.gz

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: pytaskwarrior
-Version: 1.2.0
+Version: 2.0.0
 Summary: Taskwarrior wrapper python module
 Author-email: sznicolas <sznicolas@users.noreply.github.com>
 License-Expression: MIT

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

@@ -9,7 +9,7 @@
 
 A modern Python wrapper for [TaskWarrior](https://taskwarrior.org/) v3.4, the command-line task management tool.
 
-**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.
+**v2.0.0**: Major release with breaking API changes (Context.define now accepts ContextDTO; UdaConfig.type → UdaConfig.uda_type). All tests passing and documentation updated.
 
 ## Features
 
@@ -31,7 +31,7 @@ A modern Python wrapper for [TaskWarrior](https://taskwarrior.org/) v3.4, the co
 ## Installation
 
 ```bash
-pip install pytaskwarrior==1.2.0
+pip install pytaskwarrior==2.0.0
 ```
 
 Or install from source:
@@ -132,7 +132,7 @@ tw = TaskWarrior(
 
 | Method | Description |
 |--------|-------------|
-| `define_context(name, read_filter, write_filter)` | Create a context with read and write filters |
+| `define_context(ctx: ContextDTO)` | Create a context from a ContextDTO (name, read_filter, write_filter) |
 | `apply_context(name)` | Activate a context |
 | `unset_context()` | Deactivate current context |
 | `get_contexts()` | List all contexts |
@@ -144,7 +144,7 @@ tw = TaskWarrior(
 
 | Method | Description |
 |--------|-------------|
-| `is_sync_configured()` | Return `True` if any `sync.*` key is present in taskrc. |
+| `is_sync_configured()` | Return `True` if any `sync.*` key is present in configuration (ConfigStore). |
 | `synchronize()` | Run `task sync`; raises `TaskSyncError` if not configured or sync fails. |
 
 ### Exceptions
@@ -244,9 +244,10 @@ RecurrencePeriod.YEARLY
 ### Working with Contexts
 
 ```python
+from taskwarrior import ContextDTO
 # Define contexts for different workflows
-tw.define_context("work", read_filter="project:work or +urgent", write_filter="project:work or +urgent")
-tw.define_context("home", read_filter="project:home or project:personal", write_filter="project:home or project:personal")
+tw.define_context(ContextDTO(name="work", read_filter="project:work or +urgent", write_filter="project:work or +urgent"))
+tw.define_context(ContextDTO(name="home", read_filter="project:home or project:personal", write_filter="project:home or project:personal"))
 
 # Switch to work context
 tw.apply_context("work")

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

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

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: pytaskwarrior
-Version: 1.2.0
+Version: 2.0.0
 Summary: Taskwarrior wrapper python module
 Author-email: sznicolas <sznicolas@users.noreply.github.com>
 License-Expression: MIT

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

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

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

@@ -76,4 +76,3 @@ __all__ = [
     "UdaRegistry",
     "UdaType",
 ]
-

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

@@ -28,7 +28,6 @@ logger = logging.getLogger(__name__)
 
 
 class TaskWarriorAdapter:
-
     """Low-level adapter for TaskWarrior CLI commands.
 
     This class handles direct communication with the TaskWarrior binary,
@@ -134,9 +133,7 @@ class TaskWarriorAdapter:
             )
         result = self.run_task_command(["sync"])
         if result.returncode != 0:
-            raise TaskSyncError(
-                f"Synchronization failed: {result.stderr or result.stdout}"
-            )
+            raise TaskSyncError(f"Synchronization failed: {result.stderr or result.stdout}")
 
     @staticmethod
     def _wrap_filter(f: str) -> str:
@@ -267,13 +264,9 @@ class TaskWarriorAdapter:
                     )
             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
+                raise TaskWarriorError(f"Invalid response from TaskWarrior: {result.stdout}") from e
         else:
-            raise TaskNotFound(
-                f"Task ID/UUID {task_id_or_uuid} not found"
-            )
+            raise TaskNotFound(f"Task ID/UUID {task_id_or_uuid} not found")
 
     def get_tasks(
         self,
@@ -351,9 +344,7 @@ class TaskWarriorAdapter:
                 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
+                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}")

{pytaskwarrior-1.2.0 → pytaskwarrior-2.0.0}/src/taskwarrior/config/config_store.py

@@ -7,12 +7,14 @@ from ..exceptions import TaskConfigurationError
 
 if TYPE_CHECKING:
     from ..dto.context_dto import ContextDTO
+    from ..dto.uda_dto import UdaConfig
 
 DEFAULT_OPTIONS = [
     "rc.confirmation=off",
     "rc.bulk=0",
 ]
 
+
 class ConfigStore:
     """
     Loads and caches Taskwarrior config from taskrc. Provides access methods and refresh capability.
@@ -20,7 +22,9 @@ class ConfigStore:
 
     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._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()
@@ -34,7 +38,7 @@ class ConfigStore:
             default_content = f"""# Taskwarrior configuration file
 # This file was automatically created by pytaskwarrior
 # Default data location
-rc.data.location={self._data_location or '~/.task'}
+rc.data.location={self._data_location or "~/.task"}
 # Disable confirmation prompts
 rc.confirmation=off
 rc.bulk=0
@@ -56,11 +60,17 @@ rc.bulk=0
         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
+            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]
+        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():
@@ -128,3 +138,15 @@ rc.bulk=0
             )
             for n, filters in names.items()
         ]
+
+    def get_udas(self) -> list["UdaConfig"]:
+        """
+        Parse and return UDAs from the cached config mapping.
+
+        Returns a list of UdaConfig objects representing UDAs defined in the
+        TaskWarrior configuration. Uses the shared uda_parser to perform parsing.
+        """
+        # Local import to avoid module import cycles
+        from .uda_parser import parse_udas_from_mapping
+
+        return parse_udas_from_mapping(self.config)

pytaskwarrior-2.0.0/src/taskwarrior/config/uda_parser.py

@@ -0,0 +1,65 @@
+"""Parser utilities to convert TaskWarrior config mappings into UdaConfig DTOs.
+
+This module centralizes the logic that converts a mapping of configuration
+keys (as produced by ConfigStore.config) into UdaConfig DTOs.
+"""
+
+from __future__ import annotations
+
+from ..dto.uda_dto import UdaConfig, UdaType
+from ..exceptions import TaskWarriorError
+
+
+def parse_udas_from_mapping(config: dict[str, str]) -> list[UdaConfig]:
+    """Parse UDA definitions from a config mapping.
+
+    Accepts keys like 'uda.<name>.<attr>' or 'taskrc.uda.<name>.<attr>'.
+    Returns a list of UdaConfig objects.
+
+    Raises TaskWarriorError on parsing errors.
+    """
+    uda_groups: dict[str, dict[str, str]] = {}
+    for key, value in config.items():
+        if not key:
+            continue
+        k = key.strip()
+        # normalize 'taskrc.' prefix if present
+        if k.startswith("taskrc."):
+            k = k[len("taskrc.") :]
+        if not k.startswith("uda."):
+            continue
+        parts = k.split(".")
+        if len(parts) < 3:
+            continue
+        name, attr = parts[1], parts[2]
+        uda_groups.setdefault(name, {})[attr] = value
+
+    udas: list[UdaConfig] = []
+    for name, attrs in uda_groups.items():
+        try:
+            converted_attrs: dict[str, object] = {}
+            for attr, val in attrs.items():
+                if attr == "type":
+                    try:
+                        converted_attrs["uda_type"] = UdaType(val)
+                    except ValueError:
+                        converted_attrs["uda_type"] = UdaType(val.lower())
+                elif attr == "values":
+                    converted_attrs["values"] = [v.strip() for v in val.split(",")] if val else []
+                elif attr == "coefficient":
+                    try:
+                        converted_attrs["coefficient"] = float(val)
+                    except (TypeError, ValueError):
+                        converted_attrs["coefficient"] = None
+                elif attr == "label":
+                    converted_attrs["label"] = val
+                elif attr == "default":
+                    converted_attrs["default"] = val
+                else:
+                    converted_attrs[attr] = val
+
+            uda = UdaConfig(name=name, **converted_attrs)  # type: ignore[arg-type]
+            udas.append(uda)
+        except Exception as e:
+            raise TaskWarriorError(f"Error while parsing UDA '{name}': {e}") from e
+    return udas

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

@@ -2,4 +2,4 @@ from .annotation_dto import AnnotationDTO
 from .context_dto import ContextDTO
 from .task_dto import TaskInputDTO, TaskOutputDTO
 
-__all__ = ['AnnotationDTO', 'ContextDTO', 'TaskInputDTO', 'TaskOutputDTO']
+__all__ = ["AnnotationDTO", "ContextDTO", "TaskInputDTO", "TaskOutputDTO"]

{pytaskwarrior-1.2.0 → pytaskwarrior-2.0.0}/src/taskwarrior/dto/annotation_dto.py

@@ -30,9 +30,7 @@ class AnnotationDTO(BaseModel):
                 print(f"{annotation.entry}: {annotation.description}")
     """
 
-    entry: datetime = Field(
-        description="Annotation creation date and time (ISO format)"
-    )
+    entry: datetime = Field(description="Annotation creation date and time (ISO format)")
     description: str = Field(description="Annotation description")
 
     model_config = {"populate_by_name": True, "extra": "forbid"}

{pytaskwarrior-1.2.0 → pytaskwarrior-2.0.0}/src/taskwarrior/dto/task_dto.py

@@ -69,15 +69,11 @@ class TaskInputDTO(BaseModel):
             )
     """
 
-    description: str | None = Field(
-        default=None, description="Task description (optional)."
-    )
+    description: str | None = Field(default=None, description="Task description (optional).")
     priority: Priority | None = Field(
         default=None, description="Priority of the task (H, M, L, or empty)"
     )
-    due: str | None = Field(
-        default=None, description="Due date and time for the task (ISO format)"
-    )
+    due: str | None = Field(default=None, description="Due date and time for the task (ISO format)")
     project: str | None = Field(default=None, description="Project the task belongs to")
     tags: list[str] = Field(
         default_factory=list, description="List of tags associated with the task"

{pytaskwarrior-1.2.0 → pytaskwarrior-2.0.0}/src/taskwarrior/dto/uda_dto.py

@@ -26,7 +26,7 @@ class UdaType(str, Enum):
 
     Example:
         >>> from taskwarrior.dto.uda_dto import UdaConfig, UdaType
-        >>> uda = UdaConfig(name="severity", type=UdaType.STRING)
+        >>> uda = UdaConfig(name="severity", uda_type=UdaType.STRING)
     """
 
     STRING = "string"
@@ -40,11 +40,11 @@ class UdaConfig(BaseModel):
     """Data Transfer Object for User Defined Attributes (UDAs).
 
     UDAs extend TaskWarrior with custom fields. Each UDA has a name,
-    type, and optional configuration like allowed values or defaults.
+    uda_type, and optional configuration like allowed values or defaults.
 
     Attributes:
         name: Unique name for the UDA (used as the field name).
-        type: Data type of the UDA value.
+        uda_type: Data type of the UDA value.
         label: Human-readable label for display in reports.
         values: List of allowed values (for string type with enumeration).
         default: Default value when not specified.
@@ -56,7 +56,7 @@ class UdaConfig(BaseModel):
 
             uda = UdaConfig(
                 name="severity",
-                type=UdaType.STRING,
+                uda_type=UdaType.STRING,
                 label="Severity",
                 values=["low", "medium", "high", "critical"],
                 default="medium",
@@ -66,7 +66,7 @@ class UdaConfig(BaseModel):
     """
 
     name: str = Field(..., description="Name of the UDA")
-    type: UdaType = Field(..., description="Data type of the UDA")
+    uda_type: UdaType = Field(..., description="Data type of the UDA")
     label: str | None = Field(default=None, description="Display label for the UDA")
     values: list[str] | None = Field(
         default=None, description="Allowed values for the UDA (for string types)"

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

@@ -26,6 +26,7 @@ class TaskSyncError(TaskWarriorError):
 
     This exception is used to signal errors encountered during sync operations.
     """
+
     pass
 
 

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

@@ -91,8 +91,9 @@ class TaskWarrior:
         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()
+        # Auto-load UDA definitions from the configured store
+        # Use the service to orchestrate loading and registry population
+        self.uda_service.load_udas_from_store()
 
     def add_task(self, task: TaskInputDTO) -> TaskOutputDTO:
         """Add a new task to TaskWarrior.
@@ -321,25 +322,19 @@ class TaskWarrior:
         """
         self.adapter.annotate_task(task_id_or_uuid, annotation)
 
-    def define_context(self, context: str, read_filter: str, write_filter: str) -> None:
-        """Define a new context with explicit read and write filters.
+    def define_context(self, context) -> None:
+        """Define a new context from a ContextDTO.
 
-        Both filters are required. Use an empty string for write_filter
-        if you want a read-only context (new tasks won't inherit a project).
+        The context argument must be a ContextDTO instance containing
+        name, read_filter and write_filter.
 
         Args:
-            context:      Name of the context to create.
-            read_filter:  Filter applied when listing/querying tasks.
-            write_filter: Filter applied when creating or modifying tasks.
+            context: ContextDTO instance with the context definition.
 
         Raises:
             TaskWarriorError: If context creation fails.
-
-        Example:
-            >>> tw.define_context("work", read_filter="project:work", write_filter="project:work")
-            >>> tw.define_context("review", read_filter="+urgent or priority:H", write_filter="")
         """
-        self.context_service.define_context(context, read_filter, write_filter)
+        self.context_service.define_context(context)
 
     def apply_context(self, context: str) -> None:
         """Activate a context.
@@ -471,10 +466,12 @@ class TaskWarrior:
             current_context = None
             current_context_details = None
 
-        info.update({
-            "current_context": current_context,
-            "current_context_details": current_context_details,
-        })
+        info.update(
+            {
+                "current_context": current_context,
+                "current_context_details": current_context_details,
+            }
+        )
 
         return info
 
@@ -526,7 +523,7 @@ class TaskWarrior:
             >>> tw.reload_udas()
             >>> names = tw.get_uda_names()
         """
-        self.uda_service.load_udas_from_taskrc()
+        self.uda_service.load_udas_from_store()
 
     def get_uda_names(self) -> set[str]:
         """Get all defined UDA names.

pytaskwarrior-2.0.0/src/taskwarrior/registry/uda_registry.py

@@ -0,0 +1,70 @@
+"""Registry for User Defined Attributes (UDAs).
+
+This module provides the UdaRegistry class for tracking and managing UDA definitions.
+
+The registry no longer performs direct file I/O. UDA discovery is performed
+via ConfigStore (ConfigStore.get_udas()) or by passing an in-memory config
+mapping to `load_from_config`.
+"""
+
+from __future__ import annotations
+
+from ..dto.uda_dto import UdaConfig
+
+
+class UdaRegistry:
+    """Registry for User Defined Attributes (UDAs).
+
+    This class maintains a registry of UDA definitions loaded from in-memory
+    configuration mappings or provided by a ConfigStore instance. It intentionally
+    avoids performing direct file I/O to keep concerns separated.
+
+    Example:
+        >>> registry = UdaRegistry()
+        >>> registry.load_from_config({"uda.example.type": "string"})
+        >>> names = registry.get_uda_names()
+    """
+
+    def __init__(self) -> None:
+        self._udas: dict[str, UdaConfig] = {}
+
+    def register_udas(self, udas: list[UdaConfig]) -> None:
+        """Register a list of UdaConfig objects into the registry."""
+        for uda in udas:
+            self._udas[uda.name] = uda
+
+    def load_from_config(self, config: dict[str, str]) -> None:
+        """Load UDA definitions from an in-memory config mapping.
+
+        The config mapping should contain keys like 'uda.<name>.<attr>'.
+        This avoids direct file I/O and allows using ConfigStore.config.
+        """
+        # Local import to avoid module import cycles
+        from ..config.uda_parser import parse_udas_from_mapping
+
+        udas = parse_udas_from_mapping(config)
+        self.register_udas(udas)
+
+    def add_uda(self, uda: UdaConfig) -> None:
+        """Add a UDA definition to the in-memory registry (no side effects)."""
+        self._udas[uda.name] = uda
+
+    def update_uda(self, uda: UdaConfig) -> None:
+        """Update an existing UDA definition in the registry (no side effects)."""
+        self._udas[uda.name] = uda
+
+    def remove_uda(self, name: str) -> None:
+        """Remove a UDA definition from the registry by name (no side effects)."""
+        self._udas.pop(name, None)
+
+    def get_uda(self, name: str) -> UdaConfig | None:
+        """Get a UDA definition by name."""
+        return self._udas.get(name)
+
+    def get_uda_names(self) -> set[str]:
+        """Get all registered UDA names."""
+        return set(self._udas.keys())
+
+    def is_uda_field(self, field_name: str) -> bool:
+        """Check if a field name corresponds to a registered UDA."""
+        return field_name in self._udas

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

@@ -4,7 +4,6 @@ This module provides the ContextService class for managing TaskWarrior
 contexts (named filters).
 """
 
-
 from typing import TYPE_CHECKING
 
 from ..adapters.taskwarrior_adapter import TaskWarriorAdapter
@@ -29,11 +28,11 @@ class ContextService:
         This service is typically accessed via TaskWarrior::
 
             tw = TaskWarrior()
-            tw.define_context("work", read_filter="project:work", write_filter="project:work")
+            tw.define_context(ContextDTO(name="work", read_filter="project:work", write_filter="project:work"))
             tw.apply_context("work")
     """
 
-    def __init__(self, adapter: TaskWarriorAdapter, config_store: 'ConfigStore') -> None:
+    def __init__(self, adapter: TaskWarriorAdapter, config_store: "ConfigStore") -> None:
         """Initialize the context service.
 
         Args:
@@ -47,37 +46,38 @@ class ContextService:
         if not name or not name.strip():
             raise TaskValidationError("Context name cannot be empty")
 
-    def define_context(
-        self, name: str, read_filter: str, write_filter: str
-    ) -> None:
-        """Create or update a context with explicit read and write filters.
+    def define_context(self, ctx: ContextDTO) -> None:
+        """Create or update a context from a ContextDTO.
 
         TaskWarrior stores read and write filters separately in .taskrc.
-        Both must be provided — there is no implicit default.
+        The ContextDTO supplies both read_filter and write_filter explicitly.
 
         Args:
-            name:         Unique context name.
-            read_filter:  Filter applied when listing/querying tasks.
-            write_filter: Filter applied when creating or modifying tasks.
+            ctx: ContextDTO containing name, read_filter, and write_filter.
 
         Raises:
             TaskWarriorError: If the name is empty or creation fails.
 
         Example:
-            >>> service.define_context("work", read_filter="project:work", write_filter="project:work")
-            >>> service.define_context("urgent", read_filter="+urgent", write_filter="")  # read-only filter
+            >>> svc.define_context(ContextDTO(name="work", read_filter="project:work", write_filter="project:work"))
         """
-        self._validate_name(name)
-        result = self.adapter.run_task_command(["context", "define", name, read_filter])
-        if result.returncode != 0:
-            raise TaskWarriorError(f"Failed to define context '{name}': {result.stderr}")
-        result = self.adapter.run_task_command(
-            ["config", f"context.{name}.write", write_filter]
-        )
-        if result.returncode != 0:
-            raise TaskWarriorError(
-                f"Failed to set write filter for context '{name}': {result.stderr}"
-            )
+        self._validate_name(ctx.name)
+        # Collect commands to be executed
+        commands = [
+            ["context", "define", ctx.name, ctx.read_filter],
+            ["config", f"context.{ctx.name}.write", ctx.write_filter],
+        ]
+
+        # Execute all commands through the adapter
+        for cmd in commands:
+            result = self.adapter.run_task_command(cmd)
+            if result.returncode != 0:
+                if cmd[0] == "context" and cmd[1] == "define":
+                    raise TaskWarriorError(f"Failed to define context '{ctx.name}': {result.stderr}")
+                elif cmd[0] == "config":
+                    raise TaskWarriorError(
+                        f"Failed to set write filter for context '{ctx.name}': {result.stderr}"
+                    )
         self.config_store.refresh()
 
     def apply_context(self, name: str) -> None:
@@ -153,11 +153,10 @@ class ContextService:
             TaskWarriorError: If the name is empty or deletion fails.
         """
         self._validate_name(name)
+        # Execute command through the adapter
         result = self.adapter.run_task_command(["context", "delete", name])
         if result.returncode != 0:
-            raise TaskWarriorError(
-                f"Failed to delete context '{name}': {result.stderr}"
-            )
+            raise TaskWarriorError(f"Failed to delete context '{name}': {result.stderr}")
         self.config_store.refresh()
 
     def has_context(self, name: str) -> bool:

pytaskwarrior-2.0.0/src/taskwarrior/services/uda_service.py

@@ -0,0 +1,109 @@
+"""User Defined Attributes (UDA) service for TaskWarrior.
+
+This module provides the UdaService class for managing custom task attributes.
+"""
+
+from typing import TYPE_CHECKING
+
+if TYPE_CHECKING:
+    from ..config.config_store import ConfigStore
+
+from ..adapters.taskwarrior_adapter import TaskWarriorAdapter
+from ..dto.uda_dto import UdaConfig
+from ..exceptions import TaskOperationError
+from ..registry.uda_registry import UdaRegistry
+
+
+class UdaService:
+    """Service for managing User Defined Attributes (UDAs).
+
+    UDAs allow extending TaskWarrior with custom fields. This service
+    provides methods to define, update, and delete UDAs, delegating
+    the actual work to UdaRegistry.
+
+    Attributes:
+        adapter: The TaskWarriorAdapter instance for CLI communication.
+        registry: The UdaRegistry for tracking defined UDAs.
+
+    Example:
+        This service is typically accessed via TaskWarrior::
+
+            tw = TaskWarrior()
+            uda = UdaConfig(name="severity", uda_type=UdaType.STRING)
+            tw.uda_service.define_uda(uda)
+    """
+
+    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_store(self) -> None:
+        """Load existing UDA definitions from the configured ConfigStore.
+
+        This method delegates parsing to ConfigStore.get_udas() and registers
+        the resulting UdaConfig objects in the registry (in-memory only).
+        """
+        udas = self.config_store.get_udas()
+        self.registry.register_udas(udas)
+
+    def define_uda(self, uda: UdaConfig) -> None:
+        """Define a new UDA in TaskWarrior and register it locally.
+
+        The service executes the required `task config` commands via the adapter
+        and only updates the registry if all commands succeed.
+        """
+        # Build commands to define the UDA
+        field_names = uda.__class__.model_fields.keys() - {"name"}
+        # uda_type is handled first
+        commands: list[list[str]] = [["config", f"uda.{uda.name}.type", uda.uda_type.value]]
+        field_names -= {"uda_type"}
+
+        for field_name in field_names:
+            value = getattr(uda, field_name)
+            if value is not None and value != "":
+                commands.append(["config", f"uda.{uda.name}.{field_name}", str(value)])
+
+        # Execute commands via adapter; if any fail, raise and do not modify registry
+        for cmd in commands:
+            result = self.adapter.run_task_command(cmd)
+            if getattr(result, "returncode", 0) != 0:
+                stderr = str(getattr(result, "stderr", ""))
+                raise TaskOperationError(f"Failed to run task command: {cmd} -> {stderr}")
+
+        # On success, update registry
+        self.registry.add_uda(uda)
+
+    def update_uda(self, uda: UdaConfig) -> None:
+        """Update an existing UDA in TaskWarrior and in the registry.
+
+        Executes commands via adapter and updates the registry on success.
+        """
+        # For now, same as define_uda
+        self.define_uda(uda)
+
+    def delete_uda(self, uda: UdaConfig) -> None:
+        """Delete a UDA from TaskWarrior and remove it from the registry.
+
+        Executes `task config <key>` without a value to remove each UDA key.
+        """
+        field_names = uda.__class__.model_fields.keys()
+        for key in field_names:
+            cmd = ["config", f"uda.{uda.name}.{key}"]
+            result = self.adapter.run_task_command(cmd)
+            if getattr(result, "returncode", 0) != 0:
+                stderr = str(getattr(result, "stderr", ""))
+                # tolerate missing keys (idempotent deletion)
+                if "no entry named" in stderr.lower():
+                    continue
+                raise TaskOperationError(f"Failed to run task command: {cmd} -> {stderr}")
+
+        # On success, remove from registry
+        self.registry.remove_uda(uda.name)

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

@@ -46,4 +46,3 @@ def parse_taskwarrior_date(value: str) -> datetime:
             return datetime.fromisoformat(value)
         except ValueError as e:
             raise ValueError(f"Cannot parse TaskWarrior date: {value!r}") from e
-

{pytaskwarrior-1.2.0 → pytaskwarrior-2.0.0}/src/taskwarrior/utils/dto_converter.py

@@ -29,7 +29,18 @@ def task_output_to_input(task_output: TaskOutputDTO) -> TaskInputDTO:
         >>> tw.modify_task(input_dto, uuid)
     """
     data = task_output.model_dump(
-        exclude={"uuid", "entry", "start", "end", "modified", "index", "status", "urgency", "imask", "rtype"}
+        exclude={
+            "uuid",
+            "entry",
+            "start",
+            "end",
+            "modified",
+            "index",
+            "status",
+            "urgency",
+            "imask",
+            "rtype",
+        }
     )
     # Convert datetime fields to strings as required by TaskInputDTO
     datetime_fields = ["due", "scheduled", "wait", "until"]

pytaskwarrior-1.2.0/src/taskwarrior/registry/uda_registry.py

@@ -1,168 +0,0 @@
-"""Registry for User Defined Attributes (UDAs).
-
-This module provides the UdaRegistry singleton class for tracking
-and managing UDA definitions.
-"""
-
-from __future__ import annotations
-
-from pathlib import Path
-
-from ..adapters.taskwarrior_adapter import TaskWarriorAdapter
-from ..dto.uda_dto import UdaConfig, UdaType
-from ..exceptions import TaskConfigurationError, TaskWarriorError
-
-
-class UdaRegistry:
-    """Registry for User Defined Attributes (UDAs).
-
-    This class maintains a registry of UDA definitions, loaded from
-    the taskrc file or defined programmatically. Each instance has its
-    own isolated state, making it safe to use with multiple TaskWarrior
-    instances.
-
-    Attributes:
-        _udas: Dictionary mapping UDA names to their definitions.
-
-    Example:
-        >>> registry = UdaRegistry()
-        >>> registry.load_from_taskrc("~/.taskrc")
-        >>> names = registry.get_uda_names()
-    """
-
-    def __init__(self) -> None:
-        self._udas: dict[str, UdaConfig] = {}
-
-    def load_from_taskrc(self, taskrc_file: str | Path) -> None:
-        """Load UDA definitions from a taskrc file.
-
-        Parses the taskrc file to find all `uda.*` configuration lines
-        and creates UdaConfig objects for each discovered UDA.
-
-        Args:
-            taskrc_file: Path to the taskrc configuration file.
-
-        Raises:
-            TaskWarriorError: If the file doesn't exist or parsing fails.
-
-        Example:
-            >>> registry.load_from_taskrc("/path/to/.taskrc")
-        """
-        self._udas = {}
-        try:
-            with open(taskrc_file) as f:
-                content = f.read()
-            # Find all uda.* lines
-            uda_lines = [
-                line.strip()
-                for line in content.splitlines()
-                if line.strip().startswith("uda.")
-            ]
-            # Group by UDA name
-            uda_groups: dict[str, dict[str, str]] = {}
-            for line in uda_lines:
-                if "=" not in line:
-                    continue
-                key, value = line.split("=", 1)
-                parts = key.split(".")
-                if len(parts) < 3:
-                    continue
-                name, attr = parts[1], parts[2]
-                if name not in uda_groups:
-                    uda_groups[name] = {}
-                uda_groups[name][attr] = value.strip()
-
-            # Convert to UdaConfig objects
-            for name, attrs in uda_groups.items():
-                try:
-                    # Convert type string to UdaType enum
-                    converted_attrs: dict[str, object] = {}
-                    for key, value in attrs.items():
-                        if key == "type":
-                            converted_attrs[key] = UdaType(value)
-                        elif key == "values":
-                            converted_attrs[key] = value.split(",") if value else []
-                        elif key == "default":
-                            converted_attrs[key] = value
-                        else:
-                            converted_attrs[key] = value
-
-                    self._udas[name] = UdaConfig(name=name, **converted_attrs)  # type: ignore[arg-type]
-                except Exception as e:
-                    raise TaskWarriorError(f"Error while parsing {name}: {str(e)}") from e
-
-        except FileNotFoundError as 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
-
-    def define_update_uda(self, uda: UdaConfig, adapter: TaskWarriorAdapter) -> None:
-        """Define or update a UDA in TaskWarrior configuration.
-
-        Uses `task config` commands to set UDA properties and
-        updates the local registry.
-
-        Args:
-            uda: The UDA definition to create or update.
-            adapter: The TaskWarriorAdapter for executing commands.
-        """
-        # Get all field names from UdaConfig
-        field_names = uda.__class__.model_fields.keys() - {"name"}
-        # Process the type
-        field_names -= {"type"}
-        adapter.run_task_command(
-            ["config", f"uda.{uda.name}.type", uda.type.value]
-        )
-
-        # Process each field that has a value
-        for field_name in field_names:
-            value = getattr(uda, field_name)
-            if value is not None and value != "":
-                config_key = f"uda.{uda.name}.{field_name}"
-                adapter.run_task_command(["config", config_key, str(value)])
-        self._udas.update({uda.name: uda})
-
-    def delete_uda(self, uda: UdaConfig, adapter: TaskWarriorAdapter) -> None:
-        """Delete a UDA from TaskWarrior configuration.
-
-        Clears all UDA configuration entries and removes it from the registry.
-
-        Args:
-            uda: The UDA to delete.
-            adapter: The TaskWarriorAdapter for executing commands.
-        """
-        # Clear all UDA configuration entries by setting them to empty strings
-        field_names = uda.__class__.model_fields.keys()
-        for key in field_names:
-            adapter.run_task_command(["config", f"uda.{uda.name}.{key}"])
-        self._udas.pop(uda.name)
-
-    def get_uda(self, name: str) -> UdaConfig | None:
-        """Get a UDA definition by name.
-
-        Args:
-            name: The name of the UDA to retrieve.
-
-        Returns:
-            The UdaConfig if found, None otherwise.
-        """
-        return self._udas.get(name)
-
-    def get_uda_names(self) -> set[str]:
-        """Get all registered UDA names.
-
-        Returns:
-            Set of UDA names currently in the registry.
-        """
-        return set(self._udas.keys())
-
-    def is_uda_field(self, field_name: str) -> bool:
-        """Check if a field name corresponds to a registered UDA.
-
-        Args:
-            field_name: The field name to check.
-
-        Returns:
-            True if the field is a registered UDA, False otherwise.
-        """
-        return field_name in self._udas

pytaskwarrior-1.2.0/src/taskwarrior/services/uda_service.py

@@ -1,92 +0,0 @@
-"""User Defined Attributes (UDA) service for TaskWarrior.
-
-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).
-
-    UDAs allow extending TaskWarrior with custom fields. This service
-    provides methods to define, update, and delete UDAs, delegating
-    the actual work to UdaRegistry.
-
-    Attributes:
-        adapter: The TaskWarriorAdapter instance for CLI communication.
-        registry: The UdaRegistry for tracking defined UDAs.
-
-    Example:
-        This service is typically accessed via TaskWarrior::
-
-            tw = TaskWarrior()
-            uda = UdaConfig(name="severity", type=UdaType.STRING)
-            tw.uda_service.define_uda(uda)
-    """
-
-    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:
-        """Load existing UDA definitions from the taskrc file.
-
-        Parses the taskrc file to discover and register any UDAs
-        that have been previously defined.
-        """
-        self.registry.load_from_taskrc(self.config_store._taskrc_path)
-
-    def define_uda(self, uda: UdaConfig) -> None:
-        """Define a new UDA in TaskWarrior.
-
-        Creates the UDA configuration in TaskWarrior and registers
-        it in the local registry.
-
-        Args:
-            uda: The UDA definition to create.
-
-        Example:
-            >>> uda = UdaConfig(
-            ...     name="severity",
-            ...     type=UdaType.STRING,
-            ...     values=["low", "medium", "high"]
-            ... )
-            >>> service.define_uda(uda)
-        """
-        self.registry.define_update_uda(uda, self.adapter)
-
-    def update_uda(self, uda: UdaConfig) -> None:
-        """Update an existing UDA definition.
-
-        Modifies the UDA configuration in TaskWarrior.
-
-        Args:
-            uda: The updated UDA definition.
-        """
-        self.registry.define_update_uda(uda, self.adapter)
-
-    def delete_uda(self, uda: UdaConfig) -> None:
-        """Delete a UDA from TaskWarrior.
-
-        Removes the UDA configuration and unregisters it.
-
-        Args:
-            uda: The UDA to delete.
-        """
-        self.registry.delete_uda(uda, self.adapter)