pytaskwarrior 3.0.0a2__tar.gz → 3.0.0a5__tar.gz

{pytaskwarrior-3.0.0a2/src/pytaskwarrior.egg-info → pytaskwarrior-3.0.0a5}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: pytaskwarrior
-Version: 3.0.0a2
+Version: 3.0.0a5
 Summary: Taskwarrior wrapper python module
 Author-email: sznicolas <sznicolas@users.noreply.github.com>
 License-Expression: MIT
@@ -21,7 +21,7 @@ Requires-Python: >=3.12
 Description-Content-Type: text/markdown
 License-File: LICENSE
 Requires-Dist: pydantic>=2.11.7
-Requires-Dist: taskchampion3-py-dev>=3.0.1.1a0
+Requires-Dist: taskchampion3-py-dev>=3.0.1.2a1
 Dynamic: license-file
 
 # pytaskwarrior

{pytaskwarrior-3.0.0a2 → pytaskwarrior-3.0.0a5}/README.md

@@ -88,6 +88,30 @@ tw = TaskWarrior(
 )
 ```
 
+### Live configuration updates
+
+`config_store` is the live interface to the taskrc file.  Changes made via
+`set_value()` or `set_sync_config()` are immediately effective on the next
+adapter call — no restart or adapter recreation required.
+
+```python
+tw = TaskWarrior()
+
+# Configure remote sync at runtime
+tw.config_store.set_value("sync.server.origin", "https://sync.example.com")
+tw.config_store.set_value("sync.encryption.secret", "my-passphrase")
+tw.synchronize()  # uses the new config immediately
+
+# Or replace the whole sync block at once
+tw.config_store.set_sync_config({
+    "sync.local.server_dir": "/mnt/shared/taskserver",
+})
+tw.synchronize()
+```
+
+> **Note:** Changing `data_location` at runtime is not supported.  Create a
+> new `TaskWarrior` instance if you need a different data directory.
+
 ## Architecture
 
 ```

{pytaskwarrior-3.0.0a2 → pytaskwarrior-3.0.0a5}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "pytaskwarrior"
-version = "3.0.0a2"
+version = "3.0.0a5"
 description = "Taskwarrior wrapper python module"
 readme = "PYPI_README.md"
 requires-python = ">=3.12"
@@ -21,8 +21,7 @@ classifiers = [
 ]
 dependencies = [
     "pydantic>=2.11.7",
-    #    "taskchampion-py-dev>=3.0.1.1a1"
-    "taskchampion3-py-dev>=3.0.1.1a0",
+    "taskchampion3-py-dev>=3.0.1.2a1",
 ]
 
 [dependency-groups]

{pytaskwarrior-3.0.0a2 → pytaskwarrior-3.0.0a5/src/pytaskwarrior.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: pytaskwarrior
-Version: 3.0.0a2
+Version: 3.0.0a5
 Summary: Taskwarrior wrapper python module
 Author-email: sznicolas <sznicolas@users.noreply.github.com>
 License-Expression: MIT
@@ -21,7 +21,7 @@ Requires-Python: >=3.12
 Description-Content-Type: text/markdown
 License-File: LICENSE
 Requires-Dist: pydantic>=2.11.7
-Requires-Dist: taskchampion3-py-dev>=3.0.1.1a0
+Requires-Dist: taskchampion3-py-dev>=3.0.1.2a1
 Dynamic: license-file
 
 # pytaskwarrior

pytaskwarrior-3.0.0a5/src/pytaskwarrior.egg-info/requires.txt

@@ -0,0 +1,2 @@
+pydantic>=2.11.7
+taskchampion3-py-dev>=3.0.1.2a1

{pytaskwarrior-3.0.0a2 → pytaskwarrior-3.0.0a5}/src/taskwarrior/adapters/taskchampion_adapter.py

@@ -11,6 +11,16 @@ Usage::
     dto = adapter.add_task(TaskInputDTO(description="Buy milk"))
     print(dto.uuid, dto.index)
 
+Live configuration updates
+--------------------------
+Pass a :class:`~taskwarrior.config.config_store.ConfigStore` instance to keep
+sync parameters in sync with the taskrc file at all times::
+
+    adapter = TaskChampionAdapter(config_store=my_config_store)
+    # Later — no adapter recreation required:
+    my_config_store.set_value("sync.server.origin", "https://sync.example.com")
+    adapter.synchronize()  # picks up the new URL automatically
+
 Limitations vs :class:`~taskwarrior.adapters.taskwarrior_adapter.TaskWarriorAdapter`
 -------------------------------------------------------------------------------------
 * :meth:`task_calc` raises :exc:`NotImplementedError` — no TW date parser.
@@ -19,7 +29,7 @@ Limitations vs :class:`~taskwarrior.adapters.taskwarrior_adapter.TaskWarriorAdap
   supported; see :mod:`~taskwarrior.adapters.tc_filter` for what is.
 * Urgency is always ``None`` (not computed).
 * UDA config / context support requires separate configuration.
-* Sync requires ``sync_server_url`` (remote) or ``sync_local_server_dir`` (local directory).
+* Changing ``data_location`` at runtime requires creating a new adapter instance.
 """
 
 from __future__ import annotations
@@ -37,6 +47,7 @@ from uuid import UUID
 
 from taskchampion import AccessMode, Annotation, Operations, Replica, Status
 
+from ..config.config_store import ConfigStore
 from ..dto.task_dto import TaskInputDTO, TaskOutputDTO
 from ..dto.task_id import TaskRef, to_taskid
 from ..exceptions import (
@@ -105,7 +116,8 @@ class TaskChampionAdapter:
     data_location:
         Path to the taskchampion data directory (the one that contains
         ``task.sqlite``).  Pass ``None`` to use a temporary in-memory
-        database (useful for tests).
+        database (useful for tests).  When *config_store* is supplied and
+        *data_location* is omitted, ``config_store.data_location`` is used.
     create_if_missing:
         When *data_location* is given, create the directory / DB if absent.
     access_mode:
@@ -113,18 +125,36 @@ class TaskChampionAdapter:
         ``AccessMode.ReadOnly`` for read-only access, which is safe to use
         from multiple concurrent threads or processes (SQLite WAL allows
         many concurrent readers alongside a single writer).
+    config_store:
+        When provided, sync parameters (server URL, client ID, encryption
+        secret, local server dir) are **read lazily** from the store on every
+        :meth:`synchronize` call.  This means that a
+        ``config_store.set_value(…)`` call is immediately reflected the next
+        time sync is invoked — no adapter recreation required.  This is the
+        recommended mode when the adapter is created via
+        :class:`~taskwarrior.main.TaskWarrior`.
     sync_server_url:
         Remote taskchampion sync server URL (``sync.server.origin`` in taskrc).
-        When set, :meth:`synchronize` will use ``sync_to_remote``.
+        Used only when *config_store* is ``None``.
     sync_client_id:
         Client identifier sent to the sync server.  A random UUID is used
         when not supplied (not recommended — prefer persisting in taskrc).
+        Used only when *config_store* is ``None``.
     sync_encryption_secret:
         Encryption secret for the remote sync server.
+        Used only when *config_store* is ``None``.
     sync_local_server_dir:
         Local directory used as a sync server (``sync.local.server_dir`` in
         taskrc).  When set, :meth:`synchronize` will use ``sync_to_local``.
         Takes precedence over *sync_server_url*.
+        Used only when *config_store* is ``None``.
+
+    Note
+    ----
+    Changing ``data_location`` at runtime requires creating a new
+    :class:`TaskChampionAdapter` instance because the underlying
+    :class:`taskchampion.Replica` (SQLite connection) is opened once at
+    construction time.
 
     Thread safety
     -------------
@@ -166,6 +196,7 @@ class TaskChampionAdapter:
         data_location: str | Path | None = None,
         create_if_missing: bool = True,
         access_mode: AccessMode = AccessMode.ReadWrite,
+        config_store: ConfigStore | None = None,
         sync_server_url: str | None = None,
         sync_client_id: str | None = None,
         sync_encryption_secret: str | None = None,
@@ -174,14 +205,25 @@ class TaskChampionAdapter:
         self._owner_thread_id = threading.current_thread().ident
         self._db_lock = threading.Lock()
         self._metrics = AdapterMetrics()
-        if data_location is None:
+
+        # When a ConfigStore is provided it becomes the live source of truth for
+        # sync parameters; they are re-read on every sync() call so that
+        # config_store.set_value() changes take effect without recreating the adapter.
+        self._config_store: ConfigStore | None = config_store
+
+        effective_data_location = (
+            config_store.data_location if (config_store is not None and data_location is None) else data_location
+        )
+
+        if effective_data_location is None:
             self._replica = Replica.new_in_memory()
             self._data_location: str | None = None
         else:
-            resolved = str(Path(data_location).expanduser())
+            resolved = str(Path(effective_data_location).expanduser())
             self._replica = Replica.new_on_disk(resolved, create_if_missing, access_mode)
             self._data_location = resolved
 
+        # Legacy / direct-construction params (used when config_store is None).
         self._sync_local_server_dir = sync_local_server_dir
         self._sync_server_url = sync_server_url
         self._sync_client_id = sync_client_id or str(_uuid.uuid4())
@@ -486,22 +528,36 @@ class TaskChampionAdapter:
         self._locked_call(self._synchronize_internal)
 
     def _synchronize_internal(self) -> None:
-        if not self._sync_configured:
+        if self._config_store is not None:
+            cfg = self._config_store.get_sync_config()
+            sync_local = cfg.get("sync.local.server_dir")
+            sync_url = cfg.get("sync.server.origin")
+            sync_client_id = cfg.get("sync.server.client_id") or self._sync_client_id
+            sync_secret = cfg.get("sync.encryption.secret") or ""
+            is_configured = bool(sync_local or sync_url)
+        else:
+            sync_local = self._sync_local_server_dir
+            sync_url = self._sync_server_url
+            sync_client_id = self._sync_client_id
+            sync_secret = self._sync_encryption_secret
+            is_configured = self._sync_configured
+
+        if not is_configured:
             raise TaskSyncError(
                 "No sync server configured. "
                 "Pass sync_local_server_dir or sync_server_url to TaskChampionAdapter()."
             )
         try:
-            if self._sync_local_server_dir:
+            if sync_local:
                 self._replica.sync_to_local(
-                    str(Path(self._sync_local_server_dir).expanduser()),
+                    str(Path(sync_local).expanduser()),
                     _AVOID_SNAPSHOTS,
                 )
             else:
                 self._replica.sync_to_remote(
-                    self._sync_server_url,
-                    self._sync_client_id,
-                    self._sync_encryption_secret,
+                    sync_url,
+                    sync_client_id,
+                    sync_secret,
                     _AVOID_SNAPSHOTS,
                 )
             logger.info("Sync completed")
@@ -510,6 +566,9 @@ class TaskChampionAdapter:
 
     def is_sync_configured(self) -> bool:
         """Return ``True`` if a sync server URL was provided."""
+        if self._config_store is not None:
+            cfg = self._config_store.get_sync_config()
+            return bool(cfg.get("sync.server.origin") or cfg.get("sync.local.server_dir"))
         return self._sync_configured
 
     def has_local_changes(self) -> bool:
@@ -586,17 +645,27 @@ class TaskChampionAdapter:
 
     def get_sync_info(self) -> dict[str, str | None]:
         """Return sync configuration details."""
-        if self._sync_local_server_dir:
+        if self._config_store is not None:
+            cfg = self._config_store.get_sync_config()
+            sync_url = cfg.get("sync.server.origin")
+            sync_local = cfg.get("sync.local.server_dir")
+            sync_client_id = cfg.get("sync.server.client_id")
+        else:
+            sync_url = self._sync_server_url
+            sync_local = self._sync_local_server_dir
+            sync_client_id = self._sync_client_id if self._sync_server_url else None
+
+        if sync_local:
             sync_backend: str | None = "local"
-        elif self._sync_server_url:
+        elif sync_url:
             sync_backend = "remote"
         else:
             sync_backend = None
         return {
             "sync_backend": sync_backend,
-            "sync_server_url": self._sync_server_url,
-            "sync_local_server_dir": self._sync_local_server_dir,
-            "sync_client_id": self._sync_client_id if self._sync_server_url else None,
+            "sync_server_url": sync_url,
+            "sync_local_server_dir": sync_local,
+            "sync_client_id": sync_client_id,
         }
 
     def get_projects(self) -> list[str]:

{pytaskwarrior-3.0.0a2 → pytaskwarrior-3.0.0a5}/src/taskwarrior/adapters/taskwarrior_adapter.py

@@ -33,9 +33,11 @@ from ..utils.virtual_tags import TASKWARRIOR_VIRTUAL_TAG_SET, TASKWARRIOR_VIRTUA
 class TaskWarriorAdapter:
     """Low-level adapter for TaskWarrior CLI commands.
 
-    This class handles direct communication with the TaskWarrior binary,
-    including command execution, argument building, and response parsing.
-    It is used internally by the TaskWarrior facade class.
+    Communicates with the TaskWarrior binary via subprocess.  Configuration
+    (CLI options, data location, sync settings) is read **lazily** from the
+    injected :class:`~taskwarrior.config.config_store.ConfigStore` on every
+    call, so a ``config_store.set_value(…)`` change is automatically reflected
+    without recreating the adapter.
 
     Attributes:
         task_cmd: Path to the TaskWarrior binary.
@@ -49,22 +51,23 @@ class TaskWarriorAdapter:
         """Initialize the adapter.
 
         Args:
+            config_store: Live configuration store.  CLI options, data
+                location, and sync settings are re-read from this store on
+                every operation so that runtime changes to the taskrc are
+                immediately effective.
             task_cmd: TaskWarrior binary name or path.
-            config_store: The configuration store instance (required).
 
         Raises:
             TaskConfigurationError: If TaskWarrior binary not found.
         """
 
         self.task_cmd: Path = self._check_binary_path(task_cmd)
-        self._cli_options: list[str] = config_store.cli_options
-        self._sync_configured: bool = bool(config_store.get_sync_config())
-        self._data_location: str = str(config_store.data_location)
+        self._config_store: ConfigStore = config_store
 
     @property
     def cli_options(self) -> list[str]:
-        """Public accessor for CLI options."""
-        return self._cli_options
+        """Public accessor for CLI options (always reflects current config)."""
+        return self._config_store.cli_options
 
     def _check_binary_path(self, task_cmd: str) -> Path:
         """Verify TaskWarrior binary exists in PATH."""
@@ -75,7 +78,7 @@ class TaskWarriorAdapter:
 
     def is_sync_configured(self) -> bool:
         """Return True if sync settings are present in taskrc (any ``sync.*`` key)."""
-        return self._sync_configured
+        return bool(self._config_store.get_sync_config())
 
     def has_local_changes(self) -> bool:
         """Always returns ``False`` for the CLI adapter.
@@ -109,7 +112,7 @@ class TaskWarriorAdapter:
         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._cli_options)
+            cmd.extend(self._config_store.cli_options)
         cmd.extend(args)
         logger.debug(f"Running command: {' '.join(cmd)}")
 
@@ -147,7 +150,7 @@ class TaskWarriorAdapter:
             TaskSyncError: If no sync settings are configured, or if the sync
                 command exits with a non-zero return code.
         """
-        if not self._sync_configured:
+        if not self.is_sync_configured():
             raise TaskSyncError(
                 "No sync server is configured. "
                 "Add sync.* settings to your taskrc (e.g. sync.local.server_dir)."
@@ -500,7 +503,7 @@ class TaskWarriorAdapter:
 
     def get_data_location(self) -> str | None:
         """Return the TaskWarrior data directory path."""
-        return self._data_location
+        return str(self._config_store.data_location)
 
     def get_projects(self) -> list[str]:
         """Get all projects defined in TaskWarrior.

{pytaskwarrior-3.0.0a2 → pytaskwarrior-3.0.0a5}/src/taskwarrior/config/config_store.py

@@ -126,6 +126,60 @@ rc.bulk=0
         # Accept both 'sync.' and 'taskrc.sync.' keys for compatibility
         return {k: v for k, v in self.config.items() if k.startswith("sync.")}
 
+    def set_sync_config(self, config: dict[str, str | None]) -> None:
+        """Write (or clear) the ``sync.*`` section of the taskrc file.
+
+        This is the write-symmetric counterpart of :meth:`get_sync_config`.  It
+        **replaces** the current ``sync.*`` keys entirely: keys present in the
+        file but absent from *config* are deleted; keys provided in *config*
+        are written (or removed when their value is ``None``).
+
+        Keys may be supplied with or without the ``"sync."`` prefix — the prefix
+        is added automatically when missing.
+
+        Args:
+            config: Mapping of sync key → value.  Pass ``None`` as the value
+                to explicitly delete a key (e.g.
+                ``{"sync.encryption.secret": None}``).  Pass an empty dict to
+                wipe all ``sync.*`` keys.
+
+        Raises:
+            TaskConfigurationError: If the taskrc file cannot be read or
+                written.
+
+        Example::
+
+            tw.config_store.set_sync_config({
+                "sync.server.origin": "https://taskchampion.example.com",
+                "sync.server.client_id": "xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx",
+                "sync.encryption.secret": "my-passphrase",
+            })
+            # Replace with local sync, removing any previous remote config:
+            tw.config_store.set_sync_config({
+                "sync.local.server_dir": "/mnt/shared/taskserver",
+            })
+        """
+        # Normalise keys so callers may omit the "sync." prefix.
+        normalised: dict[str, str | None] = {}
+        for k, v in config.items():
+            full_key = k if k.startswith("sync.") else f"sync.{k}"
+            normalised[full_key] = v
+
+        # Delete keys currently in the file that are not present in the new config.
+        for existing_key in list(self.get_sync_config().keys()):
+            if existing_key not in normalised:
+                self.delete_value(existing_key)
+
+        # Write or delete each supplied key.
+        for key, value in normalised.items():
+            if value is None:
+                self.delete_value(key)
+            else:
+                self.set_value(key, value)
+
+        # Final refresh ensures the in-memory cache reflects the final state.
+        self.refresh()
+
     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.")}
@@ -162,13 +216,23 @@ rc.bulk=0
         ``key=value`` is appended at the end.  The in-memory cache is refreshed
         automatically after the write.
 
+        Because both :class:`~taskwarrior.adapters.taskchampion_adapter.TaskChampionAdapter`
+        and :class:`~taskwarrior.adapters.taskwarrior_adapter.TaskWarriorAdapter`
+        read configuration lazily from this store, changes are effective on the
+        **next** adapter call without requiring an adapter restart.
+
         Args:
-            key: Dotted taskrc key (e.g. ``"uda.severity.type"``).
+            key: Dotted taskrc key (e.g. ``"sync.server.origin"``).
             value: New value (may be empty string to clear the value without
                 removing the key).
 
         Raises:
             TaskConfigurationError: If the file cannot be written.
+
+        Example::
+
+            tw.config_store.set_value("sync.server.origin", "https://sync.example.com")
+            tw.synchronize()  # picks up the new URL immediately
         """
         pattern = re.compile(r"^\s*" + re.escape(key) + r"\s*=.*$", re.IGNORECASE)
         try:

{pytaskwarrior-3.0.0a2 → pytaskwarrior-3.0.0a5}/src/taskwarrior/main.py

@@ -31,7 +31,21 @@ class TaskWarrior:
     ``task_cmd="task"`` (or any path to the binary) to use the classic CLI
     adapter instead.
 
+    Both adapters read configuration **lazily** from
+    :attr:`config_store`, so changes made via
+    ``tw.config_store.set_value(…)`` are immediately effective on the next
+    adapter call — no adapter recreation required.
+
+    .. note::
+        Changing ``data_location`` at runtime is not supported; create a new
+        :class:`TaskWarrior` instance in that case.
+
     Attributes:
+        config_store: Live view of the taskrc configuration.  Use
+            :meth:`~taskwarrior.config.config_store.ConfigStore.set_value`,
+            :meth:`~taskwarrior.config.config_store.ConfigStore.delete_value`,
+            and :meth:`~taskwarrior.config.config_store.ConfigStore.set_sync_config`
+            to modify settings at runtime.
         adapter: The underlying adapter instance (TaskChampion or CLI).
         context_service: Service for managing contexts.
         uda_service: Service for managing UDAs.
@@ -46,6 +60,13 @@ class TaskWarrior:
             added = tw.add_task(task)
             print(f"Added task: {added.uuid}")
 
+        Live configuration update (sync config, UDA, context, …)::
+
+            tw = TaskWarrior()
+            tw.config_store.set_value("sync.server.origin", "https://sync.example.com")
+            tw.config_store.set_value("sync.encryption.secret", "my-passphrase")
+            tw.synchronize()  # uses the new config immediately
+
         Explicit CLI adapter::
 
             tw = TaskWarrior(task_cmd="task")
@@ -108,24 +129,13 @@ class TaskWarrior:
             # Default mode: TaskChampionAdapter — no binary required.
             import uuid as _uuid
 
+            # Persist a stable client_id if remote sync is configured but none is set.
             sync_cfg = self.config_store.get_sync_config()
-            sync_server_url = sync_cfg.get("sync.server.origin")
-            sync_local_dir = sync_cfg.get("sync.local.server_dir")
-            sync_client_id = sync_cfg.get("sync.server.client_id")
-            sync_encryption_secret = sync_cfg.get("sync.encryption.secret")
+            if sync_cfg.get("sync.server.origin") and not sync_cfg.get("sync.server.client_id"):
+                self.config_store.set_value("sync.server.client_id", str(_uuid.uuid4()))
 
-            # Persist a stable client_id if remote sync is configured but none is set.
-            if sync_server_url and not sync_client_id:
-                sync_client_id = str(_uuid.uuid4())
-                self.config_store.set_value("sync.server.client_id", sync_client_id)
-
-            self.adapter = TaskChampionAdapter(
-                data_location=self.config_store.data_location,
-                sync_server_url=sync_server_url,
-                sync_client_id=sync_client_id,
-                sync_encryption_secret=sync_encryption_secret,
-                sync_local_server_dir=sync_local_dir,
-            )
+            # Pass config_store directly so sync params are re-read on every sync() call.
+            self.adapter = TaskChampionAdapter(config_store=self.config_store)
 
         self._cli_adapter: TaskWarriorAdapter | None = _cli
 

pytaskwarrior-3.0.0a2/src/pytaskwarrior.egg-info/requires.txt

@@ -1,2 +0,0 @@
-pydantic>=2.11.7
-taskchampion3-py-dev>=3.0.1.1a0