mcp-ticketer 0.1.21__py3-none-any.whl → 0.1.23__py3-none-any.whl

mcp_ticketer/queue/__init__.py

@@ -1,7 +1,7 @@
 """Async queue system for mcp-ticketer."""
 
+from .manager import WorkerManager
 from .queue import Queue, QueueItem, QueueStatus
 from .worker import Worker
-from .manager import WorkerManager
 
-__all__ = ["Queue", "QueueItem", "QueueStatus", "Worker", "WorkerManager"]
+__all__ = ["Queue", "QueueItem", "QueueStatus", "Worker", "WorkerManager"]

mcp_ticketer/queue/__main__.py

@@ -3,4 +3,4 @@
 from .run_worker import main
 
 if __name__ == "__main__":
-    main()
+    main()

mcp_ticketer/queue/manager.py

@@ -1,17 +1,17 @@
 """Worker manager with file-based locking for single instance."""
 
+import fcntl
+import logging
 import os
-import psutil
 import subprocess
 import sys
 import time
 from pathlib import Path
-from typing import Optional, Dict, Any
-import fcntl
-import logging
+from typing import Any, Optional
+
+import psutil
 
 from .queue import Queue
-from .worker import Worker
 
 logger = logging.getLogger(__name__)
 
@@ -31,6 +31,7 @@ class WorkerManager:
 
         Returns:
             True if lock acquired, False otherwise
+
         """
         try:
             # Create lock file if it doesn't exist
@@ -46,13 +47,13 @@ class WorkerManager:
             self.lock_fd.flush()
 
             return True
-        except IOError:
+        except OSError:
             # Lock already held
             return False
 
     def _release_lock(self):
         """Release worker lock."""
-        if hasattr(self, 'lock_fd'):
+        if hasattr(self, "lock_fd"):
             fcntl.lockf(self.lock_fd, fcntl.LOCK_UN)
             self.lock_fd.close()
 
@@ -65,6 +66,7 @@ class WorkerManager:
 
         Returns:
             True if worker started or already running, False otherwise
+
         """
         # Check if worker is already running
         if self.is_running():
@@ -84,6 +86,7 @@ class WorkerManager:
 
         Returns:
             True if started successfully, False otherwise
+
         """
         # Check if already running
         if self.is_running():
@@ -97,18 +100,14 @@ class WorkerManager:
 
         try:
             # Start worker in subprocess
-            cmd = [
-                sys.executable,
-                "-m",
-                "mcp_ticketer.queue.run_worker"
-            ]
+            cmd = [sys.executable, "-m", "mcp_ticketer.queue.run_worker"]
 
             # Start as background process
             process = subprocess.Popen(
                 cmd,
                 stdout=subprocess.DEVNULL,
                 stderr=subprocess.DEVNULL,
-                start_new_session=True
+                start_new_session=True,
             )
 
             # Save PID
@@ -116,6 +115,7 @@ class WorkerManager:
 
             # Give the process a moment to start
             import time
+
             time.sleep(0.5)
 
             # Verify process is running
@@ -137,6 +137,7 @@ class WorkerManager:
 
         Returns:
             True if stopped successfully, False otherwise
+
         """
         pid = self._get_pid()
         if not pid:
@@ -177,6 +178,7 @@ class WorkerManager:
 
         Returns:
             True if restarted successfully, False otherwise
+
         """
         logger.info("Restarting worker...")
         self.stop()
@@ -188,6 +190,7 @@ class WorkerManager:
 
         Returns:
             True if running, False otherwise
+
         """
         pid = self._get_pid()
         if not pid:
@@ -204,30 +207,30 @@ class WorkerManager:
 
         return False
 
-    def get_status(self) -> Dict[str, Any]:
+    def get_status(self) -> dict[str, Any]:
         """Get detailed worker status.
 
         Returns:
             Status information
+
         """
         is_running = self.is_running()
         pid = self._get_pid() if is_running else None
 
-        status = {
-            "running": is_running,
-            "pid": pid
-        }
+        status = {"running": is_running, "pid": pid}
 
         # Add process info if running
         if is_running and pid:
             try:
                 process = psutil.Process(pid)
-                status.update({
-                    "cpu_percent": process.cpu_percent(),
-                    "memory_mb": process.memory_info().rss / 1024 / 1024,
-                    "create_time": process.create_time(),
-                    "status": process.status()
-                })
+                status.update(
+                    {
+                        "cpu_percent": process.cpu_percent(),
+                        "memory_mb": process.memory_info().rss / 1024 / 1024,
+                        "create_time": process.create_time(),
+                        "status": process.status(),
+                    }
+                )
             except (psutil.NoSuchProcess, psutil.AccessDenied):
                 pass
 
@@ -242,6 +245,7 @@ class WorkerManager:
 
         Returns:
             Process ID or None if not found
+
         """
         if not self.pid_file.exists():
             return None
@@ -249,7 +253,7 @@ class WorkerManager:
         try:
             pid_text = self.pid_file.read_text().strip()
             return int(pid_text)
-        except (ValueError, IOError):
+        except (OSError, ValueError):
             return None
 
     def _cleanup(self):
@@ -258,4 +262,4 @@ class WorkerManager:
         if self.pid_file.exists():
             self.pid_file.unlink()
         if self.lock_file.exists():
-            self.lock_file.unlink()
+            self.lock_file.unlink()

mcp_ticketer/queue/queue.py

@@ -1,18 +1,19 @@
 """SQLite-based queue system for async ticket operations."""
 
-import sqlite3
 import json
+import sqlite3
 import threading
+import uuid
+from dataclasses import asdict, dataclass
 from datetime import datetime, timedelta
 from enum import Enum
 from pathlib import Path
-from typing import Optional, Dict, Any, List
-from dataclasses import dataclass, asdict
-import uuid
+from typing import Any, Optional
 
 
 class QueueStatus(str, Enum):
     """Queue item status values."""
+
     PENDING = "pending"
     PROCESSING = "processing"
     COMPLETED = "completed"
@@ -22,8 +23,9 @@ class QueueStatus(str, Enum):
 @dataclass
 class QueueItem:
     """Represents a queued operation."""
+
     id: str
-    ticket_data: Dict[str, Any]
+    ticket_data: dict[str, Any]
     adapter: str
     operation: str
     status: QueueStatus
@@ -31,15 +33,15 @@ class QueueItem:
     processed_at: Optional[datetime] = None
     error_message: Optional[str] = None
     retry_count: int = 0
-    result: Optional[Dict[str, Any]] = None
+    result: Optional[dict[str, Any]] = None
     project_dir: Optional[str] = None
 
     def to_dict(self) -> dict:
         """Convert to dictionary for storage."""
         data = asdict(self)
-        data['created_at'] = self.created_at.isoformat()
+        data["created_at"] = self.created_at.isoformat()
         if self.processed_at:
-            data['processed_at'] = self.processed_at.isoformat()
+            data["processed_at"] = self.processed_at.isoformat()
         return data
 
     @classmethod
@@ -56,7 +58,7 @@ class QueueItem:
             error_message=row[7],
             retry_count=row[8],
             result=json.loads(row[9]) if row[9] else None,
-            project_dir=row[10] if len(row) > 10 else None
+            project_dir=row[10] if len(row) > 10 else None,
         )
 
 
@@ -68,6 +70,7 @@ class Queue:
 
         Args:
             db_path: Path to SQLite database. Defaults to ~/.mcp-ticketer/queue.db
+
         """
         if db_path is None:
             db_dir = Path.home() / ".mcp-ticketer"
@@ -81,7 +84,8 @@ class Queue:
     def _init_database(self):
         """Initialize database schema."""
         with sqlite3.connect(self.db_path) as conn:
-            conn.execute('''
+            conn.execute(
+                """
                 CREATE TABLE IF NOT EXISTS queue (
                     id TEXT PRIMARY KEY,
                     ticket_data TEXT NOT NULL,
@@ -95,35 +99,44 @@ class Queue:
                     result TEXT,
                     CHECK (status IN ('pending', 'processing', 'completed', 'failed'))
                 )
-            ''')
+            """
+            )
 
             # Create indices for efficient queries
-            conn.execute('''
+            conn.execute(
+                """
                 CREATE INDEX IF NOT EXISTS idx_queue_status
                 ON queue(status)
-            ''')
-            conn.execute('''
+            """
+            )
+            conn.execute(
+                """
                 CREATE INDEX IF NOT EXISTS idx_queue_created
                 ON queue(created_at)
-            ''')
-            conn.execute('''
+            """
+            )
+            conn.execute(
+                """
                 CREATE INDEX IF NOT EXISTS idx_queue_adapter
                 ON queue(adapter)
-            ''')
+            """
+            )
 
             # Migration: Add project_dir column if it doesn't exist
             cursor = conn.execute("PRAGMA table_info(queue)")
             columns = [row[1] for row in cursor.fetchall()]
-            if 'project_dir' not in columns:
-                conn.execute('ALTER TABLE queue ADD COLUMN project_dir TEXT')
+            if "project_dir" not in columns:
+                conn.execute("ALTER TABLE queue ADD COLUMN project_dir TEXT")
 
             conn.commit()
 
-    def add(self,
-            ticket_data: Dict[str, Any],
-            adapter: str,
-            operation: str,
-            project_dir: Optional[str] = None) -> str:
+    def add(
+        self,
+        ticket_data: dict[str, Any],
+        adapter: str,
+        operation: str,
+        project_dir: Optional[str] = None,
+    ) -> str:
         """Add item to queue.
 
         Args:
@@ -134,6 +147,7 @@ class Queue:
 
         Returns:
             Queue ID for tracking
+
         """
         queue_id = f"Q-{uuid.uuid4().hex[:8].upper()}"
 
@@ -143,21 +157,24 @@ class Queue:
 
         with self._lock:
             with sqlite3.connect(self.db_path) as conn:
-                conn.execute('''
+                conn.execute(
+                    """
                     INSERT INTO queue (
                         id, ticket_data, adapter, operation,
                         status, created_at, retry_count, project_dir
                     ) VALUES (?, ?, ?, ?, ?, ?, ?, ?)
-                ''', (
-                    queue_id,
-                    json.dumps(ticket_data),
-                    adapter,
-                    operation,
-                    QueueStatus.PENDING.value,
-                    datetime.now().isoformat(),
-                    0,
-                    project_dir
-                ))
+                """,
+                    (
+                        queue_id,
+                        json.dumps(ticket_data),
+                        adapter,
+                        operation,
+                        QueueStatus.PENDING.value,
+                        datetime.now().isoformat(),
+                        0,
+                        project_dir,
+                    ),
+                )
                 conn.commit()
 
         return queue_id
@@ -167,25 +184,32 @@ class Queue:
 
         Returns:
             Next pending QueueItem or None if queue is empty
+
         """
         with self._lock:
             with sqlite3.connect(self.db_path) as conn:
                 # Get next pending item ordered by creation time
-                cursor = conn.execute('''
+                cursor = conn.execute(
+                    """
                     SELECT * FROM queue
                     WHERE status = ?
                     ORDER BY created_at
                     LIMIT 1
-                ''', (QueueStatus.PENDING.value,))
+                """,
+                    (QueueStatus.PENDING.value,),
+                )
 
                 row = cursor.fetchone()
                 if row:
                     # Mark as processing
-                    conn.execute('''
+                    conn.execute(
+                        """
                         UPDATE queue
                         SET status = ?
                         WHERE id = ?
-                    ''', (QueueStatus.PROCESSING.value, row[0]))
+                    """,
+                        (QueueStatus.PROCESSING.value, row[0]),
+                    )
                     conn.commit()
 
                     # Create QueueItem from row and update status
@@ -195,11 +219,13 @@ class Queue:
 
         return None
 
-    def update_status(self,
-                     queue_id: str,
-                     status: QueueStatus,
-                     error_message: Optional[str] = None,
-                     result: Optional[Dict[str, Any]] = None):
+    def update_status(
+        self,
+        queue_id: str,
+        status: QueueStatus,
+        error_message: Optional[str] = None,
+        result: Optional[dict[str, Any]] = None,
+    ):
         """Update queue item status.
 
         Args:
@@ -207,25 +233,31 @@ class Queue:
             status: New status
             error_message: Error message if failed
             result: Result data if completed
+
         """
         with self._lock:
             with sqlite3.connect(self.db_path) as conn:
-                processed_at = datetime.now().isoformat() if status in [
-                    QueueStatus.COMPLETED, QueueStatus.FAILED
-                ] else None
+                processed_at = (
+                    datetime.now().isoformat()
+                    if status in [QueueStatus.COMPLETED, QueueStatus.FAILED]
+                    else None
+                )
 
-                conn.execute('''
+                conn.execute(
+                    """
                     UPDATE queue
                     SET status = ?, processed_at = ?,
                         error_message = ?, result = ?
                     WHERE id = ?
-                ''', (
-                    status.value,
-                    processed_at,
-                    error_message,
-                    json.dumps(result) if result else None,
-                    queue_id
-                ))
+                """,
+                    (
+                        status.value,
+                        processed_at,
+                        error_message,
+                        json.dumps(result) if result else None,
+                        queue_id,
+                    ),
+                )
                 conn.commit()
 
     def increment_retry(self, queue_id: str) -> int:
@@ -236,16 +268,20 @@ class Queue:
 
         Returns:
             New retry count
+
         """
         with self._lock:
             with sqlite3.connect(self.db_path) as conn:
-                cursor = conn.execute('''
+                cursor = conn.execute(
+                    """
                     UPDATE queue
                     SET retry_count = retry_count + 1,
                         status = ?
                     WHERE id = ?
                     RETURNING retry_count
-                ''', (QueueStatus.PENDING.value, queue_id))
+                """,
+                    (QueueStatus.PENDING.value, queue_id),
+                )
 
                 result = cursor.fetchone()
                 conn.commit()
@@ -259,18 +295,22 @@ class Queue:
 
         Returns:
             QueueItem or None if not found
+
         """
         with sqlite3.connect(self.db_path) as conn:
-            cursor = conn.execute('''
+            cursor = conn.execute(
+                """
                 SELECT * FROM queue WHERE id = ?
-            ''', (queue_id,))
+            """,
+                (queue_id,),
+            )
 
             row = cursor.fetchone()
             return QueueItem.from_row(row) if row else None
 
-    def list_items(self,
-                   status: Optional[QueueStatus] = None,
-                   limit: int = 50) -> List[QueueItem]:
+    def list_items(
+        self, status: Optional[QueueStatus] = None, limit: int = 50
+    ) -> list[QueueItem]:
         """List queue items.
 
         Args:
@@ -279,21 +319,28 @@ class Queue:
 
         Returns:
             List of QueueItems
+
         """
         with sqlite3.connect(self.db_path) as conn:
             if status:
-                cursor = conn.execute('''
+                cursor = conn.execute(
+                    """
                     SELECT * FROM queue
                     WHERE status = ?
                     ORDER BY created_at DESC
                     LIMIT ?
-                ''', (status.value, limit))
+                """,
+                    (status.value, limit),
+                )
             else:
-                cursor = conn.execute('''
+                cursor = conn.execute(
+                    """
                     SELECT * FROM queue
                     ORDER BY created_at DESC
                     LIMIT ?
-                ''', (limit,))
+                """,
+                    (limit,),
+                )
 
             return [QueueItem.from_row(row) for row in cursor.fetchall()]
 
@@ -302,12 +349,16 @@ class Queue:
 
         Returns:
             Number of pending items
+
         """
         with sqlite3.connect(self.db_path) as conn:
-            cursor = conn.execute('''
+            cursor = conn.execute(
+                """
                 SELECT COUNT(*) FROM queue
                 WHERE status = ?
-            ''', (QueueStatus.PENDING.value,))
+            """,
+                (QueueStatus.PENDING.value,),
+            )
 
             return cursor.fetchone()[0]
 
@@ -316,20 +367,24 @@ class Queue:
 
         Args:
             days: Delete items older than this many days
+
         """
         cutoff_date = (datetime.now() - timedelta(days=days)).isoformat()
 
         with self._lock:
             with sqlite3.connect(self.db_path) as conn:
-                conn.execute('''
+                conn.execute(
+                    """
                     DELETE FROM queue
                     WHERE status IN (?, ?)
                     AND processed_at < ?
-                ''', (
-                    QueueStatus.COMPLETED.value,
-                    QueueStatus.FAILED.value,
-                    cutoff_date
-                ))
+                """,
+                    (
+                        QueueStatus.COMPLETED.value,
+                        QueueStatus.FAILED.value,
+                        cutoff_date,
+                    ),
+                )
                 conn.commit()
 
     def reset_stuck_items(self, timeout_minutes: int = 30):
@@ -337,39 +392,46 @@ class Queue:
 
         Args:
             timeout_minutes: Consider items stuck after this many minutes
+
         """
         cutoff_time = (datetime.now() - timedelta(minutes=timeout_minutes)).isoformat()
 
         with self._lock:
             with sqlite3.connect(self.db_path) as conn:
-                conn.execute('''
+                conn.execute(
+                    """
                     UPDATE queue
                     SET status = ?, error_message = ?
                     WHERE status = ?
                     AND created_at < ?
-                ''', (
-                    QueueStatus.PENDING.value,
-                    "Reset from stuck processing state",
-                    QueueStatus.PROCESSING.value,
-                    cutoff_time
-                ))
+                """,
+                    (
+                        QueueStatus.PENDING.value,
+                        "Reset from stuck processing state",
+                        QueueStatus.PROCESSING.value,
+                        cutoff_time,
+                    ),
+                )
                 conn.commit()
 
-    def get_stats(self) -> Dict[str, int]:
+    def get_stats(self) -> dict[str, int]:
         """Get queue statistics.
 
         Returns:
             Dictionary with counts by status
+
         """
         with sqlite3.connect(self.db_path) as conn:
-            cursor = conn.execute('''
+            cursor = conn.execute(
+                """
                 SELECT status, COUNT(*)
                 FROM queue
                 GROUP BY status
-            ''')
+            """
+            )
 
             stats = {status.value: 0 for status in QueueStatus}
             for status, count in cursor.fetchall():
                 stats[status] = count
 
-            return stats
+            return stats

mcp_ticketer/queue/run_worker.py

@@ -8,8 +8,7 @@ from .worker import Worker
 
 # Set up logging
 logging.basicConfig(
-    level=logging.INFO,
-    format='%(asctime)s - %(name)s - %(levelname)s - %(message)s'
+    level=logging.INFO, format="%(asctime)s - %(name)s - %(levelname)s - %(message)s"
 )
 logger = logging.getLogger(__name__)
 
@@ -35,4 +34,4 @@ def main():
 
 
 if __name__ == "__main__":
-    main()
+    main()