webscout 8.2.2__py3-none-any.whl → 8.2.7__py3-none-any.whl

webscout/Extra/GitToolkit/gitapi/repository.py

@@ -1,195 +0,0 @@
-from typing import List, Dict, Any, Optional
-from .utils import request
-from urllib.parse import quote
-
-class Repository:
-    """Class for interacting with GitHub repositories"""
-    
-    def __init__(self, owner: str, repo: str):
-        """
-        Initialize repository client
-        
-        Args:
-            owner: Repository owner
-            repo: Repository name
-        """
-        self.owner = owner
-        self.repo = repo
-        self.base_url = f"https://api.github.com/repos/{owner}/{repo}"
-
-    def get_info(self) -> Dict[str, Any]:
-        """Get basic repository information"""
-        return request(self.base_url)
-
-    def get_commits(self, page: int = 1, per_page: int = 30, sha: str = None) -> List[Dict[str, Any]]:
-        """
-        Get repository commits
-        
-        Args:
-            page: Page number
-            per_page: Items per page
-            sha: SHA or branch name to start listing commits from
-        """
-        url = f"{self.base_url}/commits?page={page}&per_page={per_page}"
-        if sha:
-            url += f"&sha={sha}"
-        return request(url)
-
-    def get_commit(self, sha: str) -> Dict[str, Any]:
-        """Get a specific commit details"""
-        url = f"{self.base_url}/commits/{sha}"
-        return request(url)
-
-    def get_pull_requests(self, state: str = "all", page: int = 1, per_page: int = 30) -> List[Dict[str, Any]]:
-        """
-        Get repository pull requests
-        
-        Args:
-            state: State of PRs to return (open/closed/all)
-            page: Page number
-            per_page: Items per page
-        """
-        url = f"{self.base_url}/pulls?state={state}&page={page}&per_page={per_page}"
-        return request(url)
-
-    def get_pull_request(self, pr_number: int) -> Dict[str, Any]:
-        """Get specific pull request details"""
-        url = f"{self.base_url}/pulls/{pr_number}"
-        return request(url)
-
-    def get_pull_request_commits(self, pr_number: int) -> List[Dict[str, Any]]:
-        """Get commits in a specific pull request"""
-        url = f"{self.base_url}/pulls/{pr_number}/commits"
-        return request(url)
-
-    def get_pull_request_files(self, pr_number: int) -> List[Dict[str, Any]]:
-        """Get files changed in a specific pull request"""
-        url = f"{self.base_url}/pulls/{pr_number}/files"
-        return request(url)
-
-    def get_issues(self, state: str = "all", page: int = 1, per_page: int = 30, labels: str = None) -> List[Dict[str, Any]]:
-        """
-        Get repository issues
-        
-        Args:
-            state: State of issues to return (open/closed/all)
-            page: Page number
-            per_page: Items per page
-            labels: Comma-separated list of label names
-        """
-        url = f"{self.base_url}/issues?state={state}&page={page}&per_page={per_page}"
-        if labels:
-            url += f"&labels={labels}"
-        return request(url)
-
-    def get_issue(self, issue_number: int) -> Dict[str, Any]:
-        """Get specific issue details"""
-        url = f"{self.base_url}/issues/{issue_number}"
-        return request(url)
-
-    def get_issue_comments(self, issue_number: int) -> List[Dict[str, Any]]:
-        """Get comments on a specific issue"""
-        url = f"{self.base_url}/issues/{issue_number}/comments"
-        return request(url)
-
-    def get_labels(self) -> List[Dict[str, Any]]:
-        """Get repository labels"""
-        url = f"{self.base_url}/labels"
-        return request(url)
-
-    def get_milestones(self, state: str = "all") -> List[Dict[str, Any]]:
-        """Get repository milestones"""
-        url = f"{self.base_url}/milestones?state={state}"
-        return request(url)
-
-    def get_contributors(self, page: int = 1, per_page: int = 30) -> List[Dict[str, Any]]:
-        """Get repository contributors"""
-        url = f"{self.base_url}/contributors?page={page}&per_page={per_page}"
-        return request(url)
-
-    def get_languages(self) -> Dict[str, int]:
-        """Get repository language breakdown"""
-        url = f"{self.base_url}/languages"
-        return request(url)
-
-    def get_teams(self) -> List[Dict[str, Any]]:
-        """Get teams with access to repository"""
-        url = f"{self.base_url}/teams"
-        return request(url)
-
-    def get_tags(self) -> List[Dict[str, Any]]:
-        """Get repository tags"""
-        url = f"{self.base_url}/tags"
-        return request(url)
-
-    def get_releases(self, page: int = 1, per_page: int = 30) -> List[Dict[str, Any]]:
-        """Get repository releases"""
-        url = f"{self.base_url}/releases?page={page}&per_page={per_page}"
-        return request(url)
-
-    def get_release(self, release_id: str) -> Dict[str, Any]:
-        """Get specific release details"""
-        url = f"{self.base_url}/releases/{release_id}"
-        return request(url)
-
-    def get_latest_release(self) -> Dict[str, Any]:
-        """Get latest release"""
-        url = f"{self.base_url}/releases/latest"
-        return request(url)
-
-    def get_branches(self, page: int = 1, per_page: int = 30) -> List[Dict[str, Any]]:
-        """Get repository branches"""
-        url = f"{self.base_url}/branches?page={page}&per_page={per_page}"
-        return request(url)
-
-    def get_branch(self, branch: str) -> Dict[str, Any]:
-        """Get specific branch details"""
-        url = f"{self.base_url}/branches/{branch}"
-        return request(url)
-
-    def get_contents(self, path: str = "", ref: Optional[str] = None) -> Dict[str, Any]:
-        """Get contents of file or directory"""
-        url = f"{self.base_url}/contents/{quote(path)}"
-        if ref:
-            url += f"?ref={ref}"
-        return request(url)
-
-    def get_collaborators(self) -> List[Dict[str, Any]]:
-        """Get repository collaborators"""
-        url = f"{self.base_url}/collaborators"
-        return request(url)
-
-    def get_workflows(self) -> List[Dict[str, Any]]:
-        """Get repository GitHub Actions workflows"""
-        url = f"{self.base_url}/actions/workflows"
-        return request(url)
-
-    def get_workflow_runs(self, workflow_id: str) -> List[Dict[str, Any]]:
-        """Get workflow runs for a specific workflow"""
-        url = f"{self.base_url}/actions/workflows/{workflow_id}/runs"
-        return request(url)
-
-    def get_deployments(self) -> List[Dict[str, Any]]:
-        """Get repository deployments"""
-        url = f"{self.base_url}/deployments"
-        return request(url)
-
-    def get_traffic(self) -> Dict[str, Any]:
-        """Get repository traffic data"""
-        url = f"{self.base_url}/traffic/views"
-        return request(url)
-
-    def get_code_frequency(self) -> List[List[int]]:
-        """Get weekly commit activity"""
-        url = f"{self.base_url}/stats/code_frequency"
-        return request(url)
-
-    def get_commit_activity(self) -> List[Dict[str, Any]]:
-        """Get last year of commit activity"""
-        url = f"{self.base_url}/stats/commit_activity"
-        return request(url)
-
-    def get_community_profile(self) -> Dict[str, Any]:
-        """Get community profile metrics"""
-        url = f"{self.base_url}/community/profile"
-        return request(url)

webscout/Extra/GitToolkit/gitapi/user.py

@@ -1,96 +0,0 @@
-from typing import List, Dict, Any
-from .utils import request
-
-class User:
-    """Class for interacting with GitHub user data"""
-    
-    def __init__(self, username: str):
-        """
-        Initialize user client
-        
-        Args:
-            username: GitHub username
-        """
-        self.username = username
-        self.base_url = f"https://api.github.com/users/{username}"
-
-    def get_profile(self) -> Dict[str, Any]:
-        """Get user profile information"""
-        return request(self.base_url)
-
-    def get_repositories(self, page: int = 1, per_page: int = 30, type: str = "all") -> List[Dict[str, Any]]:
-        """
-        Get user's public repositories
-        
-        Args:
-            page: Page number
-            per_page: Items per page
-            type: Type of repositories (all/owner/member)
-        """
-        url = f"{self.base_url}/repos?page={page}&per_page={per_page}&type={type}"
-        return request(url)
-
-    def get_starred(self, page: int = 1, per_page: int = 30) -> List[Dict[str, Any]]:
-        """Get repositories starred by user"""
-        url = f"{self.base_url}/starred?page={page}&per_page={per_page}"
-        return request(url)
-
-    def get_followers(self, page: int = 1, per_page: int = 30) -> List[Dict[str, Any]]:
-        """Get user's followers"""
-        url = f"{self.base_url}/followers?page={page}&per_page={per_page}"
-        return request(url)
-
-    def get_following(self, page: int = 1, per_page: int = 30) -> List[Dict[str, Any]]:
-        """Get users followed by this user"""
-        url = f"{self.base_url}/following?page={page}&per_page={per_page}"
-        return request(url)
-
-    def get_gists(self, page: int = 1, per_page: int = 30) -> List[Dict[str, Any]]:
-        """Get user's public gists"""
-        url = f"{self.base_url}/gists?page={page}&per_page={per_page}"
-        return request(url)
-
-    def get_organizations(self) -> List[Dict[str, Any]]:
-        """Get user's organizations"""
-        url = f"{self.base_url}/orgs"
-        return request(url)
-
-    def get_received_events(self, page: int = 1, per_page: int = 30) -> List[Dict[str, Any]]:
-        """Get events received by user"""
-        url = f"{self.base_url}/received_events?page={page}&per_page={per_page}"
-        return request(url)
-
-    def get_public_events(self, page: int = 1, per_page: int = 30) -> List[Dict[str, Any]]:
-        """Get user's public events"""
-        url = f"{self.base_url}/events/public?page={page}&per_page={per_page}"
-        return request(url)
-
-    def get_starred_gists(self) -> List[Dict[str, Any]]:
-        """Get gists starred by user"""
-        url = f"{self.base_url}/starred_gists"
-        return request(url)
-
-    def get_subscriptions(self) -> List[Dict[str, Any]]:
-        """Get repositories user is watching"""
-        url = f"{self.base_url}/subscriptions"
-        return request(url)
-
-    def get_hovercard(self) -> Dict[str, Any]:
-        """Get user's hovercard information"""
-        url = f"{self.base_url}/hovercard"
-        return request(url)
-
-    def get_installation(self) -> Dict[str, Any]:
-        """Get user's GitHub App installations"""
-        url = f"{self.base_url}/installation"
-        return request(url)
-
-    def get_keys(self) -> List[Dict[str, Any]]:
-        """Get user's public SSH keys"""
-        url = f"{self.base_url}/keys"
-        return request(url)
-
-    def get_gpg_keys(self) -> List[Dict[str, Any]]:
-        """Get user's public GPG keys"""
-        url = f"{self.base_url}/gpg_keys"
-        return request(url)

webscout/Extra/GitToolkit/gitapi/utils.py

@@ -1,62 +0,0 @@
-from urllib.request import Request, urlopen
-from urllib.error import HTTPError
-import json
-from typing import Dict, Any
-from webscout.litagent import LitAgent
-
-class GitError(Exception):
-    """Base exception for GitHub API errors"""
-    pass
-
-class RateLimitError(GitError):
-    """Raised when hitting GitHub API rate limits"""
-    pass
-
-class NotFoundError(GitError):
-    """Raised when resource is not found"""
-    pass
-
-class RequestError(GitError):
-    """Raised for general request errors"""
-    pass
-
-_USER_AGENT_GENERATOR = LitAgent()
-
-def request(url: str, retry_attempts: int = 3) -> Dict[str, Any]:
-    """
-    Send a request to GitHub API with retry mechanism
-    
-    Args:
-        url: GitHub API endpoint URL
-        retry_attempts: Number of retry attempts
-        
-    Returns:
-        Parsed JSON response
-        
-    Raises:
-        NotFoundError: If resource not found
-        RateLimitError: If rate limited
-        RequestError: For other request errors
-    """
-    headers = {
-        "User-Agent": _USER_AGENT_GENERATOR.random(),
-        "Accept": "application/vnd.github+json"
-    }
-    
-    for attempt in range(retry_attempts):
-        try:
-            req = Request(url, headers=headers)
-            response = urlopen(req)
-            return json.loads(response.read().decode('utf-8'))
-            
-        except HTTPError as e:
-            if e.code == 404:
-                raise NotFoundError(f"Resource not found: {url}")
-            if e.code == 429:
-                raise RateLimitError(f"Rate limited on attempt {attempt + 1}")
-            if attempt == retry_attempts - 1:
-                raise RequestError(f"HTTP Error {e.code}: {e.reason}")
-            
-        except Exception as e:
-            if attempt == retry_attempts - 1:
-                raise RequestError(f"Request failed: {str(e)}")