raztodo 0.1.0__py3-none-any.whl

raztodo/__main__.py

@@ -0,0 +1,30 @@
+import sys
+
+from raztodo.domain.exceptions import RazTodoException
+from raztodo.infrastructure.container import AppContainer
+from raztodo.infrastructure.logger import get_logger
+from raztodo.presentation.cli.entrypoint import run_cli
+
+logger = get_logger("main")
+
+
+def main() -> int:
+    container = AppContainer()
+    handler = container.task_handler
+
+    try:
+        return run_cli(handler=handler)
+    except RazTodoException as e:
+        logger.exception(e)
+        print(f"[Error] {e}", file=sys.stderr)
+        return 1
+    except Exception as e:
+        logger.exception(e)
+        print("[Fatal] Unexpected error.", file=sys.stderr)
+        return 1
+    finally:
+        container.close_singleton()
+
+
+if __name__ == "__main__":
+    sys.exit(main())

raztodo/application/use_cases/create_task.py

@@ -0,0 +1,60 @@
+from raztodo.domain.exceptions import RazTodoException
+from raztodo.domain.task_repository import TaskRepository
+
+MAX_TITLE_LENGTH = 60
+
+
+class CreateTaskUseCase:
+    """
+    Handles creation of a new task with validation and repository interaction.
+    """
+
+    def __init__(self, repo: TaskRepository) -> None:
+        self.repo: TaskRepository = repo
+
+    def execute(
+        self,
+        title: str,
+        description: str = "",
+        priority: str = "",
+        due_date: str | None = None,
+        tags: list[str] | None = None,
+        project: str | None = None,
+    ) -> int:
+        """
+        Create a task after validating title and length.
+
+        Args:
+            title: Task title (required, max 60 chars).
+            description: Optional task description.
+            priority: Optional task priority.
+            due_date: Optional due date in string format.
+            tags: Optional list of tags.
+            project: Optional project name.
+
+        Returns:
+            ID of the newly created task.
+
+        Raises:
+            RazTodoException: If validation fails or task creation fails.
+        """
+
+        title_stripped: str = title.strip() if title else ""
+        if not title_stripped:
+            raise RazTodoException("Task title cannot be empty")
+
+        if len(title_stripped) > MAX_TITLE_LENGTH:
+            raise RazTodoException(
+                f"Task title too long. Maximum {MAX_TITLE_LENGTH} characters, "
+                f"provided {len(title_stripped)}"
+            )
+
+        task_id: int | None = self.repo.add_task(
+            title_stripped, description, priority, due_date, tags, project
+        )
+        if not task_id:
+            raise RazTodoException(
+                f"Failed to create task. Title '{title_stripped}' might already exist or validation failed"
+            )
+
+        return task_id

raztodo/application/use_cases/delete_task.py

@@ -0,0 +1,30 @@
+from raztodo.domain.exceptions import RazTodoException
+from raztodo.domain.task_repository import TaskRepository
+
+
+class DeleteTaskUseCase:
+    """
+    Handles deletion of a task by ID via the repository.
+    """
+
+    def __init__(self, repo: TaskRepository) -> None:
+        self.repo: TaskRepository = repo
+
+    def execute(self, task_id: int) -> bool:
+        """
+        Delete a task by its ID.
+
+        Args:
+            task_id: ID of the task to delete.
+
+        Returns:
+            True if deletion was successful.
+
+        Raises:
+            RazTodoException: If no task with the given ID exists.
+        """
+
+        removed: int = self.repo.remove_task(task_id)
+        if removed <= 0:
+            raise RazTodoException(f"No task found with id {task_id}")
+        return True

raztodo/application/use_cases/export_task.py

@@ -0,0 +1,33 @@
+from raztodo.domain.exceptions import RazTodoException
+from raztodo.domain.task_repository import TaskRepository
+
+
+class ExportTasksUseCase:
+    """
+    Handles exporting tasks to a specified file via the repository.
+    """
+
+    def __init__(self, repo: TaskRepository) -> None:
+        """
+        Export all tasks to the given file path.
+
+        Args:
+            filepath: Destination file path for exported tasks.
+
+        Returns:
+            True if export was successful.
+
+        Raises:
+            RazTodoException: If export fails (e.g., permission or disk issues).
+        """
+
+        self.repo: TaskRepository = repo
+
+    def execute(self, filepath: str) -> bool:
+        success: bool = self.repo.export_tasks(filepath)
+        if not success:
+            raise RazTodoException(
+                f"Failed to export tasks to '{filepath}'. "
+                "Check file permissions and disk space."
+            )
+        return True

raztodo/application/use_cases/import_task.py

@@ -0,0 +1,108 @@
+import json
+import os
+from typing import Any
+
+from raztodo.domain.exceptions import RazTodoException
+from raztodo.domain.task_entity import TaskEntity
+from raztodo.domain.task_repository import TaskRepository
+
+
+class ImportTasksUseCase:
+    """
+    Handles importing tasks from a JSON file, with optional upsert support.
+    """
+
+    def __init__(self, repo: TaskRepository) -> None:
+        self.repo: TaskRepository = repo
+
+    def execute(self, filepath: str, upsert: bool = False) -> int | dict[str, int]:
+        """
+        Import tasks from a file, optionally updating existing tasks.
+
+        Args:
+            filepath: Path to the JSON file containing tasks.
+            upsert: If True, update existing tasks with matching titles.
+
+        Returns:
+            Number of tasks imported, or a dict with counts of inserted and updated tasks if upsert is True.
+
+        Raises:
+            RazTodoException: If file is missing, unreadable, JSON is invalid, or import fails.
+        """
+
+        try:
+            if not os.path.exists(filepath):
+                raise RazTodoException(f"File not found: {filepath}")
+
+            if not os.access(filepath, os.R_OK):
+                raise RazTodoException(f"Permission denied: Cannot read '{filepath}'")
+
+            if not upsert:
+                return self.repo.import_tasks(filepath)
+
+            with open(filepath, encoding="utf-8") as f:
+                data: Any = json.load(f)
+
+            if not isinstance(data, list):
+                raise RazTodoException(
+                    f"Expected JSON array in '{filepath}', got {type(data).__name__}"
+                )
+
+            inserted: int = 0
+            updated: int = 0
+            for item in data:
+                if not isinstance(item, dict):
+                    continue
+
+                title: str = item.get("title", "").strip()
+                if not title:
+                    continue
+
+                desc: str = item.get("description", "")
+                priority: str = item.get("priority") or ""
+                due_date: str | None = item.get("due_date")
+                tags: list[str] = item.get("tags") or []
+                project: str | None = item.get("project")
+
+                try:
+                    inserted_id: int | None = self.repo.add_task(
+                        title, desc, priority, due_date, tags, project
+                    )
+                    if inserted_id:
+                        if "done" in item:
+                            self.repo.mark_done(inserted_id, bool(item["done"]))
+                        inserted += 1
+                        continue
+                except RazTodoException:
+                    pass
+
+                matches: list[TaskEntity] = [
+                    t for t in self.repo.search_tasks(title) if t.title == title
+                ]
+                if matches:
+                    task = matches[0]
+                    self.repo.update_task(
+                        task.id,
+                        title=title,
+                        description=desc,
+                        priority=priority or None,
+                        due_date=due_date,
+                        tags=tags if tags else None,
+                        project=project,
+                    )
+                    if "done" in item:
+                        self.repo.mark_done(task.id, bool(item["done"]))
+                    updated += 1
+
+            return {"inserted": inserted, "updated": updated}
+
+        except json.JSONDecodeError as e:
+            raise RazTodoException(
+                f"Invalid JSON format in '{filepath}': {e.msg} at line {e.lineno}"
+            ) from e
+        except UnicodeDecodeError as e:
+            raise RazTodoException(f"File encoding error in '{filepath}': {e}") from e
+        except OSError as e:
+            raise RazTodoException(
+                f"I/O error while accessing '{filepath}': {e}"
+            ) from e

raztodo/application/use_cases/list_tasks.py

@@ -0,0 +1,50 @@
+from raztodo.domain.task_entity import TaskEntity
+from raztodo.domain.task_repository import TaskRepository
+
+
+class ListTasksUseCase:
+    """
+    Retrieves tasks from the repository with optional filtering and pagination.
+    """
+
+    def __init__(self, repo: TaskRepository) -> None:
+        self.repo: TaskRepository = repo
+
+    def execute(
+        self,
+        limit: int | None = None,
+        offset: int | None = None,
+        priority: str | None = None,
+        project: str | None = None,
+        done: bool | None = None,
+        tags: list[str] | None = None,
+        due_before: str | None = None,
+        due_after: str | None = None,
+    ) -> list[TaskEntity]:
+        """
+        List tasks with optional filters.
+
+        Args:
+            limit: Maximum number of tasks to return.
+            offset: Number of tasks to skip.
+            priority: Filter by task priority.
+            project: Filter by project name.
+            done: Filter by completion status.
+            tags: Filter by tags.
+            due_before: Filter tasks due before this date.
+            due_after: Filter tasks due after this date.
+
+        Returns:
+            List of TaskEntity objects matching the filters.
+        """
+
+        return self.repo.get_tasks(
+            limit=limit,
+            offset=offset,
+            priority=priority,
+            project=project,
+            done=done,
+            tags=tags,
+            due_before=due_before,
+            due_after=due_after,
+        )

raztodo/application/use_cases/mark_task_done.py

@@ -0,0 +1,31 @@
+from raztodo.domain.exceptions import RazTodoException
+from raztodo.domain.task_repository import TaskRepository
+
+
+class MarkDoneUseCase:
+    """
+    Marks a task as done or undone via the repository.
+    """
+
+    def __init__(self, repo: TaskRepository) -> None:
+        self.repo: TaskRepository = repo
+
+    def execute(self, task_id: int, done: bool = True) -> bool:
+        """
+        Update a task's completion status.
+
+        Args:
+            task_id: ID of the task to update.
+            done: True to mark as done, False to mark as not done.
+
+        Returns:
+            True if the update was successful.
+
+        Raises:
+            RazTodoException: If no task with the given ID exists.
+        """
+
+        updated: int = self.repo.mark_done(task_id, done)
+        if not updated:
+            raise RazTodoException(f"No task found with id {task_id}")
+        return True

raztodo/application/use_cases/migrate_tasks.py

@@ -0,0 +1,37 @@
+from collections.abc import Callable
+from sqlite3 import Connection
+
+from raztodo.infrastructure.sqlite.migrations import (
+    create_unique_title_index,
+    deduplicate_titles,
+)
+
+
+class MigrateUseCase:
+    """
+    Handles database migration tasks such as deduplicating titles and creating indexes.
+    """
+
+    def __init__(self, connection_factory: Callable[[], Connection]) -> None:
+        self._connection_factory: Callable[[], Connection] = connection_factory
+
+    def execute(self) -> dict[str, object]:
+        """
+        Perform migration: fix duplicate task titles and create unique title index.
+
+        Returns:
+            A dictionary with migration results:
+                - 'duplicates_fixed': number of duplicate titles corrected
+                - 'unique_index': True if the unique index was created
+
+        Raises:
+            Any exceptions from database operations are propagated.
+        """
+
+        conn: Connection = self._connection_factory()
+        try:
+            updated: int = deduplicate_titles(conn)
+            create_unique_title_index(conn)
+            return {"duplicates_fixed": updated, "unique_index": True}
+        finally:
+            conn.close()

raztodo/application/use_cases/search_tasks.py

@@ -0,0 +1,37 @@
+from raztodo.domain.task_entity import TaskEntity
+from raztodo.domain.task_repository import TaskRepository
+
+
+class SearchTasksUseCase:
+    """
+    Searches tasks in the repository by keyword with optional filters.
+    """
+
+    def __init__(self, repo: TaskRepository) -> None:
+        self.repo: TaskRepository = repo
+
+    def execute(
+        self,
+        keyword: str,
+        priority: str | None = None,
+        project: str | None = None,
+        tags: list[str] | None = None,
+    ) -> list[TaskEntity]:
+        """
+        Search tasks matching a keyword and optional filters.
+
+        Args:
+            keyword: Text to search in task titles/descriptions.
+            priority: Optional filter by task priority.
+            project: Optional filter by project name.
+            tags: Optional filter by tags.
+
+        Returns:
+            List of TaskEntity objects matching the search criteria.
+        """
+
+        if not keyword.strip():
+            return []
+        return self.repo.search_tasks(
+            keyword, priority=priority, project=project, tags=tags
+        )

raztodo/application/use_cases/update_task.py

@@ -0,0 +1,49 @@
+from raztodo.domain.exceptions import RazTodoException
+from raztodo.domain.task_repository import TaskRepository
+
+
+class UpdateTaskUseCase:
+    """
+    Updates an existing task's attributes via the repository.
+    """
+
+    def __init__(self, repo: TaskRepository) -> None:
+        self.repo: TaskRepository = repo
+
+    def execute(
+        self,
+        task_id: int,
+        title: str | None = None,
+        description: str | None = None,
+        priority: str | None = None,
+        due_date: str | None = None,
+        tags: list[str] | None = None,
+        project: str | None = None,
+    ) -> bool:
+        """
+        Update task fields by ID.
+
+        Args:
+            task_id: ID of the task to update.
+            title: Optional new title.
+            description: Optional new description.
+            priority: Optional new priority.
+            due_date: Optional new due date.
+            tags: Optional new list of tags.
+            project: Optional new project name.
+
+        Returns:
+            True if the update was successful.
+
+        Raises:
+            RazTodoException: If the task does not exist or no changes were provided.
+        """
+
+        updated: int = self.repo.update_task(
+            task_id, title, description, priority, due_date, tags, project
+        )
+        if not updated:
+            raise RazTodoException(
+                f"No task found with id {task_id} or no changes provided"
+            )
+        return True

raztodo/domain/exceptions.py

@@ -0,0 +1,200 @@
+class RazTodoException(Exception):
+    """Base exception class for all RazTodo domain-specific errors."""
+
+    pass
+
+
+def default_message(base: str, **kwargs: str | None) -> str:
+    """
+    Builds a formatted message by appending keyword arguments to a base message.
+
+    Args:
+        base (str): The base error message.
+        **kwargs (Optional[str]): Optional key-value pairs providing context.
+
+    Returns:
+        str: The composed error message.
+    """
+
+    parts = [f"{k}='{v}'" for k, v in kwargs.items() if v is not None]
+    return f"{base}: {', '.join(parts)}" if parts else base
+
+
+class TaskNotFoundError(RazTodoException):
+    """
+    Raised when a task with the specified identifier cannot be located.
+
+    Args:
+        task_id (int): Identifier of the missing task.
+        message (Optional[str]): Custom message override.
+    """
+
+    def __init__(self, task_id: int, message: str | None = None) -> None:
+        self.task_id = task_id
+        super().__init__(message or f"No task found with id {task_id}")
+
+
+class TaskValidationError(RazTodoException):
+    """
+    Raised when a task fails validation rules.
+
+    Args:
+        field (Optional[str]): Name of the invalid field, if applicable.
+        value (Optional[str]): Provided invalid value.
+        message (Optional[str]): Custom message override.
+    """
+
+    def __init__(
+        self,
+        field: str | None = None,
+        value: str | None = None,
+        message: str | None = None,
+    ) -> None:
+        self.field = field
+        self.value = value
+
+        if message is None:
+            if field and value is not None:
+                message = f"Validation failed for field '{field}': {value}"
+            elif field:
+                message = f"Validation failed for field '{field}'"
+            else:
+                message = "Task validation failed"
+
+        super().__init__(message)
+
+
+class DuplicateTaskError(RazTodoException):
+    """
+    Raised when attempting to create a task with a title that already exists.
+
+    Args:
+        title (str): Title of the conflicting task.
+        message (Optional[str]): Custom message override.
+    """
+
+    def __init__(self, title: str, message: str | None = None) -> None:
+        self.title = title
+        super().__init__(message or default_message("Task already exists", title=title))
+
+
+class FileOperationError(RazTodoException):
+    """
+    Raised when a file-related operation fails.
+
+    Args:
+        filepath (Optional[str]): Path of the involved file.
+        message (Optional[str]): Custom message override.
+    """
+
+    def __init__(self, filepath: str | None = None, message: str | None = None) -> None:
+        self.filepath = filepath
+        super().__init__(
+            message or default_message("File operation failed", filepath=filepath)
+        )
+
+
+class TaskFileNotFoundError(FileOperationError):
+    """
+    Raised when the expected task file is not found.
+
+    Args:
+        filepath (str): Path of the missing file.
+    """
+
+    def __init__(self, filepath: str) -> None:
+        super().__init__(filepath=filepath, message=f"File not found: {filepath}")
+
+
+class FilePermissionError(FileOperationError):
+    """
+    Raised when the system lacks permissions for a file operation.
+
+    Args:
+        filepath (str): Path of the target file.
+        operation (str): Operation being attempted (e.g., read, write).
+    """
+
+    def __init__(self, filepath: str, operation: str = "access") -> None:
+        super().__init__(
+            filepath=filepath,
+            message=f"Permission denied: Cannot {operation} '{filepath}'",
+        )
+
+
+class InvalidFileFormatError(FileOperationError):
+    """
+    Raised when a file has an invalid or unsupported format.
+
+    Args:
+        filepath (Optional[str]): Path of the problematic file.
+        format_type (Optional[str]): File format that failed validation.
+        message (Optional[str]): Custom message override.
+    """
+
+    def __init__(
+        self,
+        filepath: str | None = None,
+        format_type: str | None = None,
+        message: str | None = None,
+    ) -> None:
+
+        self.format_type = format_type
+
+        if message is None:
+            if filepath and format_type:
+                message = f"Invalid {format_type} format in file '{filepath}'"
+            elif filepath:
+                message = f"Invalid file format: {filepath}"
+            elif format_type:
+                message = f"Invalid {format_type} format"
+            else:
+                message = "Invalid file format"
+
+        super().__init__(filepath=filepath, message=message)
+
+
+class DatabaseError(RazTodoException):
+    """
+    Raised when a database operation fails.
+
+    Args:
+        operation (Optional[str]): Type of operation attempted.
+        message (Optional[str]): Custom message override.
+    """
+
+    def __init__(
+        self, operation: str | None = None, message: str | None = None
+    ) -> None:
+        self.operation = operation
+        super().__init__(
+            message or default_message("Database operation failed", operation=operation)
+        )
+
+
+class DatabaseConnectionError(DatabaseError):
+    """
+    Raised when a connection to the database cannot be established.
+
+    Args:
+        message (Optional[str]): Custom message override.
+    """
+
+    def __init__(self, message: str | None = None) -> None:
+        super().__init__(
+            operation="connection",
+            message=message or "Failed to connect to database",
+        )
+
+
+ERROR_TYPE_MAP: dict[str, type[RazTodoException]] = {
+    """Mapping of string error identifiers to their corresponding exception types."""
+    "not_found": TaskNotFoundError,
+    "validation": TaskValidationError,
+    "duplicate": DuplicateTaskError,
+    "permission": FilePermissionError,
+    "file_operation": FileOperationError,
+    "invalid_format": InvalidFileFormatError,
+    "file_not_found": TaskFileNotFoundError,
+    "database": DatabaseError,
+}