Filter Skill

Purpose

Implement comprehensive filtering for task management.

Instructions

Filter by Priority

from typing import List, Optional

def filter_by_priority(self, priority: str) -> List[dict]:
    """Filter tasks by priority level."""
    return self.db.search(self.db.query.priority == priority)

def filter_by_priorities(self, priorities: List[str]) -> List[dict]:
    """Filter tasks by multiple priority levels."""
    return [t for t in self.get_all_tasks() if t.get('priority') in priorities]

def get_urgent_tasks(self) -> List[dict]:
    """Get only urgent and high priority tasks."""
    return self.filter_by_priorities(['urgent', 'high'])

Filter by Status

def filter_by_status(self, status: str) -> List[dict]:
    """Filter tasks by status."""
    return self.db.search(self.db.query.status == status)

def get_pending_tasks(self) -> List[dict]:
    """Get all pending tasks."""
    return self.filter_by_status('pending')

def get_completed_tasks(self) -> List[dict]:
    """Get all completed tasks."""
    return self.filter_by_status('completed')

def get_active_tasks(self) -> List[dict]:
    """Get all non-completed tasks."""
    return self.db.search(self.db.query.status != 'completed')

Filter by Tags

def filter_by_tag(self, tag: str) -> List[dict]:
    """Filter tasks containing a specific tag."""
    tag = tag.lower()
    return self.db.search(
        self.db.query.tags.test(
            lambda tags: tag in [t.lower() for t in tags]
        )
    )

def filter_by_all_tags(self, tags: List[str]) -> List[dict]:
    """Filter tasks containing ALL specified tags."""
    tags = [t.lower() for t in tags]
    return self.db.search(
        self.db.query.tags.test(
            lambda task_tags: all(
                tag in [t.lower() for t in task_tags] 
                for tag in tags
            )
        )
    )

def filter_by_any_tag(self, tags: List[str]) -> List[dict]:
    """Filter tasks containing ANY specified tag."""
    tags = [t.lower() for t in tags]
    return self.db.search(
        self.db.query.tags.test(
            lambda task_tags: any(
                tag in [t.lower() for t in task_tags] 
                for tag in tags
            )
        )
    )

Filter by Due Date

from datetime import datetime, timedelta

def get_overdue_tasks(self) -> List[dict]:
    """Get tasks past their due date."""
    now = datetime.now().isoformat()
    return self.db.search(
        (self.db.query.due_date.exists()) &
        (self.db.query.due_date.test(lambda d: d < now)) &
        (self.db.query.status != 'completed')
    )

def get_due_today(self) -> List[dict]:
    """Get tasks due today."""
    today = datetime.now().date().isoformat()
    tomorrow = (datetime.now().date() + timedelta(days=1)).isoformat()
    return self.db.search(
        (self.db.query.due_date.exists()) &
        (self.db.query.due_date.test(lambda d: today <= d[:10] < tomorrow))
    )

def get_due_this_week(self) -> List[dict]:
    """Get tasks due within the next 7 days."""
    today = datetime.now().date()
    week_end = (today + timedelta(days=7)).isoformat()
    return self.db.search(
        (self.db.query.due_date.exists()) &
        (self.db.query.due_date.test(
            lambda d: today.isoformat() <= d[:10] <= week_end
        ))
    )

def get_tasks_without_due_date(self) -> List[dict]:
    """Get tasks without a due date."""
    return self.db.search(
        ~self.db.query.due_date.exists() | 
        (self.db.query.due_date == None)
    )

Combined Filter Service

class FilterService:
    """Comprehensive filter service with chainable filters."""
    
    def __init__(self, database):
        self.db = database
    
    def filter_tasks(
        self,
        priority: Optional[str] = None,
        priorities: Optional[List[str]] = None,
        status: Optional[str] = None,
        tags: Optional[List[str]] = None,
        tag_mode: str = 'any',  # 'any' or 'all'
        has_due_date: Optional[bool] = None,
        is_overdue: Optional[bool] = None,
        due_before: Optional[str] = None,
        due_after: Optional[str] = None,
    ) -> List[dict]:
        """Apply multiple filters to tasks."""
        
        tasks = self.db.get_all()
        
        # Priority filter
        if priority:
            tasks = [t for t in tasks if t.get('priority') == priority]
        elif priorities:
            tasks = [t for t in tasks if t.get('priority') in priorities]
        
        # Status filter
        if status:
            tasks = [t for t in tasks if t.get('status') == status]
        
        # Tags filter
        if tags:
            tags = [tag.lower() for tag in tags]
            if tag_mode == 'all':
                tasks = [
                    t for t in tasks 
                    if all(tag in [x.lower() for x in t.get('tags', [])] for tag in tags)
                ]
            else:  # 'any'
                tasks = [
                    t for t in tasks 
                    if any(tag in [x.lower() for x in t.get('tags', [])] for tag in tags)
                ]
        
        # Due date presence filter
        if has_due_date is not None:
            if has_due_date:
                tasks = [t for t in tasks if t.get('due_date')]
            else:
                tasks = [t for t in tasks if not t.get('due_date')]
        
        # Overdue filter
        if is_overdue is not None:
            now = datetime.now().isoformat()
            if is_overdue:
                tasks = [
                    t for t in tasks 
                    if t.get('due_date') and t['due_date'] < now and t.get('status') != 'completed'
                ]
            else:
                tasks = [
                    t for t in tasks 
                    if not t.get('due_date') or t['due_date'] >= now
                ]
        
        # Date range filters
        if due_before:
            tasks = [t for t in tasks if t.get('due_date') and t['due_date'] < due_before]
        if due_after:
            tasks = [t for t in tasks if t.get('due_date') and t['due_date'] > due_after]
        
        return tasks

Best Practices

• Handle None/empty filter values gracefully
• Support both single and multiple value filters
• Provide sensible defaults for filter modes
• Combine filters efficiently (filter in memory when possible)
• Cache common filter results if performance is needed
• Normalize tags and other text-based filters