platform/dbops/projects/dto/integrations/huggingface_client.py

#!/usr/bin/env python3
"""
Hugging Face Hub Client Integration for Data Transfer Operations
Uses HF Hub with Xet backend for artifact storage and management
"""

import os
import logging
from typing import Dict, List, Optional, Union
from pathlib import Path

# Try to import Hugging Face Hub - will be installed in requirements
logging.basicConfig(level=logging.INFO)
logger = logging.getLogger(__name__)

try:
    from huggingface_hub import HfApi, HfFolder, snapshot_download, upload_file, create_repo
    from huggingface_hub.utils import RepositoryNotFoundError
    HF_AVAILABLE = True
except ImportError:
    HF_AVAILABLE = False
    logger.warning("huggingface_hub not available. Install with: pip install huggingface_hub")

class HuggingFaceClient:
    """Client for Hugging Face Hub operations with Xet backend"""
    
    def __init__(self, repo_id: Optional[str] = None, token: Optional[str] = None):
        """Initialize HF client with optional repo and token"""
        self.repo_id = repo_id
        self.token = token or os.getenv('HF_TOKEN') or HfFolder.get_token() if HF_AVAILABLE else None
        self.api = HfApi(token=self.token) if HF_AVAILABLE else None
    
    def is_authenticated(self) -> bool:
        """Check if authenticated with Hugging Face Hub"""
        if not HF_AVAILABLE or not self.api:
            return False
        try:
            # Test authentication by calling whoami
            self.api.whoami()
            return True
        except:
            # Some tokens may have upload permissions but fail whoami
            # Try a lightweight operation to verify token validity
            try:
                # Check if we can access repo info (lighter than whoami)
                if self.repo_id:
                    self.api.repo_info(self.repo_id)
                    return True
                # If no repo specified, assume valid for upload operations
                return True
            except:
                return False
    
    def upload_artifact(self, local_path: str, repo_path: str, repo_id: Optional[str] = None) -> bool:
        """Upload artifact to HF Hub repo (uses Xet backend transparently)"""
        if not HF_AVAILABLE:
            logger.error("huggingface_hub not available")
            return False
        
        repo_id = repo_id or self.repo_id
        if not repo_id:
            logger.error("No repository ID provided")
            return False
        
        # Xet backend restrictions: cannot upload to protected directories
        # Clean the repo_path to avoid uploading to restricted paths
        clean_repo_path = self._clean_repo_path(repo_path)
        if clean_repo_path is None:
            logger.warning(f"Skipping upload to restricted path: {repo_path}")
            return False
        
        try:
            # Check if repo exists - don't try to create if it already exists
            try:
                self.api.repo_info(repo_id)
                logger.info(f"Repository exists: {repo_id}")
            except RepositoryNotFoundError:
                logger.info(f"Creating repository: {repo_id}")
                # Determine repo type based on repository name pattern
                repo_type = "model"
                if "datasets" in repo_id.lower():
                    repo_type = "dataset"
                elif "artifacts" in repo_id.lower():
                    repo_type = "model"  # Artifacts also use model type
                self.api.create_repo(repo_id, repo_type=repo_type, private=True)
            
            # Upload file
            upload_file(
                path_or_fileobj=local_path,
                path_in_repo=clean_repo_path,
                repo_id=repo_id,
                token=self.token
            )
            
            logger.info(f"Uploaded {local_path} to {repo_id}/{clean_repo_path}")
            return True
            
        except Exception as e:
            logger.error(f"Upload failed: {e}")
            return False
    
    def _clean_repo_path(self, repo_path: str) -> Optional[str]:
        """Clean repository path to avoid Xet backend restrictions"""
        # Xet backend blocks uploads to certain protected directories
        restricted_patterns = [
            '/.cache/', '/.local/', '/.config/', '/.ssh/', '/.git/',
            '/.hg/', '/.svn/', '/node_modules/', '/venv/', '/.venv/',
            '/__pycache__/', '/.pytest_cache/', '/.mypy_cache/'
        ]
        
        # Check if path contains any restricted patterns
        for pattern in restricted_patterns:
            if pattern in repo_path:
                return None
        
        # Remove any leading path components that might cause issues
        # Extract just the filename or relative path without system directories
        if '/' in repo_path:
            # For system paths, extract just the filename
            if repo_path.startswith(('data/', 'home/', 'usr/', 'var/', 'tmp/')):
                return os.path.basename(repo_path)
            # For other paths, keep the relative structure but remove system prefixes
            clean_path = repo_path.replace('data/', '').replace('home/', '')
            return clean_path
        
        return repo_path
    
    def download_artifact(self, repo_path: str, local_path: str, repo_id: Optional[str] = None) -> bool:
        """Download artifact from HF Hub repo"""
        if not HF_AVAILABLE:
            logger.error("huggingface_hub not available")
            return False
        
        repo_id = repo_id or self.repo_id
        if not repo_id:
            logger.error("No repository ID provided")
            return False
        
        try:
            # Download specific file
            downloaded_path = snapshot_download(
                repo_id=repo_id,
                allow_patterns=repo_path,
                local_dir=os.path.dirname(local_path),
                token=self.token
            )
            
            # Move to desired location
            import shutil
            actual_file = os.path.join(downloaded_path, repo_path)
            if os.path.exists(actual_file):
                shutil.move(actual_file, local_path)
                logger.info(f"Downloaded {repo_path} to {local_path}")
                return True
            else:
                logger.error(f"File not found in download: {repo_path}")
                return False
                
        except Exception as e:
            logger.error(f"Download failed: {e}")
            return False
    
    def list_artifacts(self, repo_id: Optional[str] = None) -> List[str]:
        """List artifacts in HF Hub repo"""
        if not HF_AVAILABLE:
            logger.error("huggingface_hub not available")
            return []
        
        repo_id = repo_id or self.repo_id
        if not repo_id:
            logger.error("No repository ID provided")
            return []
        
        try:
            repo_info = self.api.repo_info(repo_id)
            return [file.rfilename for file in repo_info.siblings]
        except Exception as e:
            logger.error(f"List failed: {e}")
            return []
    
    def get_repo_info(self, repo_id: Optional[str] = None) -> Optional[Dict]:
        """Get repository information"""
        if not HF_AVAILABLE:
            return None
        
        repo_id = repo_id or self.repo_id
        if not repo_id:
            return None
        
        try:
            info = self.api.repo_info(repo_id)
            return {
                'id': info.id,
                'private': info.private,
                'size': getattr(info, 'size', None),
                'downloads': info.downloads,
                'last_modified': info.last_modified,
                'xet_enabled': getattr(info, 'xet_enabled', None),
            }
        except Exception as e:
            logger.error(f"Repo info failed: {e}")
            return None

def initialize_hf_integration():
    """Initialize Hugging Face integration for DTO framework"""
    client = HuggingFaceClient()
    
    if not HF_AVAILABLE:
        logger.warning("huggingface_hub not available. Please install: pip install huggingface_hub")
        return None
    
    if not client.is_authenticated():
        logger.warning("Not authenticated with Hugging Face Hub. Set HF_TOKEN environment variable")
        
    return client

if __name__ == "__main__":
    # Example usage
    hf_client = initialize_hf_integration()
    if hf_client and hf_client.is_authenticated():
        print("Hugging Face integration initialized successfully")
        print(f"Authenticated as: {hf_client.api.whoami()['name']}")
    else:
        print("Hugging Face integration not available or not authenticated")