"""User model that provides GitHub-compatible interface for Gitea users.""" from typing import Optional, List, Dict, Any class User: """ User wrapper that provides GitHub-compatible interface for Gitea users. """ def __init__(self, gitea_user, gitea_client): """ Initialize user wrapper. Args: gitea_user: The Gitea user object gitea_client: The Gitea client instance """ self._user = gitea_user self._gitea = gitea_client # Map Gitea attributes to GitHub attributes self.login = gitea_user.login self.id = gitea_user.id self.avatar_url = gitea_user.avatar_url self.html_url = gitea_user.html_url self.type = 'User' # Could be 'User' or 'Organization' self.name = gitea_user.full_name self.company = getattr(gitea_user, 'company', None) self.blog = getattr(gitea_user, 'website', None) self.location = gitea_user.location self.email = gitea_user.email self.bio = getattr(gitea_user, 'description', None) self.public_repos = getattr(gitea_user, 'public_repos', 0) self.followers = getattr(gitea_user, 'followers_count', 0) self.following = getattr(gitea_user, 'following_count', 0) self.created_at = gitea_user.created self.updated_at = getattr(gitea_user, 'last_login', gitea_user.created) def get_repos(self, type: str = 'owner', sort: str = 'full_name', direction: str = 'asc') -> List[Any]: """ Get repositories for the user. Args: type: Type of repos to return ('all', 'owner', 'member') sort: Sort field ('created', 'updated', 'pushed', 'full_name') direction: Sort direction ('asc', 'desc') Returns: List of Repository objects """ # Import here to avoid circular imports try: # When running tests or using as a module from models.repository import Repository except ImportError: # When using as a package from .repository import Repository # Get repos using Gitea API gitea_repos = self._user.get_repos() # Convert to Repository objects repos = [Repository(repo, self._gitea) for repo in gitea_repos] # Apply sorting if sort == 'full_name': repos.sort(key=lambda r: r.full_name, reverse=(direction == 'desc')) elif sort == 'created': repos.sort(key=lambda r: r.created_at, reverse=(direction == 'desc')) elif sort == 'updated': repos.sort(key=lambda r: r.updated_at, reverse=(direction == 'desc')) return repos def get_starred(self) -> List[Any]: """ Get repositories starred by the user. Returns: List of Repository objects """ # Import here to avoid circular imports try: # When running tests or using as a module from models.repository import Repository except ImportError: # When using as a package from .repository import Repository # Get starred repos using Gitea API gitea_repos = self._user.get_starred() # Convert to Repository objects return [Repository(repo, self._gitea) for repo in gitea_repos] def get_subscriptions(self) -> List[Any]: """ Get repositories watched by the user. Returns: List of Repository objects """ # Import here to avoid circular imports try: # When running tests or using as a module from models.repository import Repository except ImportError: # When using as a package from .repository import Repository # Get watched repos using Gitea API gitea_repos = self._user.get_subscriptions() # Convert to Repository objects return [Repository(repo, self._gitea) for repo in gitea_repos] def get_orgs(self) -> List[Dict[str, Any]]: """ Get organizations the user belongs to. Returns: List of organization objects """ gitea_orgs = self._user.get_orgs() orgs = [] for org in gitea_orgs: orgs.append({ 'login': org.username, 'id': org.id, 'avatar_url': org.avatar_url, 'description': org.description, 'type': 'Organization' }) return orgs def get_followers(self) -> List['User']: """ Get users following this user. Returns: List of User objects """ gitea_followers = self._user.get_followers() # Convert to User objects return [User(follower, self._gitea) for follower in gitea_followers] def get_following(self) -> List['User']: """ Get users this user is following. Returns: List of User objects """ gitea_following = self._user.get_following() # Convert to User objects return [User(user, self._gitea) for user in gitea_following] def has_in_following(self, following: 'User') -> bool: """ Check if this user follows another user. Args: following: User to check Returns: True if following, False otherwise """ return self._user.is_following(following.login) def add_to_following(self, following: 'User') -> None: """ Follow another user. Args: following: User to follow """ self._user.follow(following.login) def remove_from_following(self, following: 'User') -> None: """ Unfollow another user. Args: following: User to unfollow """ self._user.unfollow(following.login) def get_keys(self) -> List[Dict[str, Any]]: """ Get SSH keys for the user. Returns: List of key objects """ gitea_keys = self._user.get_keys() keys = [] for key in gitea_keys: keys.append({ 'id': key.id, 'key': key.key, 'title': key.title, 'created_at': key.created_at, 'read_only': getattr(key, 'read_only', True) }) return keys def create_repo(self, name: str, **kwargs) -> Any: """ Create a new repository for the user. Args: name: Repository name **kwargs: Additional parameters Returns: Repository object """ # Import here to avoid circular imports try: # When running tests or using as a module from models.repository import Repository except ImportError: # When using as a package from .repository import Repository # Map GitHub parameters to Gitea parameters gitea_params = { 'name': name, 'description': kwargs.get('description', ''), 'private': kwargs.get('private', False), 'auto_init': kwargs.get('auto_init', False), 'gitignores': kwargs.get('gitignore_template', ''), 'license': kwargs.get('license_template', ''), 'readme': kwargs.get('readme', '') } gitea_repo = self._user.create_repo(**gitea_params) return Repository(gitea_repo, self._gitea)