taskdog-client 0.18.1__tar.gz

taskdog_client-0.18.1/PKG-INFO

@@ -0,0 +1,160 @@
+Metadata-Version: 2.4
+Name: taskdog-client
+Version: 0.18.1
+Summary: HTTP API client for Taskdog server
+Author: Kohei Wada
+License: MIT
+Project-URL: Homepage, https://github.com/Kohei-Wada/taskdog
+Project-URL: Repository, https://github.com/Kohei-Wada/taskdog
+Project-URL: Bug Tracker, https://github.com/Kohei-Wada/taskdog/issues
+Keywords: task,management,api-client
+Classifier: Development Status :: 4 - Beta
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Requires-Python: >=3.12
+Description-Content-Type: text/markdown
+Requires-Dist: taskdog-core==0.18.1
+Requires-Dist: httpx>=0.27.0
+Requires-Dist: websockets>=14.0
+Provides-Extra: dev
+Requires-Dist: pytest>=7.0.0; extra == "dev"
+Requires-Dist: pytest-cov>=4.0.0; extra == "dev"
+Requires-Dist: pytest-asyncio>=1.0.0; extra == "dev"
+Requires-Dist: mypy>=1.0.0; extra == "dev"
+Requires-Dist: ruff>=0.7.0; extra == "dev"
+
+# taskdog-client
+
+HTTP API client library for Taskdog server.
+
+## Overview
+
+This package provides a type-safe HTTP client for communicating with the Taskdog API server. It handles authentication, error mapping, and response conversion to domain DTOs.
+
+**Use cases:**
+
+- Building custom CLI tools
+- Integrating Taskdog with other systems
+- Creating automated workflows
+- Testing API endpoints
+
+## Installation
+
+```bash
+pip install taskdog-client
+```
+
+For development:
+
+```bash
+pip install -e ".[dev]"
+```
+
+## Client Classes
+
+| Client | Purpose |
+|--------|---------|
+| `TaskClient` | Task CRUD operations (create, update, delete, archive) |
+| `LifecycleClient` | Status changes (start, complete, pause, cancel, reopen) |
+| `RelationshipClient` | Dependencies and tags |
+| `QueryClient` | List tasks, get task details |
+| `AnalyticsClient` | Statistics and Gantt data |
+| `NotesClient` | Task notes (markdown) |
+| `AuditClient` | Audit log access |
+| `BaseApiClient` | Base class with common HTTP logic |
+
+## Usage Example
+
+```python
+from taskdog_client import TaskClient, LifecycleClient, QueryClient
+
+# Create clients
+base_url = "http://127.0.0.1:8000"
+api_key = "your-api-key"  # Optional, for authenticated servers
+
+task_client = TaskClient(base_url, api_key)
+lifecycle_client = LifecycleClient(base_url, api_key)
+query_client = QueryClient(base_url, api_key)
+
+# Create a task
+task = task_client.create_task(
+    name="My Task",
+    priority=100,
+    estimated_duration=8.0,
+    tags=["backend"]
+)
+print(f"Created task: {task.id}")
+
+# List tasks
+tasks = query_client.list_tasks(status="pending")
+for t in tasks:
+    print(f"- {t.name} (ID: {t.id})")
+
+# Start a task
+lifecycle_client.start_task(task.id)
+
+# Complete a task
+lifecycle_client.complete_task(task.id)
+```
+
+## Error Handling
+
+Clients raise exceptions from `taskdog_core.domain.exceptions`:
+
+```python
+from taskdog_core.domain.exceptions import TaskNotFoundException, TaskValidationError
+
+try:
+    task_client.get_task(999)
+except TaskNotFoundException:
+    print("Task not found")
+except TaskValidationError as e:
+    print(f"Validation error: {e}")
+```
+
+## Configuration
+
+Clients accept optional configuration:
+
+```python
+from taskdog_client import TaskClient
+
+# Basic usage (no auth)
+client = TaskClient("http://127.0.0.1:8000")
+
+# With API key authentication
+client = TaskClient(
+    base_url="http://127.0.0.1:8000",
+    api_key="your-secret-key"
+)
+
+# Custom timeout (in seconds)
+client = TaskClient(
+    base_url="http://127.0.0.1:8000",
+    timeout=30.0
+)
+```
+
+## Dependencies
+
+- `taskdog-core`: Domain DTOs and exceptions
+- `httpx`: HTTP client library
+
+## Related Packages
+
+- [taskdog-core](../taskdog-core/): Domain DTOs used by this package
+- [taskdog-server](../taskdog-server/): API server this client connects to
+- [taskdog-ui](../taskdog-ui/): CLI/TUI that uses this client
+- [taskdog-mcp](../taskdog-mcp/): MCP server that uses this client
+
+## Testing
+
+```bash
+pytest tests/
+```
+
+## License
+
+MIT

taskdog_client-0.18.1/README.md

@@ -0,0 +1,133 @@
+# taskdog-client
+
+HTTP API client library for Taskdog server.
+
+## Overview
+
+This package provides a type-safe HTTP client for communicating with the Taskdog API server. It handles authentication, error mapping, and response conversion to domain DTOs.
+
+**Use cases:**
+
+- Building custom CLI tools
+- Integrating Taskdog with other systems
+- Creating automated workflows
+- Testing API endpoints
+
+## Installation
+
+```bash
+pip install taskdog-client
+```
+
+For development:
+
+```bash
+pip install -e ".[dev]"
+```
+
+## Client Classes
+
+| Client | Purpose |
+|--------|---------|
+| `TaskClient` | Task CRUD operations (create, update, delete, archive) |
+| `LifecycleClient` | Status changes (start, complete, pause, cancel, reopen) |
+| `RelationshipClient` | Dependencies and tags |
+| `QueryClient` | List tasks, get task details |
+| `AnalyticsClient` | Statistics and Gantt data |
+| `NotesClient` | Task notes (markdown) |
+| `AuditClient` | Audit log access |
+| `BaseApiClient` | Base class with common HTTP logic |
+
+## Usage Example
+
+```python
+from taskdog_client import TaskClient, LifecycleClient, QueryClient
+
+# Create clients
+base_url = "http://127.0.0.1:8000"
+api_key = "your-api-key"  # Optional, for authenticated servers
+
+task_client = TaskClient(base_url, api_key)
+lifecycle_client = LifecycleClient(base_url, api_key)
+query_client = QueryClient(base_url, api_key)
+
+# Create a task
+task = task_client.create_task(
+    name="My Task",
+    priority=100,
+    estimated_duration=8.0,
+    tags=["backend"]
+)
+print(f"Created task: {task.id}")
+
+# List tasks
+tasks = query_client.list_tasks(status="pending")
+for t in tasks:
+    print(f"- {t.name} (ID: {t.id})")
+
+# Start a task
+lifecycle_client.start_task(task.id)
+
+# Complete a task
+lifecycle_client.complete_task(task.id)
+```
+
+## Error Handling
+
+Clients raise exceptions from `taskdog_core.domain.exceptions`:
+
+```python
+from taskdog_core.domain.exceptions import TaskNotFoundException, TaskValidationError
+
+try:
+    task_client.get_task(999)
+except TaskNotFoundException:
+    print("Task not found")
+except TaskValidationError as e:
+    print(f"Validation error: {e}")
+```
+
+## Configuration
+
+Clients accept optional configuration:
+
+```python
+from taskdog_client import TaskClient
+
+# Basic usage (no auth)
+client = TaskClient("http://127.0.0.1:8000")
+
+# With API key authentication
+client = TaskClient(
+    base_url="http://127.0.0.1:8000",
+    api_key="your-secret-key"
+)
+
+# Custom timeout (in seconds)
+client = TaskClient(
+    base_url="http://127.0.0.1:8000",
+    timeout=30.0
+)
+```
+
+## Dependencies
+
+- `taskdog-core`: Domain DTOs and exceptions
+- `httpx`: HTTP client library
+
+## Related Packages
+
+- [taskdog-core](../taskdog-core/): Domain DTOs used by this package
+- [taskdog-server](../taskdog-server/): API server this client connects to
+- [taskdog-ui](../taskdog-ui/): CLI/TUI that uses this client
+- [taskdog-mcp](../taskdog-mcp/): MCP server that uses this client
+
+## Testing
+
+```bash
+pytest tests/
+```
+
+## License
+
+MIT

taskdog_client-0.18.1/pyproject.toml

@@ -0,0 +1,64 @@
+[project]
+name = "taskdog-client"
+version = "0.18.1"
+description = "HTTP API client for Taskdog server"
+readme = "README.md"
+requires-python = ">=3.12"
+authors = [
+    { name = "Kohei Wada" }
+]
+license = { text = "MIT" }
+keywords = ["task", "management", "api-client"]
+classifiers = [
+    "Development Status :: 4 - Beta",
+    "License :: OSI Approved :: MIT License",
+    "Programming Language :: Python :: 3",
+    "Programming Language :: Python :: 3.12",
+    "Programming Language :: Python :: 3.13",
+]
+
+dependencies = [
+    "taskdog-core==0.18.1",
+    "httpx>=0.27.0",
+    "websockets>=14.0",
+]
+
+[project.optional-dependencies]
+dev = [
+    "pytest>=7.0.0",
+    "pytest-cov>=4.0.0",
+    "pytest-asyncio>=1.0.0",
+    "mypy>=1.0.0",
+    "ruff>=0.7.0",
+]
+
+[project.urls]
+Homepage = "https://github.com/Kohei-Wada/taskdog"
+Repository = "https://github.com/Kohei-Wada/taskdog"
+"Bug Tracker" = "https://github.com/Kohei-Wada/taskdog/issues"
+
+[build-system]
+requires = ["setuptools>=68.0.0", "wheel"]
+build-backend = "setuptools.build_meta"
+
+[tool.setuptools]
+packages = [
+    "taskdog_client",
+    "taskdog_client.converters",
+    "taskdog_client.websocket",
+]
+package-dir = { "" = "src" }
+
+[tool.setuptools.package-data]
+taskdog_client = ["py.typed"]
+
+[tool.mypy]
+python_version = "3.13"
+strict = true
+warn_unused_ignores = false
+
+[tool.pytest.ini_options]
+testpaths = ["tests"]
+python_files = ["test_*.py"]
+python_classes = ["Test*"]
+python_functions = ["test_*"]

taskdog_client-0.18.1/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

taskdog_client-0.18.1/src/taskdog_client/__init__.py

@@ -0,0 +1,31 @@
+"""HTTP and WebSocket client for Taskdog server.
+
+This package provides type-safe HTTP and WebSocket clients for communicating with
+the Taskdog API server. It handles authentication, error mapping,
+and response conversion to domain DTOs.
+"""
+
+from taskdog_client.analytics_client import AnalyticsClient
+from taskdog_client.audit_client import AuditClient
+from taskdog_client.base_client import BaseApiClient
+from taskdog_client.lifecycle_client import LifecycleClient
+from taskdog_client.notes_client import NotesClient
+from taskdog_client.query_client import QueryClient
+from taskdog_client.relationship_client import RelationshipClient
+from taskdog_client.task_client import TaskClient
+from taskdog_client.taskdog_api_client import TaskdogApiClient
+from taskdog_client.websocket import ConnectionState, WebSocketClient
+
+__all__ = [
+    "AnalyticsClient",
+    "AuditClient",
+    "BaseApiClient",
+    "ConnectionState",
+    "LifecycleClient",
+    "NotesClient",
+    "QueryClient",
+    "RelationshipClient",
+    "TaskClient",
+    "TaskdogApiClient",
+    "WebSocketClient",
+]

taskdog_client-0.18.1/src/taskdog_client/analytics_client.py

@@ -0,0 +1,97 @@
+"""Analytics and optimization client."""
+
+from datetime import datetime
+
+from taskdog_client.base_client import BaseApiClient
+from taskdog_client.converters import (
+    convert_to_optimization_output,
+    convert_to_statistics_output,
+)
+from taskdog_core.application.dto.optimization_output import OptimizationOutput
+from taskdog_core.application.dto.statistics_output import StatisticsOutput
+
+
+class AnalyticsClient:
+    """Client for analytics and schedule optimization.
+
+    Operations:
+    - Calculate statistics
+    - Optimize schedules
+    - Get algorithm metadata
+    """
+
+    def __init__(self, base_client: BaseApiClient):
+        """Initialize analytics client.
+
+        Args:
+            base_client: Base API client for HTTP operations
+        """
+        self._base = base_client
+
+    def calculate_statistics(self, period: str = "all") -> StatisticsOutput:
+        """Calculate task statistics.
+
+        Args:
+            period: Time period (all, 7d, 30d)
+
+        Returns:
+            StatisticsOutput with statistics data
+
+        Raises:
+            TaskValidationError: If period is invalid
+        """
+        data = self._base._request_json("get", f"/api/v1/statistics?period={period}")
+        return convert_to_statistics_output(data)
+
+    def optimize_schedule(
+        self,
+        algorithm: str,
+        start_date: datetime | None,
+        max_hours_per_day: float,
+        force_override: bool = True,
+        task_ids: list[int] | None = None,
+        include_all_days: bool = False,
+    ) -> OptimizationOutput:
+        """Optimize task schedules.
+
+        Args:
+            algorithm: Algorithm name (required)
+            start_date: Optimization start date (None = server current time)
+            max_hours_per_day: Maximum hours per day (required)
+            force_override: Force override existing schedules
+            task_ids: Specific task IDs to optimize (None means all schedulable tasks)
+            include_all_days: If True, schedule tasks on weekends and holidays too (default: False)
+
+        Returns:
+            OptimizationOutput with optimization results
+
+        Raises:
+            TaskValidationError: If validation fails
+            TaskNotFoundException: If any specified task_id does not exist
+            NoSchedulableTasksError: If no tasks can be scheduled
+        """
+        payload: dict[str, str | float | bool | list[int] | None] = {
+            "algorithm": algorithm,
+            "start_date": start_date.isoformat() if start_date else None,
+            "max_hours_per_day": max_hours_per_day,
+            "force_override": force_override,
+            "include_all_days": include_all_days,
+        }
+
+        # Only include task_ids if it's not None
+        if task_ids is not None:
+            payload["task_ids"] = task_ids
+
+        data = self._base._request_json("post", "/api/v1/optimize", json=payload)
+        return convert_to_optimization_output(data)
+
+    def get_algorithm_metadata(self) -> list[tuple[str, str, str]]:
+        """Get available optimization algorithms.
+
+        Returns:
+            List of (name, display_name, description) tuples
+        """
+        data = self._base._request_json("get", "/api/v1/algorithms")
+        return [
+            (algo["name"], algo["display_name"], algo["description"]) for algo in data
+        ]

taskdog_client-0.18.1/src/taskdog_client/audit_client.py

@@ -0,0 +1,120 @@
+"""Audit log client."""
+
+from datetime import datetime
+from typing import Any
+
+from taskdog_client.base_client import BaseApiClient
+from taskdog_core.application.dto.audit_log_dto import (
+    AuditLogListOutput,
+    AuditLogOutput,
+)
+
+
+class AuditClient:
+    """Client for audit log operations.
+
+    Operations:
+    - List audit logs with filtering
+    - Get single audit log by ID
+    """
+
+    def __init__(self, base_client: BaseApiClient):
+        """Initialize audit client.
+
+        Args:
+            base_client: Base API client for HTTP operations
+        """
+        self._base = base_client
+
+    def list_audit_logs(
+        self,
+        client_filter: str | None = None,
+        operation: str | None = None,
+        resource_type: str | None = None,
+        resource_id: int | None = None,
+        success: bool | None = None,
+        start_date: datetime | None = None,
+        end_date: datetime | None = None,
+        limit: int = 100,
+        offset: int = 0,
+    ) -> AuditLogListOutput:
+        """List audit logs with optional filtering.
+
+        Args:
+            client_filter: Filter by client name
+            operation: Filter by operation type
+            resource_type: Filter by resource type
+            resource_id: Filter by resource ID
+            success: Filter by success status
+            start_date: Filter logs after this datetime
+            end_date: Filter logs before this datetime
+            limit: Maximum number of logs to return
+            offset: Number of logs to skip for pagination
+
+        Returns:
+            AuditLogListOutput with logs and pagination info
+        """
+        params: dict[str, str | int] = {"limit": limit, "offset": offset}
+
+        if client_filter is not None:
+            params["client"] = client_filter
+        if operation is not None:
+            params["operation"] = operation
+        if resource_type is not None:
+            params["resource_type"] = resource_type
+        if resource_id is not None:
+            params["resource_id"] = resource_id
+        if success is not None:
+            params["success"] = str(success).lower()
+        if start_date is not None:
+            params["start_date"] = start_date.isoformat()
+        if end_date is not None:
+            params["end_date"] = end_date.isoformat()
+
+        data = self._base._request_json("get", "/api/v1/audit-logs", params=params)
+        return self._convert_to_list_output(data)
+
+    def get_audit_log(self, log_id: int) -> AuditLogOutput:
+        """Get a single audit log entry by ID.
+
+        Args:
+            log_id: ID of the audit log entry to retrieve
+
+        Returns:
+            AuditLogOutput with the audit log details
+        """
+        data = self._base._request_json("get", f"/api/v1/audit-logs/{log_id}")
+        return self._convert_to_output(data)
+
+    def _convert_to_output(self, data: dict[str, Any]) -> AuditLogOutput:
+        """Convert API response to AuditLogOutput DTO."""
+        # Parse timestamp with error handling for malformed data
+        try:
+            timestamp = datetime.fromisoformat(data["timestamp"])
+        except (ValueError, KeyError):
+            # Fallback to current time if timestamp is invalid or missing
+            timestamp = datetime.now()
+
+        return AuditLogOutput(
+            id=data["id"],
+            timestamp=timestamp,
+            client_name=data.get("client_name"),
+            operation=data["operation"],
+            resource_type=data["resource_type"],
+            resource_id=data.get("resource_id"),
+            resource_name=data.get("resource_name"),
+            old_values=data.get("old_values"),
+            new_values=data.get("new_values"),
+            success=data["success"],
+            error_message=data.get("error_message"),
+        )
+
+    def _convert_to_list_output(self, data: dict[str, Any]) -> AuditLogListOutput:
+        """Convert API response to AuditLogListOutput DTO."""
+        logs = [self._convert_to_output(log) for log in data["logs"]]
+        return AuditLogListOutput(
+            logs=logs,
+            total_count=data["total_count"],
+            limit=data["limit"],
+            offset=data["offset"],
+        )