tamar-file-hub-client 0.1.3__py3-none-any.whl → 0.1.5__py3-none-any.whl

file_hub_client/services/file/sync_file_service.py

@@ -10,6 +10,11 @@ from ...schemas import (
     File,
     FileListResponse,
     GetFileResponse,
+    CompressionStatusResponse,
+    GetVariantsResponse,
+    RecompressionResponse,
+    VariantDownloadUrlResponse,
+    CompressedVariant,
 )
 from ...errors import FileNotFoundError
 
@@ -273,3 +278,215 @@ class SyncFileService(BaseFileService):
         files = [self._convert_file_info(f) for f in response.files]
 
         return FileListResponse(files=files)
+
+    def get_compression_status(
+            self,
+            file_id: str,
+            *,
+            request_id: Optional[str] = None,
+            **metadata
+    ) -> CompressionStatusResponse:
+        """
+        获取文件压缩状态
+        
+        Args:
+            file_id: 文件ID
+            request_id: 请求ID，用于追踪
+            **metadata: 额外的gRPC元数据
+            
+        Returns:
+            CompressionStatusResponse: 压缩状态响应
+        """
+        from ...rpc.gen import file_service_pb2, file_service_pb2_grpc
+        
+        stub = self.client.get_stub(file_service_pb2_grpc.FileServiceStub)
+        
+        request = file_service_pb2.CompressionStatusRequest(file_id=file_id)
+        
+        # 构建元数据
+        grpc_metadata = self.client.build_metadata(request_id=request_id, **metadata)
+        
+        response = stub.GetCompressionStatus(request, metadata=grpc_metadata)
+        
+        # 转换压缩变体
+        variants = []
+        for variant in response.variants:
+            variants.append(CompressedVariant(
+                variant_name=variant.variant_name,
+                variant_type=variant.variant_type,
+                media_type=variant.media_type,
+                width=variant.width,
+                height=variant.height,
+                file_size=variant.file_size,
+                format=variant.format,
+                quality=variant.quality if variant.quality else None,
+                duration=variant.duration if variant.duration else None,
+                bitrate=variant.bitrate if variant.bitrate else None,
+                fps=variant.fps if variant.fps else None,
+                compression_ratio=variant.compression_ratio,
+                stored_path=variant.stored_path
+            ))
+        
+        return CompressionStatusResponse(
+            status=response.status,
+            error_message=response.error_message if response.error_message else None,
+            variants=variants
+        )
+
+    def get_compressed_variants(
+            self,
+            file_id: str,
+            *,
+            variant_type: Optional[str] = None,
+            request_id: Optional[str] = None,
+            **metadata
+    ) -> GetVariantsResponse:
+        """
+        获取文件的压缩变体
+        
+        Args:
+            file_id: 文件ID
+            variant_type: 变体类型(image, video, thumbnail)
+            request_id: 请求ID，用于追踪
+            **metadata: 额外的gRPC元数据
+            
+        Returns:
+            GetVariantsResponse: 压缩变体响应
+        """
+        from ...rpc.gen import file_service_pb2, file_service_pb2_grpc
+        
+        stub = self.client.get_stub(file_service_pb2_grpc.FileServiceStub)
+        
+        request = file_service_pb2.GetVariantsRequest(file_id=file_id)
+        if variant_type:
+            request.variant_type = variant_type
+        
+        # 构建元数据
+        grpc_metadata = self.client.build_metadata(request_id=request_id, **metadata)
+        
+        response = stub.GetCompressedVariants(request, metadata=grpc_metadata)
+        
+        # 转换压缩变体
+        variants = []
+        for variant in response.variants:
+            variants.append(CompressedVariant(
+                variant_name=variant.variant_name,
+                variant_type=variant.variant_type,
+                media_type=variant.media_type,
+                width=variant.width,
+                height=variant.height,
+                file_size=variant.file_size,
+                format=variant.format,
+                quality=variant.quality if variant.quality else None,
+                duration=variant.duration if variant.duration else None,
+                bitrate=variant.bitrate if variant.bitrate else None,
+                fps=variant.fps if variant.fps else None,
+                compression_ratio=variant.compression_ratio,
+                stored_path=variant.stored_path
+            ))
+        
+        return GetVariantsResponse(variants=variants)
+
+    def trigger_recompression(
+            self,
+            file_id: str,
+            *,
+            force_reprocess: bool = False,
+            request_id: Optional[str] = None,
+            **metadata
+    ) -> RecompressionResponse:
+        """
+        触发文件重新压缩
+        
+        Args:
+            file_id: 文件ID
+            force_reprocess: 是否强制重新处理
+            request_id: 请求ID，用于追踪
+            **metadata: 额外的gRPC元数据
+            
+        Returns:
+            RecompressionResponse: 重新压缩响应
+        """
+        from ...rpc.gen import file_service_pb2, file_service_pb2_grpc
+        
+        stub = self.client.get_stub(file_service_pb2_grpc.FileServiceStub)
+        
+        request = file_service_pb2.RecompressionRequest(
+            file_id=file_id,
+            force_reprocess=force_reprocess
+        )
+        
+        # 构建元数据
+        grpc_metadata = self.client.build_metadata(request_id=request_id, **metadata)
+        
+        response = stub.TriggerRecompression(request, metadata=grpc_metadata)
+        
+        return RecompressionResponse(
+            task_id=response.task_id,
+            status=response.status
+        )
+
+    def generate_variant_download_url(
+            self,
+            file_id: str,
+            variant_name: str,
+            *,
+            expire_seconds: int = 3600,
+            is_cdn: bool = False,
+            request_id: Optional[str] = None,
+            **metadata
+    ) -> VariantDownloadUrlResponse:
+        """
+        生成变体下载URL
+        
+        Args:
+            file_id: 文件ID
+            variant_name: 变体名称(large/medium/small/thumbnail)
+            expire_seconds: 过期时间（秒）
+            is_cdn: 是否使用CDN
+            request_id: 请求ID，用于追踪
+            **metadata: 额外的gRPC元数据
+            
+        Returns:
+            VariantDownloadUrlResponse: 变体下载URL响应
+        """
+        from ...rpc.gen import file_service_pb2, file_service_pb2_grpc
+        
+        stub = self.client.get_stub(file_service_pb2_grpc.FileServiceStub)
+        
+        request = file_service_pb2.VariantDownloadUrlRequest(
+            file_id=file_id,
+            variant_name=variant_name,
+            expire_seconds=expire_seconds,
+            is_cdn=is_cdn
+        )
+        
+        # 构建元数据
+        grpc_metadata = self.client.build_metadata(request_id=request_id, **metadata)
+        
+        response = stub.GenerateVariantDownloadUrl(request, metadata=grpc_metadata)
+        
+        # 转换变体信息
+        variant_info = None
+        if response.variant_info:
+            variant_info = CompressedVariant(
+                variant_name=response.variant_info.variant_name,
+                variant_type=response.variant_info.variant_type,
+                media_type=response.variant_info.media_type,
+                width=response.variant_info.width,
+                height=response.variant_info.height,
+                file_size=response.variant_info.file_size,
+                format=response.variant_info.format,
+                quality=response.variant_info.quality if response.variant_info.quality else None,
+                duration=response.variant_info.duration if response.variant_info.duration else None,
+                bitrate=response.variant_info.bitrate if response.variant_info.bitrate else None,
+                fps=response.variant_info.fps if response.variant_info.fps else None,
+                compression_ratio=response.variant_info.compression_ratio,
+                stored_path=response.variant_info.stored_path
+            )
+        
+        return VariantDownloadUrlResponse(
+            url=response.url,
+            error=response.error if response.error else None,
+            variant_info=variant_info
+        )

file_hub_client/utils/__init__.py

@@ -46,6 +46,13 @@ from .logging import (
     grpc_request_context,
     log_grpc_call,
 )
+from .ip_detector import (
+    get_current_user_ip,
+    set_current_user_ip,
+    set_user_ip_extractor,
+    UserIPContext,
+    flask_auto_user_ip,
+)
 
 __all__ = [
     # 文件工具
@@ -87,4 +94,11 @@ __all__ = [
     "GrpcRequestLogger",
     "grpc_request_context",
     "log_grpc_call",
+    
+    # IP检测工具
+    "get_current_user_ip",
+    "set_current_user_ip", 
+    "set_user_ip_extractor",
+    "UserIPContext",
+    "flask_auto_user_ip",
 ]

file_hub_client/utils/file_utils.py

@@ -1,153 +1,186 @@
-"""
-文件工具函数
-"""
-import hashlib
-import mimetypes
-from pathlib import Path
-from typing import Generator, Optional, BinaryIO, Union
-
-
-def get_file_mime_type(file_path: Union[str, Path]) -> str:
-    """
-    获取文件的MIME类型
-    
-    Args:
-        file_path: 文件路径
-        
-    Returns:
-        MIME类型
-    """
-    file_path = Path(file_path)
-    
-    # 定义常见文件扩展名到MIME类型的映射，确保跨平台一致性
-    extension_mime_map = {
-        '.csv': 'text/csv',
-        '.txt': 'text/plain',
-        '.json': 'application/json',
-        '.xml': 'application/xml',
-        '.html': 'text/html',
-        '.htm': 'text/html',
-        '.pdf': 'application/pdf',
-        '.doc': 'application/msword',
-        '.docx': 'application/vnd.openxmlformats-officedocument.wordprocessingml.document',
-        '.xls': 'application/vnd.ms-excel',
-        '.xlsx': 'application/vnd.openxmlformats-officedocument.spreadsheetml.sheet',
-        '.ppt': 'application/vnd.ms-powerpoint',
-        '.pptx': 'application/vnd.openxmlformats-officedocument.presentationml.presentation',
-        '.jpg': 'image/jpeg',
-        '.jpeg': 'image/jpeg',
-        '.png': 'image/png',
-        '.gif': 'image/gif',
-        '.bmp': 'image/bmp',
-        '.webp': 'image/webp',
-        '.mp3': 'audio/mpeg',
-        '.wav': 'audio/wav',
-        '.mp4': 'video/mp4',
-        '.avi': 'video/x-msvideo',
-        '.mov': 'video/quicktime',
-        '.zip': 'application/zip',
-        '.rar': 'application/vnd.rar',
-        '.7z': 'application/x-7z-compressed',
-        '.tar': 'application/x-tar',
-        '.gz': 'application/gzip',
-    }
-    
-    # 获取文件扩展名（转为小写）
-    extension = file_path.suffix.lower()
-    
-    # 优先使用自定义映射，确保常见文件类型的一致性
-    if extension in extension_mime_map:
-        return extension_mime_map[extension]
-    
-    # 如果自定义映射中没有，尝试使用magic进行内容检测
-    try:
-        import magic
-        mime = magic.Magic(mime=True)
-        return mime.from_file(str(file_path))
-    except ImportError:
-        # 如果magic不可用，使用mimetypes作为fallback
-        mime_type, _ = mimetypes.guess_type(str(file_path))
-        return mime_type or "application/octet-stream"
-
-
-def get_file_extension(file_name: str) -> str:
-    """
-    获取文件扩展名
-    
-    Args:
-        file_name: 文件名
-        
-    Returns:
-        文件扩展名（包含点号）
-    """
-    return Path(file_name).suffix.lower()
-
-
-def humanize_file_size(size_bytes: int) -> str:
-    """
-    将文件大小转换为人类可读的格式
-    
-    Args:
-        size_bytes: 文件大小（字节）
-        
-    Returns:
-        人类可读的文件大小
-    """
-    for unit in ["B", "KB", "MB", "GB", "TB"]:
-        if size_bytes < 1024.0:
-            return f"{size_bytes:.2f} {unit}"
-        size_bytes /= 1024.0
-    return f"{size_bytes:.2f} PB"
-
-
-def calculate_file_hash(file_path: Union[str, Path], algorithm: str = "sha256") -> str:
-    """
-    计算文件哈希值
-    
-    Args:
-        file_path: 文件路径
-        algorithm: 哈希算法（md5, sha1, sha256等）
-        
-    Returns:
-        文件哈希值（十六进制）
-    """
-    file_path = Path(file_path)
-    hash_obj = hashlib.new(algorithm)
-
-    with open(file_path, "rb") as f:
-        while chunk := f.read(8192):
-            hash_obj.update(chunk)
-
-    return hash_obj.hexdigest()
-
-
-def split_file_chunks(
-        file_obj: BinaryIO,
-        chunk_size: int = 1024 * 1024,  # 默认1MB
-        start_offset: int = 0
-) -> Generator[tuple[bytes, int, bool], None, None]:
-    """
-    将文件分割成块
-    
-    Args:
-        file_obj: 文件对象
-        chunk_size: 块大小（字节）
-        start_offset: 起始偏移量
-        
-    Yields:
-        (块数据, 偏移量, 是否最后一块)
-    """
-    file_obj.seek(start_offset)
-    offset = start_offset
-
-    while True:
-        chunk = file_obj.read(chunk_size)
-        if not chunk:
-            break
-
-        is_last = len(chunk) < chunk_size
-        yield chunk, offset, is_last
-
-        offset += len(chunk)
-        if is_last:
-            break
+"""
+文件工具函数
+"""
+import hashlib
+import mimetypes
+from pathlib import Path
+from typing import Generator, Optional, BinaryIO, Union
+
+
+def get_file_mime_type(file_path: Union[str, Path]) -> str:
+    """
+    获取文件的MIME类型
+    
+    Args:
+        file_path: 文件路径
+        
+    Returns:
+        MIME类型
+    """
+    import json
+    
+    file_path = Path(file_path)
+    
+    # 定义常见文件扩展名到MIME类型的映射，确保跨平台一致性
+    extension_mime_map = {
+        '.csv': 'text/csv',
+        '.txt': 'text/plain',
+        '.json': 'application/json',
+        '.xml': 'application/xml',
+        '.html': 'text/html',
+        '.htm': 'text/html',
+        '.pdf': 'application/pdf',
+        '.doc': 'application/msword',
+        '.docx': 'application/vnd.openxmlformats-officedocument.wordprocessingml.document',
+        '.xls': 'application/vnd.ms-excel',
+        '.xlsx': 'application/vnd.openxmlformats-officedocument.spreadsheetml.sheet',
+        '.ppt': 'application/vnd.ms-powerpoint',
+        '.pptx': 'application/vnd.openxmlformats-officedocument.presentationml.presentation',
+        '.jpg': 'image/jpeg',
+        '.jpeg': 'image/jpeg',
+        '.png': 'image/png',
+        '.gif': 'image/gif',
+        '.bmp': 'image/bmp',
+        '.webp': 'image/webp',
+        '.mp3': 'audio/mpeg',
+        '.wav': 'audio/wav',
+        '.mp4': 'video/mp4',
+        '.avi': 'video/x-msvideo',
+        '.mov': 'video/quicktime',
+        '.zip': 'application/zip',
+        '.rar': 'application/vnd.rar',
+        '.7z': 'application/x-7z-compressed',
+        '.tar': 'application/x-tar',
+        '.gz': 'application/gzip',
+    }
+    
+    # 获取文件扩展名（转为小写）
+    extension = file_path.suffix.lower()
+    
+    # 对于JSON文件，进行内容验证
+    if extension == '.json':
+        if file_path.exists():
+            try:
+                # 尝试不同的编码方式读取文件
+                content = None
+                for encoding in ['utf-8-sig', 'utf-8', 'latin-1']:
+                    try:
+                        with open(file_path, 'r', encoding=encoding) as f:
+                            content = f.read().strip()
+                            break
+                    except UnicodeDecodeError:
+                        continue
+                
+                if content is None:
+                    # 无法读取文件，返回text/plain
+                    return 'text/plain'
+                
+                if not content:
+                    # 空文件，按扩展名处理
+                    return extension_mime_map[extension]
+                
+                # 尝试解析JSON
+                json.loads(content)
+                # 如果解析成功，确实是JSON格式
+                return 'application/json'
+            except (json.JSONDecodeError, OSError):
+                # JSON解析失败或文件读取失败，可能是格式错误的JSON文件
+                # 返回text/plain避免服务器端的类型不匹配错误
+                return 'text/plain'
+    
+    # 优先使用自定义映射，确保常见文件类型的一致性
+    if extension in extension_mime_map:
+        return extension_mime_map[extension]
+    
+    # 如果自定义映射中没有，尝试使用magic进行内容检测
+    try:
+        import magic
+        mime = magic.Magic(mime=True)
+        return mime.from_file(str(file_path))
+    except ImportError:
+        # 如果magic不可用，使用mimetypes作为fallback
+        mime_type, _ = mimetypes.guess_type(str(file_path))
+        return mime_type or "application/octet-stream"
+
+
+def get_file_extension(file_name: str) -> str:
+    """
+    获取文件扩展名
+    
+    Args:
+        file_name: 文件名
+        
+    Returns:
+        文件扩展名（包含点号）
+    """
+    return Path(file_name).suffix.lower()
+
+
+def humanize_file_size(size_bytes: int) -> str:
+    """
+    将文件大小转换为人类可读的格式
+    
+    Args:
+        size_bytes: 文件大小（字节）
+        
+    Returns:
+        人类可读的文件大小
+    """
+    for unit in ["B", "KB", "MB", "GB", "TB"]:
+        if size_bytes < 1024.0:
+            return f"{size_bytes:.2f} {unit}"
+        size_bytes /= 1024.0
+    return f"{size_bytes:.2f} PB"
+
+
+def calculate_file_hash(file_path: Union[str, Path], algorithm: str = "sha256") -> str:
+    """
+    计算文件哈希值
+    
+    Args:
+        file_path: 文件路径
+        algorithm: 哈希算法（md5, sha1, sha256等）
+        
+    Returns:
+        文件哈希值（十六进制）
+    """
+    file_path = Path(file_path)
+    hash_obj = hashlib.new(algorithm)
+
+    with open(file_path, "rb") as f:
+        while chunk := f.read(8192):
+            hash_obj.update(chunk)
+
+    return hash_obj.hexdigest()
+
+
+def split_file_chunks(
+        file_obj: BinaryIO,
+        chunk_size: int = 1024 * 1024,  # 默认1MB
+        start_offset: int = 0
+) -> Generator[tuple[bytes, int, bool], None, None]:
+    """
+    将文件分割成块
+    
+    Args:
+        file_obj: 文件对象
+        chunk_size: 块大小（字节）
+        start_offset: 起始偏移量
+        
+    Yields:
+        (块数据, 偏移量, 是否最后一块)
+    """
+    file_obj.seek(start_offset)
+    offset = start_offset
+
+    while True:
+        chunk = file_obj.read(chunk_size)
+        if not chunk:
+            break
+
+        is_last = len(chunk) < chunk_size
+        yield chunk, offset, is_last
+
+        offset += len(chunk)
+        if is_last:
+            break