update miner_fn

miner.py

@@ -6,100 +6,9 @@ from typing import List, Tuple, Optional
 import numpy as np
 import cv2
 from sklearn.cluster import KMeans
-import base64
-import boto3
-import json
-import uuid
 
 
 
-########################################
-# Helper utilities for R2 storage
-########################################
-
-def init_r2_client():
-    """
-    Khởi tạo S3 client cho Cloudflare R2.
-    Returns:
-        tuple: (s3_client, bucket_name, can_upload)
-    """
-    try:
-        r2_account_id = "f5ac691bc782b80f90edb38eba5534ad"
-        r2_access_key_id = "54f3343f68621c563d7ca29d3b356122"
-        r2_secret_access_key = "41484baa8a10838e197f528b7eefbb824e1f38ffe13abc4e6b5fa7b68ad6d82d"
-        bucket_name = "my-miner-sn44"
-
-        can_upload = all([r2_account_id, r2_access_key_id, r2_secret_access_key, bucket_name])
-
-        if can_upload:
-            s3_client = boto3.client(
-                's3',
-                endpoint_url=f"https://{r2_account_id}.r2.cloudflarestorage.com",
-                aws_access_key_id=r2_access_key_id,
-                aws_secret_access_key=r2_secret_access_key,
-                region_name='auto'
-            )
-            print(f"✅ R2 client initialized for bucket: {bucket_name}")
-            return s3_client, bucket_name, True
-        else:
-            print("⚠️  Thiếu một hoặc nhiều secret của R2, sẽ không lưu frames.")
-            return None, None, False
-
-    except Exception as e:
-        print(f"⚠️  Không thể khởi tạo S3 client: {e}")
-        return None, None, False
-
-
-def image_to_base64(image: np.ndarray, quality: int = 85) -> str:
-    """
-    Convert numpy image array to base64 string.
-    Args:
-        image: numpy array (BGR format from OpenCV)
-        quality: JPEG quality (1-100, default 85)
-    Returns:
-        str: base64 encoded string
-    """
-    # Encode image as JPEG
-    encode_param = [int(cv2.IMWRITE_JPEG_QUALITY), quality]
-    _, buffer = cv2.imencode('.jpg', image, encode_param)
-    # Convert to base64
-    base64_str = base64.b64encode(buffer).decode('utf-8')
-    return base64_str
-
-
-def upload_frames_to_r2(
-    s3_client, 
-    bucket_name: str, 
-    frames_base64: List[dict], 
-    challenge_id: str
-) -> bool:
-    """
-    Upload danh sách frames (base64) lên Cloudflare R2 dưới dạng JSON.
-    Args:
-        s3_client: boto3 S3 client
-        bucket_name: Tên bucket R2
-        frames_base64: List of dicts with frame_id and base64 data
-        challenge_id: ID của challenge (dùng làm tên file)
-    Returns:
-        bool: True nếu upload thành công
-    """
-    try:
-        json_filename = f"{challenge_id}_frames.json"
-        json_data = json.dumps(frames_base64)
-        
-        s3_client.put_object(
-            Bucket=bucket_name,
-            Key=json_filename,
-            Body=json_data.encode('utf-8'),
-            ContentType='application/json'
-        )
-        print(f"✅ {len(frames_base64)} frames đã được lưu vào R2: {json_filename}")
-        return True
-    except Exception as e:
-        print(f"⚠️  Lỗi khi tải frames lên R2: {e}")
-        return False
-
-
 ########################################
 # Helper utilities for grass & color clustering
 ########################################
@@ -195,21 +104,7 @@ class Miner:
         
         Args:
             path_hf_repo: Path to HuggingFace repo with models
-            enable_frame_storage: If True, collect frames as base64 for R2 upload
-            storage_quality: JPEG quality for stored frames (1-100)
-            challenge_id: Challenge ID for R2 upload (required if enable_frame_storage=True)
         """
-        enable_frame_storage = True
-        storage_quality = 85
-
-        challenge_id = f"challenge_{uuid.uuid4().hex[:12]}"
-        
-        # Option 2: Timestamp-based (unique theo thời gian)
-        # challenge_id = f"challenge_{datetime.now().strftime('%Y%m%d_%H%M%S_%f')}"
-        
-        print(f"✅ Auto-generated challenge_id: {challenge_id}")
-
-
         self.bbox_model = YOLO(path_hf_repo / "251110-football-detection.pt")
         print("✅ BBox Model Loaded")
         self.keypoints_model = YOLO(path_hf_repo / "17112025_keypoint.pt")
@@ -219,22 +114,6 @@ class Miner:
         self.left_team_label = 0
         self.grass_hsv = None
         self.team_classifier_fitted = False
-        
-        # Frame storage setup
-        self.enable_frame_storage = enable_frame_storage
-        self.storage_quality = storage_quality
-        self.stored_frames: List[dict] = []  # Store frames as base64
-        self.challenge_id = challenge_id
-        
-        # R2 client setup
-        if enable_frame_storage:
-            self.s3_client, self.r2_bucket, self.can_upload = init_r2_client()
-            if not challenge_id:
-                print("⚠️  WARNING: enable_frame_storage=True nhưng chưa set challenge_id")
-        else:
-            self.s3_client = None
-            self.r2_bucket = None
-            self.can_upload = False
 
     def __repr__(self) -> str:
         return (
@@ -274,83 +153,6 @@ class Miner:
 
         grass_color = get_grass_color(frame)
         self.grass_hsv = cv2.cvtColor(np.uint8([[list(grass_color)]]), cv2.COLOR_BGR2HSV)
-    
-    def _auto_upload_frames(self) -> None:
-        """Internal method to auto-upload frames after last batch."""
-        if not self.challenge_id:
-            print("❌ Không thể upload: challenge_id chưa được set!")
-            return
-        
-        total_frames = len(self.stored_frames)
-        size_mb = self.get_stored_frames_size_mb()
-        
-        print(f"📊 Tổng frames đã lưu: {total_frames}")
-        print(f"💾 Size trong memory: {size_mb:.2f} MB")
-        print(f"📤 Đang upload lên R2...")
-        
-        success = upload_frames_to_r2(
-            self.s3_client,
-            self.r2_bucket,
-            self.stored_frames,
-            self.challenge_id
-        )
-        
-        if success:
-            print(f"✅ Upload thành công {total_frames} frames!")
-            print(f"📁 File trên R2: {self.challenge_id}_frames.json")
-            # Clear frames after successful upload
-            self.clear_stored_frames()
-        else:
-            print(f"❌ Upload thất bại!")
-            print(f"💡 Frames vẫn còn trong memory. Có thể retry bằng: miner.upload_stored_frames('{self.challenge_id}')")
-    
-    def upload_stored_frames(self, challenge_id: str) -> bool:
-        """
-        Upload all stored frames to R2.
-        Args:
-            challenge_id: ID của challenge để đặt tên file
-        Returns:
-            bool: True nếu upload thành công
-        """
-        if not self.can_upload:
-            print("⚠️  R2 client chưa được khởi tạo, không thể upload frames.")
-            return False
-        
-        if len(self.stored_frames) == 0:
-            print("⚠️  Không có frames nào để upload.")
-            return False
-        
-        print(f"📤 Đang upload {len(self.stored_frames)} frames lên R2...")
-        success = upload_frames_to_r2(
-            self.s3_client,
-            self.r2_bucket,
-            self.stored_frames,
-            challenge_id
-        )
-        
-        if success:
-            print(f"✅ Đã upload thành công {len(self.stored_frames)} frames")
-            return True
-        else:
-            print("Chưa upload được.")
-            return False
-    
-    def clear_stored_frames(self) -> None:
-        """Clear all stored frames from memory."""
-        self.stored_frames = []
-        print("🗑️  Đã xóa stored frames khỏi memory")
-    
-    def get_stored_frames_count(self) -> int:
-        """Get number of stored frames."""
-        return len(self.stored_frames)
-    
-    def get_stored_frames_size_mb(self) -> float:
-        """Get approximate size of stored frames in MB."""
-        if len(self.stored_frames) == 0:
-            return 0.0
-        total_size = sum(len(frame["data"]) for frame in self.stored_frames)
-        # Base64 encoding adds ~33% overhead, but we calculate as-is
-        return total_size / (1024 * 1024)
 
     def predict_batch(
         self,
@@ -360,7 +162,6 @@ class Miner:
     ) -> list[TVFrameResult]:
         """
         Run predictions and return structured results.
-        Auto-upload when frame_id reaches 750.
         
         Args:
             batch_images: List of image arrays (numpy)
@@ -374,17 +175,6 @@ class Miner:
 
         for i, frame in enumerate(batch_images):
             frame_id = offset + i
-            
-            # Store frame as base64 if enabled
-            if self.enable_frame_storage and self.can_upload:
-                try:
-                    frame_base64 = image_to_base64(frame, quality=self.storage_quality)
-                    self.stored_frames.append({
-                        "frame_id": frame_id,
-                        "data": frame_base64
-                    })
-                except Exception as e:
-                    print(f"⚠️  Lỗi khi convert frame {frame_id} sang base64: {e}")
 
             # Fit KMeans on first frame if not done
             if not self.team_classifier_fitted:
@@ -487,19 +277,5 @@ class Miner:
                 frame_keypoints = filtered_keypoints
 
             results.append(TVFrameResult(frame_id=frame_id, boxes=boxes, keypoints=frame_keypoints))
-            
-            # Auto-upload when reaching frame 750
-            if frame_id == 749 and self.enable_frame_storage and self.can_upload:
-                try:
-                    if len(self.stored_frames) > 0:
-                        print(f"\n{'='*60}")
-                        print(f"🏁 FRAME 750 REACHED - Tự động upload {len(self.stored_frames)} frames lên R2")
-                        print(f"{'='*60}")
-                        self._auto_upload_frames()
-                    else:
-                        print("⚠️  Frame 750 reached nhưng không có frames nào để upload.")
-                except Exception as e:
-                    print(f"⚠️  Lỗi khi upload R2: {e}")
-                    print(f"💡 Tiếp tục trả về results. Frames vẫn còn trong memory.")
         
         return results