auto-coder 0.1.399__py3-none-any.whl → 0.1.400__py3-none-any.whl

autocoder/common/pull_requests/base_provider.py

@@ -0,0 +1,191 @@
+"""
+Pull Request 平台提供者基类
+"""
+from abc import ABC, abstractmethod
+from typing import Optional, Dict, Any, List
+import requests
+import time
+from loguru import logger
+
+from .models import RepoInfo, PRData, PRResult, PRInfo, PRConfig
+from .exceptions import (
+    PRError, NetworkError, AuthenticationError, RateLimitError,
+    RepositoryNotFoundError, ValidationError
+)
+
+
+class BasePlatformProvider(ABC):
+    """平台提供者基类，定义统一接口"""
+    
+    def __init__(self, config: PRConfig):
+        self.config = config
+        self.session = self._create_session()
+    
+    def _create_session(self) -> requests.Session:
+        """创建HTTP会话"""
+        session = requests.Session()
+        session.headers.update({
+            'User-Agent': 'AutoCoder-PR/1.0',
+            'Authorization': self._get_auth_header(),
+            'Accept': 'application/json',
+            'Content-Type': 'application/json'
+        })
+        session.verify = self.config.verify_ssl
+        return session
+    
+    @abstractmethod
+    def _get_auth_header(self) -> str:
+        """获取认证头"""
+        pass
+    
+    def _make_request(
+        self, 
+        method: str, 
+        url: str, 
+        data: Optional[Dict[str, Any]] = None,
+        params: Optional[Dict[str, str]] = None,
+        retry_count: Optional[int] = None
+    ) -> requests.Response:
+        """发送HTTP请求，包含重试逻辑"""
+        
+        if retry_count is None:
+            retry_count = self.config.retry_count
+        
+        last_exception = None
+        
+        for attempt in range(retry_count + 1):
+            try:
+                response = self.session.request(
+                    method=method,
+                    url=url,
+                    json=data,
+                    params=params,
+                    timeout=self.config.timeout
+                )
+                
+                if response.status_code == 401:
+                    raise AuthenticationError("认证失败，请检查token是否正确")
+                elif response.status_code == 404:
+                    raise RepositoryNotFoundError("仓库或资源不存在")
+                elif response.status_code == 429:
+                    retry_after = int(response.headers.get('Retry-After', 60))
+                    raise RateLimitError(f"API限流，请等待{retry_after}秒后重试", retry_after=retry_after)
+                elif response.status_code == 422:
+                    # 422 通常是验证错误，尝试解析响应内容获取详细错误信息
+                    try:
+                        error_data = response.json()
+                        if 'errors' in error_data:
+                            errors = error_data['errors']
+                            error_msgs = []
+                            for error in errors:
+                                if isinstance(error, dict):
+                                    field = error.get('field', '')
+                                    code = error.get('code', '')
+                                    message = error.get('message', str(error))
+                                    if field and code:
+                                        error_msgs.append(f"{field}: {message} (code: {code})")
+                                    else:
+                                        error_msgs.append(message)
+                                else:
+                                    error_msgs.append(str(error))
+                            raise ValidationError(f"请求验证失败: {'; '.join(error_msgs)}")
+                        elif 'message' in error_data:
+                            raise ValidationError(f"请求验证失败: {error_data['message']}")
+                        else:
+                            raise ValidationError(f"请求验证失败: {response.text}")
+                    except (ValueError, KeyError):
+                        raise ValidationError(f"请求验证失败: HTTP 422 - {response.text}")
+                elif response.status_code >= 400:
+                    try:
+                        error_data = response.json()
+                        if 'message' in error_data:
+                            raise PRError(f"API请求失败: HTTP {response.status_code} - {error_data['message']}")
+                        else:
+                            raise PRError(f"API请求失败: HTTP {response.status_code} - {response.text}")
+                    except (ValueError, KeyError):
+                        raise PRError(f"API请求失败: HTTP {response.status_code} - {response.text}")
+                
+                return response
+                
+            except (requests.exceptions.RequestException, ConnectionError) as e:
+                last_exception = NetworkError(f"网络请求失败: {str(e)}")
+                
+                if attempt < retry_count:
+                    delay = 2 ** attempt
+                    logger.warning(f"请求失败，{delay}秒后重试")
+                    time.sleep(delay)
+                    continue
+                
+            except RateLimitError as e:
+                if attempt < retry_count:
+                    logger.warning(f"遇到限流，等待{e.retry_after}秒后重试")
+                    time.sleep(e.retry_after)
+                    continue
+                raise
+        
+        if last_exception:
+            raise last_exception
+        
+        raise PRError("请求失败，已达到最大重试次数")
+    
+    def _validate_pr_data(self, pr_data: PRData) -> None:
+        """验证PR数据"""
+        if not pr_data.title.strip():
+            raise ValidationError("PR标题不能为空")
+        if not pr_data.source_branch.strip():
+            raise ValidationError("源分支不能为空")
+        if not pr_data.target_branch.strip():
+            raise ValidationError("目标分支不能为空")
+        if pr_data.source_branch == pr_data.target_branch:
+            raise ValidationError("源分支和目标分支不能相同")
+    
+    def _validate_repo_info(self, repo_info: RepoInfo) -> None:
+        """验证仓库信息"""
+        if not repo_info.owner.strip():
+            raise ValidationError("仓库所有者不能为空")
+        if not repo_info.name.strip():
+            raise ValidationError("仓库名称不能为空")
+    
+    @abstractmethod
+    def create_pr(self, repo_info: RepoInfo, pr_data: PRData) -> PRResult:
+        """创建 Pull Request"""
+        pass
+    
+    @abstractmethod
+    def get_pr(self, repo_info: RepoInfo, pr_number: int) -> PRResult:
+        """获取 PR 信息"""
+        pass
+    
+    @abstractmethod
+    def update_pr(self, repo_info: RepoInfo, pr_number: int, **kwargs) -> PRResult:
+        """更新 PR"""
+        pass
+    
+    @abstractmethod
+    def close_pr(self, repo_info: RepoInfo, pr_number: int) -> PRResult:
+        """关闭 PR"""
+        pass
+    
+    @abstractmethod
+    def merge_pr(self, repo_info: RepoInfo, pr_number: int, **kwargs) -> PRResult:
+        """合并 PR"""
+        pass
+    
+    @abstractmethod
+    def list_prs(
+        self, 
+        repo_info: RepoInfo, 
+        state: str = "open",
+        per_page: int = 30,
+        page: int = 1
+    ) -> List[PRInfo]:
+        """列出仓库的PR"""
+        pass
+    
+    def health_check(self) -> bool:
+        """检查连接和认证状态"""
+        try:
+            response = self._make_request('GET', f"{self.config.base_url}/user")
+            return response.status_code == 200
+        except Exception:
+            return False

autocoder/common/pull_requests/config.py

@@ -0,0 +1,66 @@
+"""
+Pull Request 配置管理
+"""
+import os
+from typing import Dict, Any, Optional
+from .models import PRConfig, PlatformType
+from .exceptions import ConfigurationError
+
+
+def get_config(platform: str, **overrides) -> PRConfig:
+    """
+    获取平台配置
+    
+    Args:
+        platform: 平台名称
+        **overrides: 配置覆盖参数
+    
+    Returns:
+        配置对象
+    """
+    # 从环境变量加载配置
+    env_config = _load_from_env(platform)
+    
+    # 合并配置
+    merged_config = {}
+    if env_config:
+        merged_config.update(env_config)
+    merged_config.update(overrides)
+    
+    # 验证必需的配置
+    if 'token' not in merged_config:
+        raise ConfigurationError(f"平台 {platform} 缺少必需的 token 配置")
+    
+    return PRConfig(platform=PlatformType(platform), **merged_config)
+
+
+def _load_from_env(platform: str) -> Dict[str, Any]:
+    """从环境变量加载配置"""
+    env_mappings = {
+        'github': {
+            'token': 'GITHUB_TOKEN',
+            'base_url': 'GITHUB_BASE_URL'
+        },
+        'gitlab': {
+            'token': 'GITLAB_TOKEN',
+            'base_url': 'GITLAB_BASE_URL'
+        },
+        'gitee': {
+            'token': 'GITEE_TOKEN',
+            'base_url': 'GITEE_BASE_URL'
+        },
+        'gitcode': {
+            'token': 'GITCODE_TOKEN',
+            'base_url': 'GITCODE_BASE_URL'
+        }
+    }
+    
+    mapping = env_mappings.get(platform, {})
+    config = {}
+    
+    for key, env_var in mapping.items():
+        value = os.getenv(env_var)
+        if value:
+            config[key] = value
+    
+    return config

autocoder/common/pull_requests/example.py

@@ -0,0 +1 @@
+ 

autocoder/common/pull_requests/exceptions.py

@@ -0,0 +1,46 @@
+"""
+Pull Request 模块自定义异常类
+"""
+from typing import Optional
+
+class PRError(Exception):
+    """Pull Request 操作基础异常"""
+    def __init__(self, message: str, error_code: Optional[str] = None, platform: Optional[str] = None):
+        self.message = message
+        self.error_code = error_code
+        self.platform = platform
+        super().__init__(message)
+
+class AuthenticationError(PRError):
+    """认证失败异常"""
+    pass
+
+class RepositoryNotFoundError(PRError):
+    """仓库不存在异常"""
+    pass
+
+class BranchNotFoundError(PRError):
+    """分支不存在异常"""
+    pass
+
+class NetworkError(PRError):
+    """网络错误异常"""
+    pass
+
+class RateLimitError(PRError):
+    """API 限流异常"""
+    def __init__(self, message: str, retry_after: int = 60, **kwargs):
+        self.retry_after = retry_after
+        super().__init__(message, **kwargs)
+
+class ValidationError(PRError):
+    """参数验证错误异常"""
+    pass
+
+class PlatformNotSupportedError(PRError):
+    """平台不支持异常"""
+    pass
+
+class ConfigurationError(PRError):
+    """配置错误异常"""
+    pass

autocoder/common/pull_requests/manager.py

@@ -0,0 +1,201 @@
+"""
+Pull Request 主管理器
+"""
+from typing import Optional, List, Dict, Any
+from loguru import logger
+
+from .models import PRConfig, PRData, PRResult, PRInfo, RepoInfo, PlatformType, DEFAULT_TEMPLATES
+from .providers import PROVIDERS
+from .utils import detect_platform_from_repo, get_repo_info_from_path, validate_repo_path
+from .exceptions import (
+    PRError, PlatformNotSupportedError, ConfigurationError, ValidationError
+)
+from .config import get_config
+
+
+class PullRequestManager:
+    """Pull Request 主管理器"""
+    
+    def __init__(self, config: Optional[PRConfig] = None):
+        self.config = config
+        self._provider = None
+        self._templates = DEFAULT_TEMPLATES.copy()
+    
+    def _get_provider(self, platform: Optional[str] = None, repo_path: Optional[str] = None):
+        """获取平台提供者"""
+        if self.config and not platform:
+            platform = self.config.platform.value
+        elif not platform and repo_path:
+            # 自动检测平台
+            detected_platform = detect_platform_from_repo(repo_path)
+            if not detected_platform:
+                raise PlatformNotSupportedError("无法从仓库路径检测平台类型")
+            platform = detected_platform.value
+        elif not platform:
+            raise ValidationError("必须指定平台类型或提供仓库路径")
+        
+        if platform not in PROVIDERS:
+            raise PlatformNotSupportedError(f"不支持的平台: {platform}")
+        
+        # 使用现有配置或创建新配置
+        if self.config and self.config.platform.value == platform:
+            config = self.config
+        else:
+            try:
+                config = get_config(platform)
+            except ConfigurationError:
+                raise ConfigurationError(f"平台 {platform} 的配置未找到")
+        
+        provider_class = PROVIDERS[platform]
+        return provider_class(config)
+    
+    def create_pull_request(
+        self,
+        repo_path: str,
+        source_branch: str,
+        target_branch: str,
+        title: str,
+        description: str = "",
+        labels: Optional[List[str]] = None,
+        assignees: Optional[List[str]] = None,
+        reviewers: Optional[List[str]] = None,
+        draft: bool = False,
+        template_type: Optional[str] = None,
+        template_vars: Optional[Dict[str, str]] = None,
+        platform: Optional[str] = None,
+        **kwargs
+    ) -> PRResult:
+        """创建 Pull Request"""
+        try:
+            # 验证仓库路径
+            repo_path = validate_repo_path(repo_path)
+            
+            # 获取仓库信息
+            repo_info = get_repo_info_from_path(repo_path)
+            if not repo_info:
+                raise ValidationError("无法获取仓库信息")
+            
+            # 获取提供者
+            provider = self._get_provider(platform, repo_path)
+            
+            # 创建PR数据
+            pr_data = PRData(
+                title=title,
+                description=description,
+                source_branch=source_branch,
+                target_branch=target_branch,
+                labels=labels or [],
+                assignees=assignees or [],
+                reviewers=reviewers or [],
+                draft=draft,
+                template_type=template_type,
+                template_vars=template_vars or {}
+            )
+            
+            # 创建PR
+            result = provider.create_pr(repo_info, pr_data)
+            
+            return result
+            
+        except Exception as e:
+            logger.error(f"创建PR失败: {e}")
+            return PRResult(
+                success=False,
+                error_message=str(e),
+                platform=PlatformType(platform) if platform else None
+            )
+    
+    def get_pull_request(
+        self,
+        repo_path: str,
+        pr_number: int,
+        platform: Optional[str] = None
+    ) -> PRResult:
+        """获取 Pull Request 信息"""
+        try:
+            repo_path = validate_repo_path(repo_path)
+            repo_info = get_repo_info_from_path(repo_path)
+            if not repo_info:
+                raise ValidationError("无法获取仓库信息")
+            
+            provider = self._get_provider(platform, repo_path)
+            return provider.get_pr(repo_info, pr_number)
+            
+        except Exception as e:
+            logger.error(f"获取PR失败: {e}")
+            return PRResult(
+                success=False,
+                error_message=str(e),
+                platform=PlatformType(platform) if platform else None
+            )
+    
+    def update_pull_request(
+        self,
+        repo_path: str,
+        pr_number: int,
+        platform: Optional[str] = None,
+        **kwargs
+    ) -> PRResult:
+        """更新 Pull Request"""
+        try:
+            repo_path = validate_repo_path(repo_path)
+            repo_info = get_repo_info_from_path(repo_path)
+            if not repo_info:
+                raise ValidationError("无法获取仓库信息")
+            
+            provider = self._get_provider(platform, repo_path)
+            return provider.update_pr(repo_info, pr_number, **kwargs)
+            
+        except Exception as e:
+            logger.error(f"更新PR失败: {e}")
+            return PRResult(
+                success=False,
+                error_message=str(e),
+                platform=PlatformType(platform) if platform else None
+            )
+    
+    def list_pull_requests(
+        self,
+        repo_path: str,
+        state: str = "open",
+        per_page: int = 30,
+        page: int = 1,
+        platform: Optional[str] = None
+    ) -> List[PRInfo]:
+        """列出 Pull Requests"""
+        try:
+            repo_path = validate_repo_path(repo_path)
+            repo_info = get_repo_info_from_path(repo_path)
+            if not repo_info:
+                raise ValidationError("无法获取仓库信息")
+            
+            provider = self._get_provider(platform, repo_path)
+            return provider.list_prs(repo_info, state, per_page, page)
+            
+        except Exception as e:
+            logger.error(f"列出PR失败: {e}")
+            return []
+    
+    def health_check(self, platform: Optional[str] = None, repo_path: Optional[str] = None) -> bool:
+        """健康检查"""
+        try:
+            provider = self._get_provider(platform, repo_path)
+            return provider.health_check()
+        except Exception as e:
+            logger.error(f"健康检查失败: {e}")
+            return False
+
+
+# 全局管理器实例
+_global_manager = PullRequestManager()
+
+
+def set_global_config(config: PRConfig) -> None:
+    """设置全局配置"""
+    global _global_manager
+    _global_manager = PullRequestManager(config)
+
+
+def get_global_manager() -> PullRequestManager:
+    """获取全局管理器"""
+    return _global_manager

autocoder/common/pull_requests/models.py

@@ -0,0 +1,164 @@
+"""
+Pull Request 数据模型定义
+"""
+from typing import Optional, List, Dict, Any
+from dataclasses import dataclass, field
+from enum import Enum
+import os
+import json
+from pathlib import Path
+
+
+class PlatformType(str, Enum):
+    """支持的代码托管平台类型"""
+    GITHUB = "github"
+    GITLAB = "gitlab" 
+    GITEE = "gitee"
+    GITCODE = "gitcode"
+
+
+@dataclass
+class PRConfig:
+    """Pull Request 配置类"""
+    platform: PlatformType
+    token: str
+    base_url: Optional[str] = None
+    timeout: int = 30
+    verify_ssl: bool = True
+    retry_count: int = 3
+    default_labels: List[str] = field(default_factory=list)
+    default_assignees: List[str] = field(default_factory=list)
+    
+    # 平台特定配置
+    draft: bool = False
+    maintainer_can_modify: bool = True
+    remove_source_branch: bool = False
+    squash: bool = False
+    
+    def __post_init__(self):
+        if isinstance(self.platform, str):
+            self.platform = PlatformType(self.platform)
+        if self.base_url is None:
+            self.base_url = self._get_default_base_url()
+    
+    def _get_default_base_url(self) -> str:
+        default_urls = {
+            PlatformType.GITHUB: "https://api.github.com",
+            PlatformType.GITLAB: "https://gitlab.com/api/v4",
+            PlatformType.GITEE: "https://gitee.com/api/v5",
+            PlatformType.GITCODE: "https://gitcode.net/api/v4"
+        }
+        return default_urls.get(self.platform, "")
+    
+    @classmethod
+    def from_env(cls, platform: str) -> 'PRConfig':
+        env_mappings = {
+            PlatformType.GITHUB: "GITHUB_TOKEN",
+            PlatformType.GITLAB: "GITLAB_TOKEN", 
+            PlatformType.GITEE: "GITEE_TOKEN",
+            PlatformType.GITCODE: "GITCODE_TOKEN"
+        }
+        platform_type = PlatformType(platform)
+        token_env = env_mappings.get(platform_type)
+        if not token_env:
+            raise ValueError(f"不支持的平台类型: {platform}")
+        token = os.getenv(token_env)
+        if not token:
+            raise ValueError(f"环境变量 {token_env} 未设置")
+        return cls(platform=platform_type, token=token)
+
+
+@dataclass
+class RepoInfo:
+    """仓库信息"""
+    owner: str
+    name: str
+    platform: PlatformType
+    full_name: str = field(init=False)
+    
+    def __post_init__(self):
+        self.full_name = f"{self.owner}/{self.name}"
+
+
+@dataclass 
+class PRData:
+    """Pull Request 数据"""
+    title: str
+    description: str
+    source_branch: str
+    target_branch: str
+    labels: List[str] = field(default_factory=list)
+    assignees: List[str] = field(default_factory=list)
+    reviewers: List[str] = field(default_factory=list)
+    draft: bool = False
+    template_type: Optional[str] = None
+    template_vars: Dict[str, str] = field(default_factory=dict)
+
+
+@dataclass
+class PRResult:
+    """Pull Request 操作结果"""
+    success: bool
+    pr_number: Optional[int] = None
+    pr_url: Optional[str] = None
+    pr_id: Optional[str] = None
+    error_message: Optional[str] = None
+    error_code: Optional[str] = None
+    platform: Optional[PlatformType] = None
+    raw_response: Optional[Dict[str, Any]] = None
+    retry_after: Optional[int] = None
+
+
+@dataclass
+class PRInfo:
+    """Pull Request 详细信息"""
+    number: int
+    title: str
+    description: str
+    state: str
+    source_branch: str
+    target_branch: str
+    author: str
+    created_at: str
+    updated_at: str
+    merged_at: Optional[str] = None
+    pr_url: str = ""
+    labels: List[str] = field(default_factory=list)
+    assignees: List[str] = field(default_factory=list)
+    reviewers: List[str] = field(default_factory=list)
+    mergeable: Optional[bool] = None
+    draft: bool = False
+    raw_data: Optional[Dict[str, Any]] = None
+
+
+# 默认模板配置
+DEFAULT_TEMPLATES = {
+    "bug_fix": {
+        "title_prefix": "🐛 Bug Fix:",
+        "description_template": """
+## 问题描述
+{problem_description}
+
+## 解决方案
+{solution_description}
+
+## 测试
+- [ ] 单元测试通过
+- [ ] 集成测试通过
+- [ ] 手动测试验证
+        """
+    },
+    "feature": {
+        "title_prefix": "✨ Feature:",
+        "description_template": """
+## 新功能说明
+{feature_description}
+
+## 实现细节
+{implementation_details}
+
+## 使用示例
+{usage_examples}
+        """
+    }
+}

autocoder/common/pull_requests/providers/__init__.py

@@ -0,0 +1,23 @@
+"""
+Pull Request 平台提供者模块
+"""
+from .github_provider import GitHubProvider
+from .gitlab_provider import GitLabProvider
+from .gitee_provider import GiteeProvider
+from .gitcode_provider import GitCodeProvider
+
+# 提供者映射
+PROVIDERS = {
+    'github': GitHubProvider,
+    'gitlab': GitLabProvider,
+    'gitee': GiteeProvider,
+    'gitcode': GitCodeProvider
+}
+
+__all__ = [
+    'GitHubProvider',
+    'GitLabProvider', 
+    'GiteeProvider',
+    'GitCodeProvider',
+    'PROVIDERS'
+]