mcp-ticketer 0.1.20__py3-none-any.whl → 0.1.22__py3-none-any.whl

mcp_ticketer/core/http_client.py

@@ -2,19 +2,19 @@
 
 import asyncio
 import logging
-from typing import Dict, Any, Optional, List, Union, Callable
-from datetime import datetime, timedelta
-from enum import Enum
 import time
+from enum import Enum
+from typing import Any, Dict, List, Optional, Union
 
 import httpx
-from httpx import AsyncClient, HTTPStatusError, TimeoutException
+from httpx import AsyncClient, TimeoutException
 
 logger = logging.getLogger(__name__)
 
 
 class HTTPMethod(str, Enum):
     """HTTP methods."""
+
     GET = "GET"
     POST = "POST"
     PUT = "PUT"
@@ -33,7 +33,7 @@ class RetryConfig:
         exponential_base: float = 2.0,
         jitter: bool = True,
         retry_on_status: Optional[List[int]] = None,
-        retry_on_exceptions: Optional[List[type]] = None
+        retry_on_exceptions: Optional[List[type]] = None,
     ):
         self.max_retries = max_retries
         self.initial_delay = initial_delay
@@ -41,7 +41,11 @@ class RetryConfig:
         self.exponential_base = exponential_base
         self.jitter = jitter
         self.retry_on_status = retry_on_status or [429, 502, 503, 504]
-        self.retry_on_exceptions = retry_on_exceptions or [TimeoutException, httpx.ConnectTimeout, httpx.ReadTimeout]
+        self.retry_on_exceptions = retry_on_exceptions or [
+            TimeoutException,
+            httpx.ConnectTimeout,
+            httpx.ReadTimeout,
+        ]
 
 
 class RateLimiter:
@@ -53,6 +57,7 @@ class RateLimiter:
         Args:
             max_requests: Maximum number of requests allowed
             time_window: Time window in seconds
+
         """
         self.max_requests = max_requests
         self.time_window = time_window
@@ -69,7 +74,7 @@ class RateLimiter:
             time_passed = now - self.last_update
             self.tokens = min(
                 self.max_requests,
-                self.tokens + (time_passed / self.time_window) * self.max_requests
+                self.tokens + (time_passed / self.time_window) * self.max_requests,
             )
             self.last_update = now
 
@@ -95,7 +100,7 @@ class BaseHTTPClient:
         retry_config: Optional[RetryConfig] = None,
         rate_limiter: Optional[RateLimiter] = None,
         verify_ssl: bool = True,
-        follow_redirects: bool = True
+        follow_redirects: bool = True,
     ):
         """Initialize HTTP client.
 
@@ -108,6 +113,7 @@ class BaseHTTPClient:
             rate_limiter: Rate limiter instance
             verify_ssl: Whether to verify SSL certificates
             follow_redirects: Whether to follow redirects
+
         """
         self.base_url = base_url.rstrip("/")
         self.default_headers = headers or {}
@@ -137,11 +143,13 @@ class BaseHTTPClient:
                 auth=self.auth,
                 timeout=self.timeout,
                 verify=self.verify_ssl,
-                follow_redirects=self.follow_redirects
+                follow_redirects=self.follow_redirects,
             )
         return self._client
 
-    async def _calculate_delay(self, attempt: int, response: Optional[httpx.Response] = None) -> float:
+    async def _calculate_delay(
+        self, attempt: int, response: Optional[httpx.Response] = None
+    ) -> float:
         """Calculate delay for retry attempt."""
         if response and response.status_code == 429:
             # Use Retry-After header if available
@@ -162,7 +170,8 @@ class BaseHTTPClient:
         # Add jitter to prevent thundering herd
         if self.retry_config.jitter:
             import random
-            delay *= (0.5 + random.random() * 0.5)
+
+            delay *= 0.5 + random.random() * 0.5
 
         return delay
 
@@ -170,7 +179,7 @@ class BaseHTTPClient:
         self,
         exception: Exception,
         response: Optional[httpx.Response] = None,
-        attempt: int = 1
+        attempt: int = 1,
     ) -> bool:
         """Determine if request should be retried."""
         if attempt >= self.retry_config.max_retries:
@@ -197,7 +206,7 @@ class BaseHTTPClient:
         headers: Optional[Dict[str, str]] = None,
         timeout: Optional[float] = None,
         retry_count: int = 0,
-        **kwargs
+        **kwargs,
     ) -> httpx.Response:
         """Make HTTP request with retry and rate limiting.
 
@@ -218,6 +227,7 @@ class BaseHTTPClient:
         Raises:
             HTTPStatusError: On HTTP errors
             TimeoutException: On timeout
+
         """
         # Rate limiting
         if self.rate_limiter:
@@ -243,7 +253,7 @@ class BaseHTTPClient:
                 params=params,
                 headers=request_headers,
                 timeout=timeout or self.timeout,
-                **kwargs
+                **kwargs,
             )
 
             # Update stats
@@ -258,7 +268,7 @@ class BaseHTTPClient:
             self.stats["errors"] += 1
 
             # Check if we should retry
-            response = getattr(e, 'response', None)
+            response = getattr(e, "response", None)
             if self._should_retry(e, response, retry_count + 1):
                 delay = await self._calculate_delay(retry_count + 1, response)
 
@@ -269,7 +279,15 @@ class BaseHTTPClient:
 
                 await asyncio.sleep(delay)
                 return await self.request(
-                    method, endpoint, data, json, params, headers, timeout, retry_count + 1, **kwargs
+                    method,
+                    endpoint,
+                    data,
+                    json,
+                    params,
+                    headers,
+                    timeout,
+                    retry_count + 1,
+                    **kwargs,
                 )
 
             # No more retries, re-raise the exception
@@ -364,6 +382,7 @@ class GitHubHTTPClient(BaseHTTPClient):
         Args:
             token: GitHub API token
             api_url: GitHub API URL
+
         """
         headers = {
             "Authorization": f"Bearer {token}",
@@ -379,9 +398,8 @@ class GitHubHTTPClient(BaseHTTPClient):
             headers=headers,
             rate_limiter=rate_limiter,
             retry_config=RetryConfig(
-                max_retries=3,
-                retry_on_status=[429, 502, 503, 504, 522, 524]
-            )
+                max_retries=3, retry_on_status=[429, 502, 503, 504, 522, 524]
+            ),
         )
 
 
@@ -394,7 +412,7 @@ class JiraHTTPClient(BaseHTTPClient):
         api_token: str,
         server_url: str,
         is_cloud: bool = True,
-        verify_ssl: bool = True
+        verify_ssl: bool = True,
     ):
         """Initialize JIRA HTTP client.
 
@@ -404,13 +422,13 @@ class JiraHTTPClient(BaseHTTPClient):
             server_url: JIRA server URL
             is_cloud: Whether this is JIRA Cloud
             verify_ssl: Whether to verify SSL certificates
+
         """
-        api_base = f"{server_url}/rest/api/3" if is_cloud else f"{server_url}/rest/api/2"
+        api_base = (
+            f"{server_url}/rest/api/3" if is_cloud else f"{server_url}/rest/api/2"
+        )
 
-        headers = {
-            "Accept": "application/json",
-            "Content-Type": "application/json"
-        }
+        headers = {"Accept": "application/json", "Content-Type": "application/json"}
 
         auth = httpx.BasicAuth(email, api_token)
 
@@ -424,7 +442,6 @@ class JiraHTTPClient(BaseHTTPClient):
             rate_limiter=rate_limiter,
             verify_ssl=verify_ssl,
             retry_config=RetryConfig(
-                max_retries=3,
-                retry_on_status=[429, 502, 503, 504]
-            )
-        )
+                max_retries=3, retry_on_status=[429, 502, 503, 504]
+            ),
+        )

mcp_ticketer/core/mappers.py

@@ -1,17 +1,16 @@
 """Centralized mapping utilities for state and priority conversions."""
 
 import logging
-from typing import Dict, List, Optional, Any, TypeVar, Generic, Callable
-from functools import lru_cache
 from abc import ABC, abstractmethod
-from enum import Enum
+from functools import lru_cache
+from typing import Any, Dict, Generic, List, Optional, TypeVar
 
-from .models import TicketState, Priority
+from .models import Priority, TicketState
 
 logger = logging.getLogger(__name__)
 
-T = TypeVar('T')
-U = TypeVar('U')
+T = TypeVar("T")
+U = TypeVar("U")
 
 
 class BiDirectionalDict(Generic[T, U]):
@@ -22,6 +21,7 @@ class BiDirectionalDict(Generic[T, U]):
 
         Args:
             mapping: Forward mapping dictionary
+
         """
         self._forward: Dict[T, U] = mapping.copy()
         self._reverse: Dict[U, T] = {v: k for k, v in mapping.items()}
@@ -64,6 +64,7 @@ class BaseMapper(ABC):
 
         Args:
             cache_size: Size of LRU cache for mapping results
+
         """
         self.cache_size = cache_size
         self._cache: Dict[str, Any] = {}
@@ -81,12 +82,15 @@ class BaseMapper(ABC):
 class StateMapper(BaseMapper):
     """Universal state mapping utility."""
 
-    def __init__(self, adapter_type: str, custom_mappings: Optional[Dict[str, Any]] = None):
+    def __init__(
+        self, adapter_type: str, custom_mappings: Optional[Dict[str, Any]] = None
+    ):
         """Initialize state mapper.
 
         Args:
             adapter_type: Type of adapter (github, jira, linear, etc.)
             custom_mappings: Custom state mappings to override defaults
+
         """
         super().__init__()
         self.adapter_type = adapter_type
@@ -104,11 +108,11 @@ class StateMapper(BaseMapper):
             "github": {
                 TicketState.OPEN: "open",
                 TicketState.IN_PROGRESS: "open",  # Uses labels
-                TicketState.READY: "open",        # Uses labels
-                TicketState.TESTED: "open",       # Uses labels
+                TicketState.READY: "open",  # Uses labels
+                TicketState.TESTED: "open",  # Uses labels
                 TicketState.DONE: "closed",
-                TicketState.WAITING: "open",      # Uses labels
-                TicketState.BLOCKED: "open",      # Uses labels
+                TicketState.WAITING: "open",  # Uses labels
+                TicketState.BLOCKED: "open",  # Uses labels
                 TicketState.CLOSED: "closed",
             },
             "jira": {
@@ -124,8 +128,8 @@ class StateMapper(BaseMapper):
             "linear": {
                 TicketState.OPEN: "backlog",
                 TicketState.IN_PROGRESS: "started",
-                TicketState.READY: "started",      # Uses labels
-                TicketState.TESTED: "started",     # Uses labels
+                TicketState.READY: "started",  # Uses labels
+                TicketState.TESTED: "started",  # Uses labels
                 TicketState.DONE: "completed",
                 TicketState.WAITING: "unstarted",  # Uses labels
                 TicketState.BLOCKED: "unstarted",  # Uses labels
@@ -140,7 +144,7 @@ class StateMapper(BaseMapper):
                 TicketState.WAITING: "waiting",
                 TicketState.BLOCKED: "blocked",
                 TicketState.CLOSED: "closed",
-            }
+            },
         }
 
         mapping = default_mappings.get(self.adapter_type, {})
@@ -160,6 +164,7 @@ class StateMapper(BaseMapper):
 
         Returns:
             Universal ticket state
+
         """
         cache_key = f"to_system_{adapter_state}"
         if cache_key in self._cache:
@@ -172,12 +177,17 @@ class StateMapper(BaseMapper):
             # Fallback: try case-insensitive matching
             adapter_state_lower = adapter_state.lower()
             for universal_state, system_state in mapping.items():
-                if isinstance(system_state, str) and system_state.lower() == adapter_state_lower:
+                if (
+                    isinstance(system_state, str)
+                    and system_state.lower() == adapter_state_lower
+                ):
                     result = universal_state
                     break
 
         if result is None:
-            logger.warning(f"Unknown {self.adapter_type} state: {adapter_state}, defaulting to OPEN")
+            logger.warning(
+                f"Unknown {self.adapter_type} state: {adapter_state}, defaulting to OPEN"
+            )
             result = TicketState.OPEN
 
         self._cache[cache_key] = result
@@ -191,6 +201,7 @@ class StateMapper(BaseMapper):
 
         Returns:
             State in adapter format
+
         """
         cache_key = f"from_system_{system_state.value}"
         if cache_key in self._cache:
@@ -200,7 +211,9 @@ class StateMapper(BaseMapper):
         result = mapping.get_forward(system_state)
 
         if result is None:
-            logger.warning(f"No {self.adapter_type} mapping for state: {system_state}, using default")
+            logger.warning(
+                f"No {self.adapter_type} mapping for state: {system_state}, using default"
+            )
             # Fallback to first available state
             available_states = mapping.reverse_keys()
             result = available_states[0] if available_states else "open"
@@ -224,6 +237,7 @@ class StateMapper(BaseMapper):
 
         Returns:
             Label name if state requires a label, None otherwise
+
         """
         if not self.supports_state_labels():
             return None
@@ -243,12 +257,15 @@ class StateMapper(BaseMapper):
 class PriorityMapper(BaseMapper):
     """Universal priority mapping utility."""
 
-    def __init__(self, adapter_type: str, custom_mappings: Optional[Dict[str, Any]] = None):
+    def __init__(
+        self, adapter_type: str, custom_mappings: Optional[Dict[str, Any]] = None
+    ):
         """Initialize priority mapper.
 
         Args:
             adapter_type: Type of adapter (github, jira, linear, etc.)
             custom_mappings: Custom priority mappings to override defaults
+
         """
         super().__init__()
         self.adapter_type = adapter_type
@@ -286,7 +303,7 @@ class PriorityMapper(BaseMapper):
                 Priority.HIGH: "high",
                 Priority.MEDIUM: "medium",
                 Priority.LOW: "low",
-            }
+            },
         }
 
         mapping = default_mappings.get(self.adapter_type, {})
@@ -306,6 +323,7 @@ class PriorityMapper(BaseMapper):
 
         Returns:
             Universal priority
+
         """
         cache_key = f"to_system_{adapter_priority}"
         if cache_key in self._cache:
@@ -319,18 +337,32 @@ class PriorityMapper(BaseMapper):
             if isinstance(adapter_priority, str):
                 adapter_priority_lower = adapter_priority.lower()
                 for universal_priority, system_priority in mapping.items():
-                    if isinstance(system_priority, str) and system_priority.lower() == adapter_priority_lower:
+                    if (
+                        isinstance(system_priority, str)
+                        and system_priority.lower() == adapter_priority_lower
+                    ):
                         result = universal_priority
                         break
                     # Check for common priority patterns
-                    elif ("critical" in adapter_priority_lower or "urgent" in adapter_priority_lower or
-                          "highest" in adapter_priority_lower or adapter_priority_lower in ["p0", "0"]):
+                    elif (
+                        "critical" in adapter_priority_lower
+                        or "urgent" in adapter_priority_lower
+                        or "highest" in adapter_priority_lower
+                        or adapter_priority_lower in ["p0", "0"]
+                    ):
                         result = Priority.CRITICAL
                         break
-                    elif ("high" in adapter_priority_lower or adapter_priority_lower in ["p1", "1"]):
+                    elif "high" in adapter_priority_lower or adapter_priority_lower in [
+                        "p1",
+                        "1",
+                    ]:
                         result = Priority.HIGH
                         break
-                    elif ("low" in adapter_priority_lower or adapter_priority_lower in ["p3", "3", "lowest"]):
+                    elif "low" in adapter_priority_lower or adapter_priority_lower in [
+                        "p3",
+                        "3",
+                        "lowest",
+                    ]:
                         result = Priority.LOW
                         break
             elif isinstance(adapter_priority, (int, float)):
@@ -345,7 +377,9 @@ class PriorityMapper(BaseMapper):
                     result = Priority.MEDIUM
 
         if result is None:
-            logger.warning(f"Unknown {self.adapter_type} priority: {adapter_priority}, defaulting to MEDIUM")
+            logger.warning(
+                f"Unknown {self.adapter_type} priority: {adapter_priority}, defaulting to MEDIUM"
+            )
             result = Priority.MEDIUM
 
         self._cache[cache_key] = result
@@ -359,6 +393,7 @@ class PriorityMapper(BaseMapper):
 
         Returns:
             Priority in adapter format
+
         """
         cache_key = f"from_system_{system_priority.value}"
         if cache_key in self._cache:
@@ -368,7 +403,9 @@ class PriorityMapper(BaseMapper):
         result = mapping.get_forward(system_priority)
 
         if result is None:
-            logger.warning(f"No {self.adapter_type} mapping for priority: {system_priority}")
+            logger.warning(
+                f"No {self.adapter_type} mapping for priority: {system_priority}"
+            )
             # Fallback based on adapter type
             fallback_mappings = {
                 "github": "P2",
@@ -393,6 +430,7 @@ class PriorityMapper(BaseMapper):
 
         Returns:
             List of possible label names
+
         """
         if self.adapter_type != "github":
             return []
@@ -415,6 +453,7 @@ class PriorityMapper(BaseMapper):
 
         Returns:
             Detected priority
+
         """
         if self.adapter_type != "github":
             return Priority.MEDIUM
@@ -422,7 +461,12 @@ class PriorityMapper(BaseMapper):
         labels_lower = [label.lower() for label in labels]
 
         # Check each priority level
-        for priority in [Priority.CRITICAL, Priority.HIGH, Priority.LOW, Priority.MEDIUM]:
+        for priority in [
+            Priority.CRITICAL,
+            Priority.HIGH,
+            Priority.LOW,
+            Priority.MEDIUM,
+        ]:
             priority_labels = self.get_priority_labels(priority)
             for priority_label in priority_labels:
                 if priority_label.lower() in labels_lower:
@@ -439,9 +483,7 @@ class MapperRegistry:
 
     @classmethod
     def get_state_mapper(
-        self,
-        adapter_type: str,
-        custom_mappings: Optional[Dict[str, Any]] = None
+        self, adapter_type: str, custom_mappings: Optional[Dict[str, Any]] = None
     ) -> StateMapper:
         """Get or create state mapper for adapter type.
 
@@ -451,6 +493,7 @@ class MapperRegistry:
 
         Returns:
             State mapper instance
+
         """
         cache_key = f"{adapter_type}_{hash(str(custom_mappings))}"
         if cache_key not in self._state_mappers:
@@ -459,9 +502,7 @@ class MapperRegistry:
 
     @classmethod
     def get_priority_mapper(
-        self,
-        adapter_type: str,
-        custom_mappings: Optional[Dict[str, Any]] = None
+        self, adapter_type: str, custom_mappings: Optional[Dict[str, Any]] = None
     ) -> PriorityMapper:
         """Get or create priority mapper for adapter type.
 
@@ -471,10 +512,13 @@ class MapperRegistry:
 
         Returns:
             Priority mapper instance
+
         """
         cache_key = f"{adapter_type}_{hash(str(custom_mappings))}"
         if cache_key not in self._priority_mappers:
-            self._priority_mappers[cache_key] = PriorityMapper(adapter_type, custom_mappings)
+            self._priority_mappers[cache_key] = PriorityMapper(
+                adapter_type, custom_mappings
+            )
         return self._priority_mappers[cache_key]
 
     @classmethod
@@ -489,4 +533,4 @@ class MapperRegistry:
     def reset(cls) -> None:
         """Reset all mappers."""
         cls._state_mappers.clear()
-        cls._priority_mappers.clear()
+        cls._priority_mappers.clear()

mcp_ticketer/core/models.py

@@ -2,12 +2,14 @@
 
 from datetime import datetime
 from enum import Enum
-from typing import Optional, Dict, Any, List
-from pydantic import BaseModel, Field, ConfigDict
+from typing import Any, Dict, List, Optional
+
+from pydantic import BaseModel, ConfigDict, Field
 
 
 class Priority(str, Enum):
     """Universal priority levels."""
+
     LOW = "low"
     MEDIUM = "medium"
     HIGH = "high"
@@ -16,14 +18,16 @@ class Priority(str, Enum):
 
 class TicketType(str, Enum):
     """Ticket type hierarchy."""
-    EPIC = "epic"        # Strategic level (Projects in Linear, Milestones in GitHub)
-    ISSUE = "issue"      # Work item level (standard issues/tasks)
-    TASK = "task"        # Sub-task level (sub-issues, checkboxes)
+
+    EPIC = "epic"  # Strategic level (Projects in Linear, Milestones in GitHub)
+    ISSUE = "issue"  # Work item level (standard issues/tasks)
+    TASK = "task"  # Sub-task level (sub-issues, checkboxes)
     SUBTASK = "subtask"  # Alias for task (for clarity)
 
 
 class TicketState(str, Enum):
     """Universal ticket states with state machine abstraction."""
+
     OPEN = "open"
     IN_PROGRESS = "in_progress"
     READY = "ready"
@@ -54,6 +58,7 @@ class TicketState(str, Enum):
 
 class BaseTicket(BaseModel):
     """Base model for all ticket types."""
+
     model_config = ConfigDict(use_enum_values=True)
 
     id: Optional[str] = Field(None, description="Unique identifier")
@@ -67,17 +72,18 @@ class BaseTicket(BaseModel):
 
     # Metadata for field mapping to different systems
     metadata: Dict[str, Any] = Field(
-        default_factory=dict,
-        description="System-specific metadata and field mappings"
+        default_factory=dict, description="System-specific metadata and field mappings"
     )
 
 
 class Epic(BaseTicket):
     """Epic - highest level container for work (Projects in Linear, Milestones in GitHub)."""
-    ticket_type: TicketType = Field(default=TicketType.EPIC, frozen=True, description="Always EPIC type")
+
+    ticket_type: TicketType = Field(
+        default=TicketType.EPIC, frozen=True, description="Always EPIC type"
+    )
     child_issues: List[str] = Field(
-        default_factory=list,
-        description="IDs of child issues"
+        default_factory=list, description="IDs of child issues"
     )
 
     def validate_hierarchy(self) -> List[str]:
@@ -85,6 +91,7 @@ class Epic(BaseTicket):
 
         Returns:
             List of validation errors (empty if valid)
+
         """
         # Epics don't have parents in our hierarchy
         return []
@@ -92,7 +99,10 @@ class Epic(BaseTicket):
 
 class Task(BaseTicket):
     """Task - individual work item (can be ISSUE or TASK type)."""
-    ticket_type: TicketType = Field(default=TicketType.ISSUE, description="Ticket type in hierarchy")
+
+    ticket_type: TicketType = Field(
+        default=TicketType.ISSUE, description="Ticket type in hierarchy"
+    )
     parent_issue: Optional[str] = Field(None, description="Parent issue ID (for tasks)")
     parent_epic: Optional[str] = Field(None, description="Parent epic ID (for issues)")
     assignee: Optional[str] = Field(None, description="Assigned user")
@@ -119,6 +129,7 @@ class Task(BaseTicket):
 
         Returns:
             List of validation errors (empty if valid)
+
         """
         errors = []
 
@@ -132,13 +143,16 @@ class Task(BaseTicket):
 
         # Tasks should not have both parent_issue and parent_epic
         if self.is_task() and self.parent_epic:
-            errors.append("Tasks should only have parent_issue, not parent_epic (epic comes from parent issue)")
+            errors.append(
+                "Tasks should only have parent_issue, not parent_epic (epic comes from parent issue)"
+            )
 
         return errors
 
 
 class Comment(BaseModel):
     """Comment on a ticket."""
+
     model_config = ConfigDict(use_enum_values=True)
 
     id: Optional[str] = Field(None, description="Comment ID")
@@ -147,17 +161,17 @@ class Comment(BaseModel):
     content: str = Field(..., min_length=1, description="Comment text")
     created_at: Optional[datetime] = Field(None, description="Creation timestamp")
     metadata: Dict[str, Any] = Field(
-        default_factory=dict,
-        description="System-specific metadata"
+        default_factory=dict, description="System-specific metadata"
     )
 
 
 class SearchQuery(BaseModel):
     """Search query parameters."""
+
     query: Optional[str] = Field(None, description="Text search query")
     state: Optional[TicketState] = Field(None, description="Filter by state")
     priority: Optional[Priority] = Field(None, description="Filter by priority")
     tags: Optional[List[str]] = Field(None, description="Filter by tags")
     assignee: Optional[str] = Field(None, description="Filter by assignee")
     limit: int = Field(10, gt=0, le=100, description="Maximum results")
-    offset: int = Field(0, ge=0, description="Result offset for pagination")
+    offset: int = Field(0, ge=0, description="Result offset for pagination")