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

autocoder/common/pull_requests/__init__.py

@@ -0,0 +1,256 @@
+"""
+Pull Request 统一管理模块
+
+统一的 Pull Request 创建和管理模块，支持 GitHub、GitLab、Gitee、GitCode 四大代码托管平台的 PR 操作。
+"""
+from typing import Optional, List, Dict, Any
+from loguru import logger
+
+from .models import (
+    PRConfig, PRResult, PRInfo, PRData, RepoInfo, PlatformType, 
+    DEFAULT_TEMPLATES
+)
+from .manager import PullRequestManager, get_global_manager, set_global_config
+from .exceptions import (
+    PRError, AuthenticationError, RepositoryNotFoundError, 
+    BranchNotFoundError, NetworkError, RateLimitError, 
+    ValidationError, PlatformNotSupportedError, ConfigurationError
+)
+from .config import get_config
+from .utils import (
+    parse_git_url, detect_platform_from_repo, get_repo_info_from_path,
+    get_current_branch, branch_exists, is_git_repo, get_default_remote_branch,
+    ensure_branch_exists_remotely, is_main_branch, create_and_checkout_branch,
+    generate_auto_branch_name
+)
+
+
+def create_pull_request(
+    repo_path: str,
+    title: str,
+    source_branch: Optional[str] = None,
+    target_branch: Optional[str] = None,
+    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,
+    token: Optional[str] = None,
+    **kwargs
+) -> PRResult:
+    """
+    创建 Pull Request（主要接口函数）
+    
+    Args:
+        repo_path: 仓库路径
+        title: PR标题
+        source_branch: 源分支（可选，默认为当前分支）
+        target_branch: 目标分支（可选，默认为远程默认分支或main）
+        description: PR描述
+        labels: 标签列表
+        assignees: 负责人列表
+        reviewers: 审查者列表
+        draft: 是否为草稿PR
+        template_type: 模板类型
+        template_vars: 模板变量
+        platform: 平台类型（可选，会自动检测）
+        token: 访问令牌（可选）
+        **kwargs: 其他配置参数
+    
+    Returns:
+        PR创建结果
+    """
+    # 处理可选的分支参数
+    if source_branch is None:
+        source_branch = get_current_branch(repo_path)
+        if not source_branch:
+            raise ValidationError("无法获取当前分支，请指定source_branch参数")
+    
+    # 从当前分支，自动创建新分支
+    auto_branch_name = generate_auto_branch_name()
+    logger.info(f"检测到当前分支 '{source_branch}' 为主分支，自动创建新分支: {auto_branch_name}")
+    
+    if not create_and_checkout_branch(repo_path, auto_branch_name):
+        raise ValidationError(f"无法从主分支 '{source_branch}' 创建新分支 '{auto_branch_name}'")
+    
+    source_branch = auto_branch_name
+    logger.info(f"已切换到新分支: {source_branch}")
+    
+    if target_branch is None:
+        target_branch = get_default_remote_branch(repo_path)
+        if not target_branch:
+            target_branch = "main"  # 默认值
+    
+    # 验证仓库是否为Git仓库
+    if not is_git_repo(repo_path):
+        raise ValidationError(f"路径 {repo_path} 不是一个有效的Git仓库")
+    
+    # 检查源分支和目标分支是否相同
+    if source_branch == target_branch:
+        raise ValidationError(f"源分支和目标分支不能相同: {source_branch}")
+    
+    # 确保源分支存在于远程仓库，如果不存在则自动推送
+    if not ensure_branch_exists_remotely(repo_path, source_branch):
+        raise BranchNotFoundError(
+            f"源分支 '{source_branch}' 在本地不存在或推送失败。"
+            f"请检查分支是否存在或网络连接是否正常。"
+        )
+    
+    # 检查目标分支是否存在于远程仓库
+    if not branch_exists(repo_path, target_branch, remote=True):
+        raise BranchNotFoundError(
+            f"目标分支 '{target_branch}' 在远程仓库中不存在。"
+        )
+    
+    # 如果提供了token，创建临时配置
+    manager = get_global_manager()
+    
+    if token:
+        # 自动检测平台或使用指定平台
+        if not platform:
+            detected_platform = detect_platform_from_repo(repo_path)
+            if detected_platform:
+                platform = detected_platform.value
+            else:
+                raise ValidationError("无法检测平台类型，请指定platform参数")
+        
+        # 创建临时配置
+        temp_config = PRConfig(platform=PlatformType(platform), token=token)
+        temp_manager = PullRequestManager(temp_config)
+        
+        return temp_manager.create_pull_request(
+            repo_path=repo_path,
+            source_branch=source_branch,
+            target_branch=target_branch,
+            title=title,
+            description=description,
+            labels=labels,
+            assignees=assignees,
+            reviewers=reviewers,
+            draft=draft,
+            template_type=template_type,
+            template_vars=template_vars,
+            platform=platform
+        )
+    else:
+        # 使用全局管理器
+        return manager.create_pull_request(
+            repo_path=repo_path,
+            source_branch=source_branch,
+            target_branch=target_branch,
+            title=title,
+            description=description,
+            labels=labels,
+            assignees=assignees,
+            reviewers=reviewers,
+            draft=draft,
+            template_type=template_type,
+            template_vars=template_vars,
+            platform=platform
+        )
+
+
+def get_pull_request(
+    repo_path: str,
+    pr_number: int,
+    platform: Optional[str] = None,
+    token: Optional[str] = None,
+    **kwargs
+) -> PRResult:
+    """获取 Pull Request 信息"""
+    manager = get_global_manager()
+    
+    if token:
+        if not platform:
+            detected_platform = detect_platform_from_repo(repo_path)
+            if detected_platform:
+                platform = detected_platform.value
+            else:
+                raise ValidationError("无法检测平台类型，请指定platform参数")
+        
+        config_data = {"token": token}
+        config_data.update(kwargs)
+        temp_config = PRConfig(platform=platform, **config_data)
+        temp_manager = PullRequestManager(temp_config)
+        
+        return temp_manager.get_pull_request(repo_path, pr_number, platform)
+    else:
+        return manager.get_pull_request(repo_path, pr_number, platform)
+
+
+def list_pull_requests(
+    repo_path: str,
+    state: str = "open",
+    per_page: int = 30,
+    page: int = 1,
+    platform: Optional[str] = None,
+    token: Optional[str] = None,
+    **kwargs
+) -> List[PRInfo]:
+    """列出 Pull Requests"""
+    manager = get_global_manager()
+    
+    if token:
+        if not platform:
+            detected_platform = detect_platform_from_repo(repo_path)
+            if detected_platform:
+                platform = detected_platform.value
+            else:
+                raise ValidationError("无法检测平台类型，请指定platform参数")
+        
+        config_data = {"token": token}
+        config_data.update(kwargs)
+        temp_config = PRConfig(platform=platform, **config_data)
+        temp_manager = PullRequestManager(temp_config)
+        
+        return temp_manager.list_pull_requests(repo_path, state, per_page, page, platform)
+    else:
+        return manager.list_pull_requests(repo_path, state, per_page, page, platform)
+
+
+# 导出所有公共接口
+__all__ = [
+    # 主要函数
+    'create_pull_request',
+    'get_pull_request', 
+    'list_pull_requests',
+    
+    # 类和模型
+    'PullRequestManager',
+    'PRConfig',
+    'PRResult',
+    'PRInfo',
+    'PRData',
+    'RepoInfo',
+    'PlatformType',
+    
+    # 异常
+    'PRError',
+    'AuthenticationError',
+    'RepositoryNotFoundError',
+    'BranchNotFoundError',
+    'NetworkError',
+    'RateLimitError',
+    'ValidationError',
+    'PlatformNotSupportedError',
+    'ConfigurationError',
+    
+    # 工具函数
+    'parse_git_url',
+    'detect_platform_from_repo',
+    'get_repo_info_from_path',
+    'get_current_branch',
+    'branch_exists',
+    'is_git_repo',
+    
+    # 配置函数
+    'get_config',
+    'set_global_config',
+    'get_global_manager',
+    
+    # 模板
+    'DEFAULT_TEMPLATES'
+]

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