majiayu000 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