truthscan-image-detector-client 0.0.1__tar.gz

truthscan_image_detector_client-0.0.1/PKG-INFO

@@ -0,0 +1,7 @@
+Metadata-Version: 2.4
+Name: truthscan-image-detector-client
+Version: 0.0.1
+Summary: Python client for AI Image Detection API
+Author: undetectableai
+Requires-Python: >=3.9
+Requires-Dist: requests>=2.31.0

truthscan_image_detector_client-0.0.1/pyproject.toml

@@ -0,0 +1,17 @@
+[build-system]
+requires = ["setuptools>=61.0"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "truthscan-image-detector-client"
+version = "0.0.1"
+description = "Python client for AI Image Detection API"
+requires-python = ">=3.9"
+authors = [{name = "undetectableai"}]
+dependencies = ["requests>=2.31.0"]
+
+[tool.setuptools.packages.find]
+where = ["src"]
+
+[tool.setuptools.package-data]
+ai_image_detection = ["py.typed"]

truthscan_image_detector_client-0.0.1/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

truthscan_image_detector_client-0.0.1/src/ai_image_detection/__init__.py

@@ -0,0 +1,40 @@
+from .client import ImageDetectionClient
+from .service import ImageDetectionService
+from .logger import Logger, DefaultConsoleLogger
+from .errors import (
+    ApiClientError,
+    PresignError,
+    UploadError,
+    DetectError,
+    QueryError,
+    CreditCheckError,
+)
+from .api_types import (
+    PresignResponse,
+    DetectResponse,
+    ResultDetails,
+    QueryResponse,
+    CreditCheckResponse,
+    Image,
+    DetectionResult,
+)
+
+__all__ = [
+    "ImageDetectionClient",
+    "ImageDetectionService",
+    "Logger",
+    "DefaultConsoleLogger",
+    "ApiClientError",
+    "PresignError",
+    "UploadError",
+    "DetectError",
+    "QueryError",
+    "CreditCheckError",
+    "PresignResponse",
+    "DetectResponse",
+    "ResultDetails",
+    "QueryResponse",
+    "CreditCheckResponse",
+    "Image",
+    "DetectionResult",
+]

truthscan_image_detector_client-0.0.1/src/ai_image_detection/api_types.py

@@ -0,0 +1,52 @@
+from typing import TypedDict, Optional, Dict, Any, List, Tuple
+
+
+class PresignResponse(TypedDict):
+    """Response from presign endpoint"""
+    status: str
+    presigned_url: str
+    file_path: str
+    document_id: Optional[str]
+
+
+class DetectResponse(TypedDict):
+    """Response from detect endpoint"""
+    id: str
+    status: str
+
+
+class ResultDetails(TypedDict, total=False):
+    """Detailed detection results"""
+    is_valid: Optional[bool]
+    detection_step: Optional[int]
+    final_result: Optional[str]
+    metadata: Optional[List[Tuple[str, str]]]
+    metadata_basic_source: Optional[str]
+    ocr: Optional[List[Tuple[str, int]]]
+    ml_model: Optional[List[Tuple[str, int]]]
+    confidence: Optional[int]
+    analysis_results: Optional[Dict[str, Any]]
+    analysis_results_status: Optional[str]
+    heatmap_url: Optional[str]
+    heatmap_status: Optional[str]
+
+
+class QueryResponse(TypedDict, total=False):
+    """Response from query endpoint"""
+    id: str
+    status: str
+    result: Optional[int]
+    result_details: Optional[ResultDetails]
+    preview_url: Optional[str]
+
+
+class CreditCheckResponse(TypedDict):
+    """Response from credit check endpoint"""
+    baseCredits: int
+    boostCredits: int
+    credits: int
+
+
+# Type aliases
+Image = str
+DetectionResult = QueryResponse

truthscan_image_detector_client-0.0.1/src/ai_image_detection/client.py

@@ -0,0 +1,128 @@
+import os
+from typing import Optional
+
+from .service import ImageDetectionService
+from .logger import Logger, DefaultConsoleLogger
+from .errors import QueryError, CreditCheckError
+from .api_types import Image, DetectionResult, CreditCheckResponse
+
+
+class ImageDetectionClient:
+    def __init__(
+        self,
+        api_key: str,
+        base_url: Optional[str] = None,
+        timeout: Optional[int] = None,
+        logger: Optional[Logger] = None
+    ) -> None:
+        """
+        Initialize the Image Detection Client.
+        
+        Args:
+            api_key: API key for authentication
+            base_url: Base URL of the API server (optional, default: 'https://ai-image-detect.undetectable.ai')
+            timeout: Default timeout for requests in seconds (optional, default: 60)
+            logger: Logger instance (optional, default: DefaultConsoleLogger("info"))
+        """
+        self.base_url = base_url or 'https://ai-image-detect.undetectable.ai'
+        resolved_logger = logger if logger is not None else DefaultConsoleLogger("info")
+        self.service = ImageDetectionService(
+            self.base_url,
+            api_key,
+            timeout or 60,
+            resolved_logger
+        )
+    
+    def detect(
+        self,
+        image: Image,
+        email: Optional[str] = None,
+        generate_preview: bool = True,
+        max_poll_attempts: int = 60,
+        poll_interval_seconds: float = 0.5
+    ) -> DetectionResult:
+        """
+        Detect AI-generated content in an image.
+        
+        This method handles the entire workflow:
+        1. Presign - Get presigned URL for upload
+        2. Upload - Upload the image file
+        3. Detect - Submit the image for detection
+        4. Poll - Wait for detection results
+        
+        Args:
+            image: File path to the image to detect
+            email: Optional email address for processing
+            generate_preview: Optional flag to generate preview (default: True)
+            max_poll_attempts: Maximum number of polling attempts (default: 60)
+            poll_interval_seconds: Seconds to sleep between polling attempts (default: 0.5)
+            
+        Returns:
+            DetectionResult containing detection status and results
+            
+        Raises:
+            QueryError: If polling times out or other errors occur
+        """
+        # 1. Extract filename from path
+        file_name = os.path.basename(image).replace(' ', '')
+        
+        # 2. Presign - Get presigned URL
+        presign_result = self.service.get_presigned_url(file_name)
+        
+        # 3. Upload - Upload the file
+        self.service.upload(presign_result["presigned_url"], image)
+        
+        # 4. Build file URL for detect operation
+        # Determine CDN base URL based on the baseUrl (dev vs prod)
+        cdn_base_url = self._get_cdn_base_url()
+        file_path_remote_full = f"{cdn_base_url}{presign_result['file_path']}"
+        file_url = ImageDetectionService.build_detect_file_url(
+            file_path_remote_full,
+            presign_result["presigned_url"]
+        )
+        
+        # 5. Detect - Submit for detection
+        detect_result = self.service.detect(
+            file_url,
+            email,
+            generate_preview
+        )
+        
+        # 6. Poll for result - Wait for completion
+        final_result = self.service.poll_for_result(
+            detect_result["id"],
+            max_poll_attempts,
+            poll_interval_seconds
+        )
+        
+        if final_result is None:
+            raise QueryError('Polling timeout - detection result not available')
+        
+        return final_result
+    
+    def check_user_credits(self) -> CreditCheckResponse:
+        """
+        Check user credits for the API key.
+        
+        Returns:
+            CreditCheckResponse containing credit information
+            
+        Raises:
+            CreditCheckError: If the credit check operation fails
+        """
+        try:
+            return self.service.check_user_credits()
+        except Exception as e:
+            raise CreditCheckError(str(e)) from e
+    
+    def _get_cdn_base_url(self) -> str:
+        """
+        Get the CDN base URL based on the configured baseUrl.
+        
+        Returns:
+            CDN base URL string
+        """
+        if 'undetectable.ai' in self.base_url:
+            return 'https://ai-image-detector-prod.nyc3.digitaloceanspaces.com/'
+        else:
+            return 'https://ai-image-detector-dev.nyc3.digitaloceanspaces.com/'

truthscan_image_detector_client-0.0.1/src/ai_image_detection/errors.py

@@ -0,0 +1,28 @@
+class ApiClientError(Exception):
+    """Base exception for API client errors."""
+    pass
+
+
+class PresignError(ApiClientError):
+    """Exception raised when presign operation fails."""
+    pass
+
+
+class UploadError(ApiClientError):
+    """Exception raised when upload operation fails."""
+    pass
+
+
+class DetectError(ApiClientError):
+    """Exception raised when detect operation fails."""
+    pass
+
+
+class QueryError(ApiClientError):
+    """Exception raised when query operation fails."""
+    pass
+
+
+class CreditCheckError(ApiClientError):
+    """Exception raised when credit check operation fails."""
+    pass

truthscan_image_detector_client-0.0.1/src/ai_image_detection/logger.py

@@ -0,0 +1,79 @@
+from typing import Protocol
+from datetime import datetime
+
+
+class Logger(Protocol):
+    """Logger interface for the Image Detection Client"""
+    
+    def info(self, message: str) -> None:
+        """Log an info message"""
+        ...
+    
+    def debug(self, message: str) -> None:
+        """Log a debug message"""
+        ...
+    
+    def warn(self, message: str) -> None:
+        """Log a warning message"""
+        ...
+    
+    def error(self, message: str) -> None:
+        """Log an error message"""
+        ...
+
+
+class DefaultConsoleLogger:
+    """
+    Default console logger implementation
+    """
+    
+    def __init__(self, log_level: str = "info") -> None:
+        """
+        Initialize the default console logger.
+        
+        Args:
+            log_level: Logging level ('debug', 'info', 'warn', 'error', default: 'info')
+        """
+        self.log_level = log_level
+    
+    def _timestamp(self) -> str:
+        """Generate ISO timestamp"""
+        return datetime.now().isoformat()
+    
+    def _should_log(self, level: str) -> bool:
+        """
+        Check if a message at the given level should be logged.
+        
+        Args:
+            level: Log level to check
+            
+        Returns:
+            True if the message should be logged
+        """
+        levels = {
+            'debug': 0,
+            'info': 1,
+            'warn': 2,
+            'error': 3,
+        }
+        return levels.get(level, 1) >= levels.get(self.log_level, 1)
+    
+    def info(self, message: str) -> None:
+        """Log an info message"""
+        if self._should_log('info'):
+            print(f"[{self._timestamp()}] INFO: {message}")
+    
+    def debug(self, message: str) -> None:
+        """Log a debug message"""
+        if self._should_log('debug'):
+            print(f"[{self._timestamp()}] DEBUG: {message}")
+    
+    def warn(self, message: str) -> None:
+        """Log a warning message"""
+        if self._should_log('warn'):
+            print(f"[{self._timestamp()}] WARN: {message}")
+    
+    def error(self, message: str) -> None:
+        """Log an error message"""
+        if self._should_log('error'):
+            print(f"[{self._timestamp()}] ERROR: {message}")

truthscan_image_detector_client-0.0.1/src/ai_image_detection/service.py

@@ -0,0 +1,496 @@
+import os
+import time
+import requests
+import mimetypes
+from urllib.parse import urlparse
+from typing import Dict, Optional, Any, Callable
+
+from .logger import Logger, DefaultConsoleLogger
+from .errors import PresignError, UploadError, DetectError, QueryError, CreditCheckError
+from .api_types import PresignResponse, DetectResponse, QueryResponse, CreditCheckResponse
+
+class ImageDetectionService:
+    def __init__(
+        self,
+        base_url: str,
+        api_key: str,
+        timeout: int = 60,
+        logger: Optional[Logger] = None
+    ) -> None:
+        """
+        Initialize the API client interface.
+        
+        Args:
+            base_url: Base URL of the API server
+            api_key: API key for authentication
+            timeout: Default timeout for requests in seconds (default: 60)
+            logger: Logger instance (optional, default: DefaultConsoleLogger("info"))
+        """
+        self.base_url = base_url.rstrip("/")
+        self.api_key = api_key
+        self.timeout = timeout  # Timeout in seconds for requests library
+        self.logger = logger if logger is not None else DefaultConsoleLogger("info")
+    
+    @staticmethod
+    def guess_mime_type(file_name: str) -> str:
+        """
+        Guess MIME type from file name.
+        
+        Args:
+            file_name: Name of the file
+            
+        Returns:
+            MIME type string
+        """
+        mime, _ = mimetypes.guess_type(file_name)
+        if mime:
+            return mime
+        
+        ext = os.path.splitext(file_name)[1].lower().lstrip('.')
+        mime_map = {
+            'jpg': 'image/jpeg',
+            'jpeg': 'image/jpeg',
+            'jfif': 'image/jpeg',
+            'png': 'image/png',
+            'webp': 'image/webp',
+            'heic': 'image/heic',
+            'heif': 'image/heif',
+            'avif': 'image/avif',
+            'bmp': 'image/bmp',
+            'tiff': 'image/tiff',
+            'tif': 'image/tiff',
+            'svg': 'image/svg+xml',
+            'gif': 'image/gif',
+            'pdf': 'application/pdf',
+        }
+        return mime_map.get(ext, "application/octet-stream")
+    
+    def get_presigned_url(self, file_name: str) -> PresignResponse:
+        """
+        Get a presigned URL for file upload.
+        
+        Args:
+            file_name: Name of the file to upload
+            
+        Returns:
+            PresignResponse containing presigned_url and file_path
+            
+        Raises:
+            PresignError: If the presign operation fails
+        """
+        self.logger.info(f"Requesting presigned URL for file: {file_name}")
+        
+        try:
+            url = f"{self.base_url}/get-presigned-url"
+            response = requests.get(
+                url,
+                headers={'apikey': self.api_key},
+                params={'file_name': file_name},
+                timeout=self.timeout,
+            )
+            
+            self.logger.debug(f"Presign response status: {response.status_code}")
+            
+            if not response.ok:
+                error_msg = f"Presign failed with status {response.status_code}"
+                try:
+                    error_data = response.json()
+                    error_msg = error_data.get("error", error_msg)
+                except Exception:
+                    error_msg = f"{error_msg}: {response.text}"
+                
+                self.logger.error(error_msg)
+                raise PresignError(error_msg)
+            
+            result = response.json()
+            
+            if "presigned_url" not in result or "file_path" not in result:
+                error_msg = "Invalid presign response: missing required fields"
+                self.logger.error(error_msg)
+                raise PresignError(error_msg)
+            
+            self.logger.info(f"Presigned URL obtained successfully for {file_name}")
+            return result
+            
+        except PresignError:
+            raise
+        except requests.exceptions.RequestException as e:
+            error_msg = f"Network error during presign: {str(e)}"
+            self.logger.error(error_msg)
+            raise PresignError(error_msg) from e
+        except Exception as e:
+            error_msg = f"Unexpected error during presign: {str(e)}"
+            self.logger.error(error_msg)
+            raise PresignError(error_msg) from e
+    
+    def upload(
+        self,
+        presigned_url: str,
+        file_path: str,
+        mime_type: Optional[str] = None
+    ) -> bool:
+        """
+        Upload a file to the presigned URL.
+        
+        Args:
+            presigned_url: Presigned URL obtained from get_presigned_url() method
+            file_path: Local path to the file to upload
+            mime_type: MIME type of the file (auto-detected if not provided)
+            
+        Returns:
+            True if upload was successful
+            
+        Raises:
+            UploadError: If the upload operation fails
+        """
+        if not os.path.exists(file_path):
+            error_msg = f"File not found: {file_path}"
+            self.logger.error(error_msg)
+            raise UploadError(error_msg)
+        
+        if mime_type is None:
+            mime_type = ImageDetectionService.guess_mime_type(file_path)
+        
+        self.logger.info(f"Uploading file {file_path} (MIME type: {mime_type})")
+        
+        try:
+            file_stats = os.stat(file_path)
+            file_size = file_stats.st_size
+            
+            with open(file_path, "rb") as f:
+                response = requests.put(
+                    presigned_url,
+                    headers={
+                        'Content-Type': mime_type,
+                        'x-amz-acl': 'private',
+                        'Content-Length': str(file_size),
+                    },
+                    data=f,
+                    timeout=300,  # 5 minutes for file uploads
+                )
+            
+            self.logger.debug(f"Upload response status: {response.status_code}")
+            
+            if response.status_code not in (200, 204):
+                error_msg = f"Upload failed with status {response.status_code}"
+                self.logger.error(error_msg)
+                raise UploadError(error_msg)
+            
+            self.logger.info(f"File uploaded successfully: {file_path}")
+            return True
+            
+        except UploadError:
+            raise
+        except requests.exceptions.RequestException as e:
+            error_msg = f"Network error during upload: {str(e)}"
+            self.logger.error(error_msg)
+            raise UploadError(error_msg) from e
+        except Exception as e:
+            error_msg = f"Unexpected error during upload: {str(e)}"
+            self.logger.error(error_msg)
+            raise UploadError(error_msg) from e
+    
+    def detect(
+        self,
+        file_url: str,
+        email: Optional[str] = None,
+        generate_preview: bool = False
+    ) -> DetectResponse:
+        """
+        Submit an image for AI detection.
+        
+        Args:
+            file_url: URL of the uploaded file
+            email: Optional email address for processing
+            generate_preview: Optional flag to generate preview (default: False)
+            
+        Returns:
+            DetectResponse containing detection ID and status
+            
+        Raises:
+            DetectError: If the detect operation fails
+        """
+        self.logger.info(f"Submitting detect request for URL: {file_url}")
+        
+        payload: Dict[str, Any] = {
+            "key": self.api_key,
+            "url": file_url,
+            "document_type": "Image",
+            "model": "generic",
+            "generate_preview": generate_preview,
+        }
+        
+        if email:
+            payload["email"] = email
+        
+        try:
+            response = requests.post(
+                f"{self.base_url}/detect",
+                headers={'Content-Type': 'application/json'},
+                json=payload,
+                timeout=120,  # 2 minutes for detect requests
+            )
+            
+            self.logger.debug(f"Detect response status: {response.status_code}")
+            
+            if not response.ok:
+                error_msg = f"Detect failed with status {response.status_code}"
+                try:
+                    error_data = response.json()
+                    error_msg = error_data.get("error", error_msg)
+                except Exception:
+                    error_msg = f"{error_msg}: {response.text}"
+                
+                self.logger.error(error_msg)
+                raise DetectError(error_msg)
+            
+            result = response.json()
+            
+            if "id" not in result:
+                error_msg = "Invalid detect response: missing detection ID"
+                self.logger.error(error_msg)
+                raise DetectError(error_msg)
+            
+            detect_id = result.get("id")
+            self.logger.info(f"Detect request submitted successfully. ID: {detect_id}")
+            return result
+            
+        except DetectError:
+            raise
+        except Exception as e:
+            if isinstance(e, DetectError):
+                raise
+            
+            error_msg = (
+                f"Network error during detect: {str(e)}"
+                if hasattr(e, 'message') and e.message
+                else f"Unexpected error during detect: {str(e)}"
+            )
+            self.logger.error(error_msg)
+            raise DetectError(error_msg) from e
+    
+    def query(self, detect_id: str) -> QueryResponse:
+        """
+        Query the detection status and results.
+        
+        Args:
+            detect_id: Detection ID returned from detect() method
+            
+        Returns:
+            QueryResponse containing detection status and results
+            
+        Raises:
+            QueryError: If the query operation fails
+        """
+        self.logger.debug(f"Querying detection status for ID: {detect_id}")
+        
+        try:
+            response = requests.post(
+                f"{self.base_url}/query",
+                headers={'Content-Type': 'application/json'},
+                json={'id': detect_id},
+                timeout=self.timeout,
+            )
+            
+            self.logger.debug(f"Query response status: {response.status_code}")
+            
+            if not response.ok:
+                error_msg = f"Query failed with status {response.status_code}"
+                try:
+                    error_data = response.json()
+                    error_msg = error_data.get("error", error_msg)
+                except Exception:
+                    error_msg = f"{error_msg}: {response.text}"
+                
+                self.logger.error(error_msg)
+                raise QueryError(error_msg)
+            
+            response_text = response.text
+            if response_text.strip() == "null" or not response_text.strip():
+                self.logger.warn(f"Document not found for ID: {detect_id}")
+                return {"id": detect_id, "status": "not_found"}
+            
+            result = response.json()
+            
+            if result is None:
+                self.logger.warn(f"Document not found for ID: {detect_id}")
+                return {"id": detect_id, "status": "not_found"}
+            
+            status = result.get("status", "unknown")
+            self.logger.debug(f"Query result status: {status}")
+            return result
+            
+        except QueryError:
+            raise
+        except requests.exceptions.RequestException as e:
+            error_msg = f"Network error during query: {str(e)}"
+            self.logger.error(error_msg)
+            raise QueryError(error_msg) from e
+        except Exception as e:
+            error_msg = f"Unexpected error during query: {str(e)}"
+            self.logger.error(error_msg)
+            raise QueryError(error_msg) from e
+    
+    def poll_for_result(
+        self,
+        detect_id: str,
+        max_attempts: int = 60,
+        sleep_seconds: float = 0.5,
+        callback: Optional[Callable[[int, QueryResponse], None]] = None
+    ) -> Optional[QueryResponse]:
+        """
+        Poll for detection results until completion.
+        
+        Continues polling until status is "done" or "failed"
+        or until max_attempts is reached.
+        
+        Args:
+            detect_id: Detection ID returned from detect() method
+            max_attempts: Maximum number of polling attempts (default: 60)
+            sleep_seconds: Seconds to sleep between attempts (default: 0.5)
+            callback: Optional callback function called on each attempt
+            
+        Returns:
+            Final result if status reached completion, None if timeout
+        """
+        self.logger.info(f"Starting to poll for detection ID: {detect_id}")
+        
+        final_result: Optional[QueryResponse] = None
+        
+        for attempt_idx in range(1, max_attempts + 1):
+            try:
+                result = self.query(detect_id)
+                
+                if callback:
+                    try:
+                        callback(attempt_idx, result)
+                    except Exception as e:
+                        self.logger.warn(f"Callback error: {e}")
+                
+                status = result.get("status", "unknown")
+                
+                if status == "done" or status == "failed":
+                    final_result = result
+                    self.logger.info(
+                        f"Polling completed. Status: {status} "
+                        f"(attempt {attempt_idx}/{max_attempts})"
+                    )
+                    break
+                
+                if attempt_idx < max_attempts:
+                    time.sleep(sleep_seconds)
+                    
+            except QueryError as e:
+                self.logger.warn(f"Query error on attempt {attempt_idx}: {e}")
+                time.sleep(sleep_seconds)
+                continue
+            except Exception as e:
+                self.logger.warn(
+                    f"Unexpected error on attempt {attempt_idx}: "
+                    f"{str(e) if hasattr(e, '__str__') else 'Unknown error'}"
+                )
+                time.sleep(sleep_seconds)
+                continue
+        
+        if final_result is None:
+            self.logger.warn(
+                f"Polling timeout reached for detection ID: {detect_id} "
+                f"(max attempts: {max_attempts})"
+            )
+        
+        return final_result
+    
+    def check_user_credits(self) -> CreditCheckResponse:
+        """
+        Check user credits for the API key.
+        
+        Returns:
+            CreditCheckResponse containing credit information
+            
+        Raises:
+            CreditCheckError: If the credit check operation fails
+        """
+        self.logger.info(f"Requesting credit check for API key: {self.api_key}")
+        
+        try:
+            response = requests.get(
+                f"{self.base_url}/check-user-credits",
+                headers={'apikey': self.api_key},
+                timeout=self.timeout,
+            )
+            
+            self.logger.debug(f"Credit check response status: {response.status_code}")
+            
+            if not response.ok:
+                error_msg = f"Credit check failed with status {response.status_code}"
+                try:
+                    error_data = response.json()
+                    error_msg = error_data.get("error", error_msg)
+                except Exception:
+                    error_msg = f"{error_msg}: {response.text}"
+                
+                self.logger.error(error_msg)
+                raise CreditCheckError(error_msg)
+            
+            result = response.json()
+            
+            # Check if response has required fields
+            if not result or not isinstance(result, dict):
+                error_msg = (
+                    f"Invalid credit check response: unexpected response format. "
+                    f"Response: {result}"
+                )
+                self.logger.error(error_msg)
+                raise CreditCheckError(error_msg)
+            
+            # Check for required fields (allow 0 values but not undefined/null)
+            if (
+                result.get("baseCredits") is None
+                or result.get("boostCredits") is None
+                or result.get("credits") is None
+            ):
+                error_msg = (
+                    f"Invalid credit check response: missing required fields. "
+                    f"Response: {result}"
+                )
+                self.logger.error(error_msg)
+                raise CreditCheckError(error_msg)
+            
+            self.logger.info("Credit check obtained successfully")
+            return result
+            
+        except CreditCheckError:
+            raise
+        except requests.exceptions.RequestException as e:
+            error_msg = f"Network error during credit check: {str(e)}"
+            self.logger.error(error_msg)
+            raise CreditCheckError(error_msg) from e
+        except Exception as e:
+            error_msg = f"Unexpected error during credit check: {str(e)}"
+            self.logger.error(error_msg)
+            raise CreditCheckError(error_msg) from e
+    
+    @staticmethod
+    def build_detect_file_url(
+        file_path_remote: str,
+        presigned_url: str
+    ) -> str:
+        """
+        Build the full file URL for detect operation.
+        
+        If file_path_remote is already a full URL, returns it as-is.
+        Otherwise, constructs URL from presigned URL origin.
+        
+        Args:
+            file_path_remote: Remote file path or full URL
+            presigned_url: Presigned URL to extract origin from
+            
+        Returns:
+            Full URL to the file
+        """
+        if file_path_remote.startswith("http://") or file_path_remote.startswith("https://"):
+            return file_path_remote
+        
+        parsed = urlparse(presigned_url)
+        origin = f"{parsed.scheme}://{parsed.netloc}"
+        return f"{origin}/{file_path_remote.lstrip('/')}"

truthscan_image_detector_client-0.0.1/src/truthscan_image_detector_client.egg-info/PKG-INFO

@@ -0,0 +1,7 @@
+Metadata-Version: 2.4
+Name: truthscan-image-detector-client
+Version: 0.0.1
+Summary: Python client for AI Image Detection API
+Author: undetectableai
+Requires-Python: >=3.9
+Requires-Dist: requests>=2.31.0

truthscan_image_detector_client-0.0.1/src/truthscan_image_detector_client.egg-info/SOURCES.txt

@@ -0,0 +1,14 @@
+pyproject.toml
+src/ai_image_detection/__init__.py
+src/ai_image_detection/api_types.py
+src/ai_image_detection/client.py
+src/ai_image_detection/errors.py
+src/ai_image_detection/logger.py
+src/ai_image_detection/py.typed
+src/ai_image_detection/service.py
+src/truthscan_image_detector_client.egg-info/PKG-INFO
+src/truthscan_image_detector_client.egg-info/SOURCES.txt
+src/truthscan_image_detector_client.egg-info/dependency_links.txt
+src/truthscan_image_detector_client.egg-info/requires.txt
+src/truthscan_image_detector_client.egg-info/top_level.txt
+tests/test_client.py

truthscan_image_detector_client-0.0.1/src/truthscan_image_detector_client.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

truthscan_image_detector_client-0.0.1/src/truthscan_image_detector_client.egg-info/requires.txt

@@ -0,0 +1 @@
+requests>=2.31.0

truthscan_image_detector_client-0.0.1/src/truthscan_image_detector_client.egg-info/top_level.txt

@@ -0,0 +1 @@
+ai_image_detection

truthscan_image_detector_client-0.0.1/tests/test_client.py

@@ -0,0 +1,304 @@
+import os
+import sys
+import json
+import time
+from pathlib import Path
+from typing import List, Dict, Optional, Any
+
+from ai_image_detection import ImageDetectionClient
+
+def log(message: str) -> None:
+    """Log a message with timestamp."""
+    timestamp = time.strftime('%H:%M:%S')
+    print(f"[{timestamp}] {message}")
+
+
+def discover_image_files(
+    folder: str,
+    allowed_exts: set,
+    min_bytes: int,
+    max_bytes: int
+) -> List[str]:
+    """
+    Discover image files in the specified folder.
+    
+    Args:
+        folder: Folder path to search
+        allowed_exts: Set of allowed file extensions
+        min_bytes: Minimum file size in bytes
+        max_bytes: Maximum file size in bytes
+        
+    Returns:
+        List of image file names
+    """
+    files: List[str] = []
+    
+    if not os.path.exists(folder):
+        return files
+    
+    entries = os.listdir(folder)
+    
+    for entry in entries:
+        entry_path = os.path.join(folder, entry)
+        
+        try:
+            stats = os.stat(entry_path)
+            if os.path.isdir(entry_path):
+                continue
+        except Exception:
+            continue
+        
+        ext = os.path.splitext(entry)[1].lower()
+        if ext not in allowed_exts:
+            continue
+        
+        try:
+            file_size = stats.st_size
+            if file_size < min_bytes or file_size > max_bytes:
+                continue
+        except Exception:
+            continue
+        
+        files.append(entry)
+    
+    return files
+
+
+def process_file(
+    client: ImageDetectionClient,
+    folder: str,
+    file_name: str
+) -> Dict[str, Any]:
+    """
+    Process a single image file through the complete workflow.
+    
+    Args:
+        client: ImageDetectionClient instance
+        folder: Folder containing the image
+        file_name: Name of the image file
+        
+    Returns:
+        Dictionary containing processing results and timing information
+    """
+    log(f"Processing file: {file_name}")
+    
+    file_start_time = time.time()
+    full_path = os.path.join(folder, file_name)
+    
+    result_data: Dict[str, Any] = {
+        "filename": file_name,
+        "detect_id": None,
+        "status": "error",
+        "error_message": None,
+        "query_result": None,
+        "total_time": 0,
+    }
+    
+    try:
+        log(f"Starting detection for {file_name}...")
+        final_result = client.detect(full_path)
+        
+        result_data["total_time"] = time.time() - file_start_time
+        result_data["detect_id"] = final_result.get("id")
+        result_data["query_result"] = final_result
+        result_data["status"] = final_result.get("status", "unknown")
+        
+        status = final_result.get("status")
+        result_value = final_result.get("result")
+        log(f"Detection completed. Status: {status}, Result: {result_value}")
+        log(f"Total time: {result_data['total_time']:.3f}s")
+        
+        return result_data
+    except Exception as e:
+        result_data["total_time"] = time.time() - file_start_time
+        if e is not None:
+            result_data["error_message"] = f"Query error: {str(e)}"
+            result_data["status"] = "query_error"
+        else:
+            result_data["error_message"] = f"Error: {str(e)}"
+            result_data["status"] = "error"
+        log(f"Error: {result_data['error_message']}")
+        return result_data
+
+
+def print_summary(results: List[Dict[str, Any]]) -> None:
+    """Print a summary of all processing results."""
+    print("\n" + "=" * 70)
+    print("  PROCESSING SUMMARY")
+    print("=" * 70)
+    
+    total_files = len(results)
+    successful_submissions = sum(1 for r in results if r.get("detect_id"))
+    errors = sum(1 for r in results if r.get("status") == "error")
+    completed = sum(1 for r in results if r.get("status") in ("done", "failed"))
+    pending = sum(1 for r in results if r.get("status") in ("submitted", "pending"))
+    
+    print(f"\nTotal files processed: {total_files}")
+    print(f"Successful submissions: {successful_submissions}")
+    print(f"Errors: {errors}")
+    print(f"Completed (done/failed): {completed}")
+    print(f"Pending/Submitted: {pending}")
+    
+    if successful_submissions > 0:
+        total_processing_time = sum(r.get("total_time", 0) for r in results)
+        
+        print("\n" + "-" * 70)
+        print("Timing Statistics:")
+        print(f"  Average total time: {(total_processing_time / successful_submissions):.3f}s")
+    
+    failed_files = [r for r in results if r.get("status") == "error" or r.get("error_message")]
+    if failed_files:
+        print("\n" + "-" * 70)
+        print("Failed Files:")
+        for result in failed_files:
+            filename = result.get("filename", "unknown")
+            error = result.get("error_message", "Unknown error")
+            print(f"  - {filename}: {error}")
+    
+    print("\n" + "=" * 70)
+
+
+def main() -> None:
+    """Main test function."""
+    print("\n" + "=" * 70)
+    print("  Image Detection Client Test Script - Batch Processing")
+    print("=" * 70)
+    
+    # For local testing
+    # BASE_URL = 'http://localhost:8000'
+    
+    # For development
+    # BASE_URL = 'https://ai-image-detector-dev-api-server-zo6e9.ondigitalocean.app'
+    
+    # For production
+    BASE_URL = 'https://ai-image-detect.undetectable.ai'
+    
+    API_KEY = "<YOUR API KEY>"
+    
+    # Folder path
+    FOLDER = "./test_images/"
+    
+    # Allow folder path as command line argument
+    if len(sys.argv) > 1:
+        folder_arg = sys.argv[1]
+        try:
+            stats = os.stat(folder_arg)
+            if os.path.isdir(folder_arg):
+                FOLDER = folder_arg
+            elif os.path.isfile(folder_arg):
+                FOLDER = os.path.dirname(folder_arg)
+            else:
+                print(f"Invalid path: {folder_arg}")
+                sys.exit(1)
+        except Exception:
+            print(f"Invalid path: {folder_arg}")
+            sys.exit(1)
+    
+    ALLOWED_EXTS = {
+        '.jpg',
+        '.jpeg',
+        '.png',
+        '.bmp',
+        '.tiff',
+        '.webp',
+        '.heic',
+        '.heif',
+        '.avif',
+        '.jfif',
+        '.tif',
+        '.svg',
+        '.gif',
+    }
+    MIN_BYTES = 1 * 1024
+    MAX_BYTES = 10 * 1024 * 1024
+    
+    log('Initializing ImageDetectionClient...')
+    client = ImageDetectionClient(API_KEY, BASE_URL)
+    
+    initial_credits = None
+    try:
+        log('Checking initial credits...')
+        initial_credits = client.check_user_credits()
+        log(
+            f"Initial credits - Base: {initial_credits['baseCredits']}, "
+            f"Boost: {initial_credits['boostCredits']}, "
+            f"Total: {initial_credits['credits']}"
+        )
+    except Exception as e:
+        if e is not None:
+            log(f"Warning: Could not check initial credits: {str(e)}")
+        else:
+            log(f"Warning: Could not check initial credits: {str(e)}")
+    
+    log(f"\nSearching for image files in: {FOLDER}")
+    if not os.path.exists(FOLDER):
+        print(f"Folder not found: {FOLDER}")
+        print('\nUsage:')
+        print('  python test_api_client.py [folder_path]')
+        sys.exit(1)
+    
+    files = discover_image_files(FOLDER, ALLOWED_EXTS, MIN_BYTES, MAX_BYTES)
+    
+    if len(files) == 0:
+        print(f"No valid image files found in: {FOLDER}")
+        print(f"\nAllowed extensions: {', '.join(sorted(ALLOWED_EXTS))}")
+        print(f"File size limits: {MIN_BYTES} bytes - {MAX_BYTES} bytes")
+        sys.exit(1)
+    
+    log(f"Found {len(files)} files to process")
+    
+    results: List[Dict[str, Any]] = []
+    
+    for file_name in files:
+        result = process_file(client, FOLDER, file_name)
+        results.append(result)
+        print()  # Empty line between files
+    
+    print_summary(results)
+    
+    final_credits = None
+    try:
+        log('\nChecking final credits...')
+        final_credits = client.check_user_credits()
+        log(
+            f"Final credits - Base: {final_credits['baseCredits']}, "
+            f"Boost: {final_credits['boostCredits']}, "
+            f"Total: {final_credits['credits']}"
+        )
+        
+        if initial_credits and final_credits:
+            credits_charged = initial_credits['credits'] - final_credits['credits']
+            print('\n' + '-' * 70)
+            print('CREDIT USAGE SUMMARY')
+            print('-' * 70)
+            print(f"Initial Credits: {initial_credits['credits']}")
+            print(f"Final Credits: {final_credits['credits']}")
+            print(f"Credits Used: {credits_charged}")
+            print('-' * 70)
+    except Exception as e:
+        if e is not None:
+            log(f"Warning: Could not check final credits: {str(e)}")
+        else:
+            log(f"Warning: Could not check final credits: {str(e)}")
+    
+    output_file = 'api_client_test_results.json'
+    with open(output_file, 'w', encoding='utf-8') as f:
+        json.dump(results, f, ensure_ascii=False, indent=2)
+    log(f"\nResults saved to: {output_file}")
+    
+    print('\n' + '=' * 70)
+    print('  All processing completed!')
+    print('=' * 70)
+
+
+if __name__ == "__main__":
+    try:
+        main()
+    except KeyboardInterrupt:
+        print("\n\n Processing interrupted by user")
+        sys.exit(1)
+    except Exception as error:
+        print(f"\n Unexpected error: {error}")
+        import traceback
+        traceback.print_exc()
+        sys.exit(1)