deepxl-python-sdk 1.0.1__py3-none-any.whl → 1.2.1__py3-none-any.whl

deepxl/__init__.py

@@ -0,0 +1,49 @@
+"""DeepXL Python SDK"""
+
+from .client import DeepXLClient
+from .types import (
+    Tag,
+    FileData,
+    ModelMetadata,
+    FraudDetection,
+    DetectionHistoryResponse,
+    DetectionResponse,
+    DetectionQueryParams,
+    AnalyzeFileOptions,
+    APIParse,
+    APIParseHistoryResponse,
+    APIParseResponse,
+    ParseQueryParams,
+    ParseDocumentOptions,
+    Verification,
+    VerificationResponse,
+    APIVerificationHistoryResponse,
+    VerificationQueryParams,
+    VerifyOptions,
+    DeepXLClientConfig,
+)
+
+__all__ = [
+    'DeepXLClient',
+    'Tag',
+    'FileData',
+    'ModelMetadata',
+    'FraudDetection',
+    'DetectionHistoryResponse',
+    'DetectionResponse',
+    'DetectionQueryParams',
+    'AnalyzeFileOptions',
+    'APIParse',
+    'APIParseHistoryResponse',
+    'APIParseResponse',
+    'ParseQueryParams',
+    'ParseDocumentOptions',
+    'Verification',
+    'VerificationResponse',
+    'APIVerificationHistoryResponse',
+    'VerificationQueryParams',
+    'VerifyOptions',
+    'DeepXLClientConfig',
+]
+
+__version__ = '1.0.0'

deepxl/client.py

@@ -0,0 +1,278 @@
+"""DeepXL API Client"""
+
+import json
+import requests
+from typing import Optional, Dict, Any, Union, List
+from io import BytesIO
+
+from .types import (
+    DeepXLClientConfig,
+    ModelMetadata,
+    DetectionHistoryResponse,
+    DetectionResponse,
+    DetectionQueryParams,
+    AnalyzeFileOptions,
+    APIParseHistoryResponse,
+    APIParseResponse,
+    ParseQueryParams,
+    ParseDocumentOptions,
+    APIVerificationHistoryResponse,
+    VerificationResponse,
+    VerificationQueryParams,
+    VerifyOptions,
+)
+
+
+class DeepXLClient:
+    """Client for interacting with the DeepXL API"""
+
+    BASE_URL = 'https://api.deepxl.ai'
+
+    def __init__(self, config: DeepXLClientConfig):
+        """
+        Initialize the DeepXL client.
+
+        Args:
+            config: Configuration object containing apiKey
+        """
+        if not config.apiKey:
+            raise ValueError('apiKey must be provided')
+        self.api_key = config.apiKey
+        self.base_url = self.BASE_URL
+
+    def _get_headers(self) -> Dict[str, str]:
+        """Get default headers for API requests"""
+        return {
+            'x-api-key': self.api_key,
+        }
+
+    def _request(
+        self,
+        method: str,
+        path: str,
+        params: Optional[Dict[str, Any]] = None,
+        files: Optional[Dict[str, Any]] = None,
+        data: Optional[Dict[str, Any]] = None,
+    ) -> Any:
+        """
+        Make an HTTP request to the API.
+
+        Args:
+            method: HTTP method (GET, POST, etc.)
+            path: API endpoint path
+            params: Query parameters
+            files: Files to upload (for multipart/form-data)
+            data: Form data (for multipart/form-data)
+
+        Returns:
+            Response JSON data
+
+        Raises:
+            ValueError: If the request fails
+        """
+        url = f'{self.base_url}{path}'
+        headers = self._get_headers()
+
+        # Prepare query parameters
+        query_params = {}
+        if params:
+            for key, value in params.items():
+                if value is not None:
+                    query_params[key] = value
+
+        try:
+            if files or data:
+                # Multipart form data request
+                response = requests.request(
+                    method=method,
+                    url=url,
+                    headers=headers,
+                    params=query_params,
+                    files=files,
+                    data=data,
+                )
+            else:
+                # JSON request
+                response = requests.request(
+                    method=method,
+                    url=url,
+                    headers=headers,
+                    params=query_params,
+                )
+
+            response.raise_for_status()
+
+            # Handle file downloads
+            content_type = response.headers.get('content-type', '')
+            if 'application/octet-stream' in content_type:
+                return response
+
+            return response.json()
+
+        except requests.exceptions.HTTPError as e:
+            error_message = str(e)
+            try:
+                error_json = response.json()
+                error_message = error_json.get('detail') or error_json.get('message') or error_message
+            except:
+                pass
+            raise ValueError(error_message) from e
+
+    def _prepare_file(self, file: Union[bytes, Any], filename: Optional[str] = None) -> tuple:
+        """
+        Prepare a file for upload.
+
+        Args:
+            file: File data (bytes or file-like object)
+            filename: Optional filename
+
+        Returns:
+            Tuple of (file_data, filename)
+        """
+        if isinstance(file, bytes):
+            file_obj = BytesIO(file)
+            filename = filename or 'file'
+        else:
+            # Assume it's a file-like object
+            file_obj = file
+            if hasattr(file, 'name'):
+                filename = filename or file.name
+            else:
+                filename = filename or 'file'
+
+        return (filename, file_obj)
+
+    # Fraud Detection Methods
+    def get_detection_models(self) -> List[ModelMetadata]:
+        """Get available fraud detection models"""
+        return self._request('GET', '/v1/detection-models')
+
+    def get_detection_history(self, params: Optional[DetectionQueryParams] = None) -> DetectionHistoryResponse:
+        """Get fraud detection history"""
+        return self._request('GET', '/v1/detection', params=params)
+
+    def get_detection_by_id(self, detection_id: int) -> DetectionResponse:
+        """Get a fraud detection record by ID"""
+        return self._request('GET', f'/v1/detection/{detection_id}')
+
+    def analyze_file(self, options: AnalyzeFileOptions) -> DetectionResponse:
+        """
+        Analyze a file for fraud detection.
+
+        Args:
+            options: Options containing model, file, fileName, and optional tags
+
+        Returns:
+            Detection response with analysis results
+        """
+        filename, file_obj = self._prepare_file(options.file, options.fileName)
+
+        files = {
+            'file': (filename, file_obj),
+        }
+
+        data = {
+            'model': options.model,
+        }
+
+        if options.tags:
+            data['tags'] = json.dumps(options.tags)
+
+        return self._request('POST', '/v1/detection', files=files, data=data)
+
+    # Document Parsing Methods
+    def get_parsing_models(self) -> List[ModelMetadata]:
+        """Get available parsing models"""
+        return self._request('GET', '/v1/parsing-models')
+
+    def get_parsing_history(self, params: Optional[ParseQueryParams] = None) -> APIParseHistoryResponse:
+        """Get document parsing history"""
+        return self._request('GET', '/v1/parse', params=params)
+
+    def get_parse_by_id(self, parse_id: int) -> APIParseResponse:
+        """Get a parsed document by ID"""
+        return self._request('GET', f'/v1/parse/{parse_id}')
+
+    def parse_document(self, options: ParseDocumentOptions) -> APIParseResponse:
+        """
+        Parse a document.
+
+        Args:
+            options: Options containing model, file, fileName, and optional tags
+
+        Returns:
+            Parse response with extracted data
+        """
+        filename, file_obj = self._prepare_file(options.file, options.fileName)
+
+        files = {
+            'file': (filename, file_obj),
+        }
+
+        data = {
+            'model': options.model,
+        }
+
+        if options.tags:
+            data['tags'] = json.dumps(options.tags)
+
+        return self._request('POST', '/v1/parse', files=files, data=data)
+
+    # Verification Methods
+    def get_verification_history(self, params: Optional[VerificationQueryParams] = None) -> APIVerificationHistoryResponse:
+        """Get verification history"""
+        return self._request('GET', '/v1/verification', params=params)
+
+    def get_verification_by_id(self, verification_id: int) -> VerificationResponse:
+        """Get a verification record by ID"""
+        return self._request('GET', f'/v1/verification/{verification_id}')
+
+    def verify(self, options: VerifyOptions) -> VerificationResponse:
+        """
+        Verify a user with their ID and selfie.
+
+        Args:
+            options: Options containing idFile, selfieFile, and optional tags
+
+        Returns:
+            Verification response with verification results
+        """
+        id_filename, id_file_obj = self._prepare_file(options.idFile, options.idFileName)
+        selfie_filename, selfie_file_obj = self._prepare_file(options.selfieFile, options.selfieFileName)
+
+        files = {
+            'idFile': (id_filename, id_file_obj),
+            'selfieFile': (selfie_filename, selfie_file_obj),
+        }
+
+        data = {}
+        if options.tags:
+            data['tags'] = json.dumps(options.tags)
+
+        return self._request('POST', '/v1/verification', files=files, data=data)
+
+    # File Retrieval Methods
+    def get_file(self, file_name: str) -> requests.Response:
+        """
+        Get a file from the API.
+
+        Args:
+            file_name: Name of the file to retrieve
+
+        Returns:
+            Response object with file content
+        """
+        return self._request('GET', f'/v1/files/{file_name}')
+
+    def download_file(self, file_name: str) -> bytes:
+        """
+        Download a file from the API.
+
+        Args:
+            file_name: Name of the file to download
+
+        Returns:
+            File content as bytes
+        """
+        response = self.get_file(file_name)
+        return response.content

deepxl/types.py

@@ -0,0 +1,205 @@
+"""Type definitions for DeepXL API"""
+
+from typing import TypedDict, Optional, List, Dict, Any, Union, Literal
+from dataclasses import dataclass
+
+
+class Tag(TypedDict):
+    name: str
+    value: str
+
+
+class FileData(TypedDict, total=False):
+    category: Optional[str]
+    fileName: str
+    fileSize: int
+    contentType: str
+    timestamp: int
+    timestampISO: str
+    url: Optional[str]
+
+
+class ModelMetadata(TypedDict):
+    name: str
+    description: str
+    tags: List[str]
+    category: str
+    validInputTypes: List[str]
+    validFileTypes: List[str]
+    ownedBy: str
+    version: str
+
+
+# Fraud Detection Types
+class FraudDetection(TypedDict, total=False):
+    detectionId: int
+    mediaType: str
+    fileName: str
+    size: int
+    fileType: str
+    model: str
+    likelihood: float
+    fraudSeverity: Literal["low", "medium", "high"]
+    reasoning: List[str]
+    modelResults: Dict[str, Any]
+    classification: Optional[str]
+    timestamp: int
+    timestampISO: str
+    tags: List[Tag]
+    files: List[FileData]
+
+
+class DetectionHistoryResponse(TypedDict):
+    totalCount: int
+    count: int
+    data: List[FraudDetection]
+
+
+class DetectionResponse(TypedDict):
+    result: FraudDetection
+
+
+class DetectionQueryParams(TypedDict, total=False):
+    limit: Optional[int]
+    offset: Optional[int]
+    sortBy: Optional[Literal["fraudDetectionId", "fileName", "size", "fileType", "model", "likelihood", "createdOn"]]
+    direction: Optional[Literal["asc", "desc"]]
+    tagFilter: Optional[str]
+    mediaType: Optional[str]
+    fileType: Optional[str]
+    fileName: Optional[str]
+    model: Optional[str]
+    minLikelihood: Optional[float]
+    maxLikelihood: Optional[float]
+    fraudSeverity: Optional[Literal["low", "medium", "high"]]
+    classification: Optional[str]
+    minTimestamp: Optional[int]
+    maxTimestamp: Optional[int]
+
+
+@dataclass
+class AnalyzeFileOptions:
+    model: str
+    file: Union[bytes, Any]  # bytes or file-like object
+    fileName: Optional[str] = None
+    tags: Optional[Dict[str, str]] = None
+
+
+# Document Parsing Types
+class APIParse(TypedDict, total=False):
+    parseId: int
+    mediaType: str
+    fileType: str
+    fileName: str
+    size: int
+    model: str
+    likelihood: float
+    documentType: str
+    parsedData: Dict[str, Any]
+    timestamp: int
+    timestampISO: str
+    tags: List[Tag]
+    files: List[FileData]
+
+
+class APIParseHistoryResponse(TypedDict):
+    totalCount: int
+    count: int
+    data: List[APIParse]
+
+
+class APIParseResponse(TypedDict):
+    result: APIParse
+
+
+class ParseQueryParams(TypedDict, total=False):
+    limit: Optional[int]
+    offset: Optional[int]
+    sortBy: Optional[Literal["parseId", "mediaType", "fileType", "fileName", "size", "confidence", "documentType", "timestamp"]]
+    direction: Optional[Literal["asc", "desc"]]
+    tagFilter: Optional[str]
+    mediaType: Optional[str]
+    fileType: Optional[str]
+    fileName: Optional[str]
+    minSize: Optional[int]
+    maxSize: Optional[int]
+    model: Optional[str]
+    documentType: Optional[str]
+    minTimestamp: Optional[int]
+    maxTimestamp: Optional[int]
+
+
+@dataclass
+class ParseDocumentOptions:
+    model: str
+    file: Union[bytes, Any]  # bytes or file-like object
+    fileName: Optional[str] = None
+    tags: Optional[Dict[str, str]] = None
+
+
+# Verification Types
+class TechnicalCheck(TypedDict, total=False):
+    type: str
+    status: str
+    confidence: Optional[float]
+    details: Optional[str]
+
+
+class Verification(TypedDict, total=False):
+    verificationId: int
+    idName: str
+    idSize: int
+    idFileType: str
+    selfieName: str
+    selfieSize: int
+    selfieFileType: str
+    verified: bool
+    technicalChecks: List[TechnicalCheck]
+    timestamp: int
+    timestampISO: str
+    tags: List[Tag]
+    files: List[FileData]
+
+
+class VerificationResponse(TypedDict):
+    result: Verification
+
+
+class APIVerificationHistoryResponse(TypedDict):
+    totalCount: int
+    count: int
+    data: List[Verification]
+
+
+class VerificationQueryParams(TypedDict, total=False):
+    limit: Optional[int]
+    offset: Optional[int]
+    sortBy: Optional[Literal["verificationId", "idName", "idSize", "idFileType", "selfieName", "selfieSize", "selfieFileType", "verified", "timestamp"]]
+    direction: Optional[Literal["asc", "desc"]]
+    tagFilter: Optional[str]
+    idName: Optional[str]
+    idFileType: Optional[str]
+    selfieName: Optional[str]
+    selfieFileType: Optional[str]
+    minIdSize: Optional[int]
+    maxIdSize: Optional[int]
+    minSelfieSize: Optional[int]
+    maxSelfieSize: Optional[int]
+    verified: Optional[bool]
+    minTimestamp: Optional[int]
+    maxTimestamp: Optional[int]
+
+
+@dataclass
+class VerifyOptions:
+    idFile: Union[bytes, Any]  # bytes or file-like object
+    idFileName: Optional[str] = None
+    selfieFile: Union[bytes, Any]  # bytes or file-like object
+    selfieFileName: Optional[str] = None
+    tags: Optional[Dict[str, str]] = None
+
+
+# Client Configuration
+@dataclass
+class DeepXLClientConfig:
+    apiKey: str

deepxl_python_sdk-1.2.1.dist-info/METADATA

@@ -0,0 +1,326 @@
+Metadata-Version: 2.4
+Name: deepxl-python-sdk
+Version: 1.2.1
+Summary: Python SDK for DeepXL fraud detection, document parsing, and verification services
+Home-page: https://github.com/deepxl/deepxl-python-sdk
+Author: DeepXL
+Author-email: david@deepxl.ai
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.8
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+Requires-Dist: requests>=2.28.0
+Dynamic: author
+Dynamic: author-email
+Dynamic: classifier
+Dynamic: description
+Dynamic: description-content-type
+Dynamic: home-page
+Dynamic: requires-dist
+Dynamic: requires-python
+Dynamic: summary
+
+# DeepXL Python SDK
+
+Python SDK for DeepXL fraud detection, document parsing, verification, and file retrieval services.
+
+## Installation
+
+```bash
+pip install deepxl
+```
+
+Or install from source:
+
+```bash
+pip install -r requirements.txt
+```
+
+## Usage
+
+### Initialize the Client
+
+```python
+from deepxl import DeepXLClient, DeepXLClientConfig
+
+config = DeepXLClientConfig(apiKey='your-api-key-here')
+client = DeepXLClient(config)
+```
+
+## Fraud Detection
+
+### Get Available Models
+
+```python
+models = client.get_detection_models()
+print(models)
+```
+
+### Analyze a File for Fraud Detection
+
+```python
+from deepxl import AnalyzeFileOptions
+
+# Read file as bytes
+with open('document.jpg', 'rb') as f:
+    file_data = f.read()
+
+options = AnalyzeFileOptions(
+    model='document',  # or 'object'
+    file=file_data,
+    fileName='document.jpg',
+    tags={
+        'customerId': '9999',
+        'customerName': 'Acme Corp',
+        'documentId': 'DOC-2024-001'
+    }
+)
+
+result = client.analyze_file(options)
+print(result['result'])
+```
+
+### Get Detection History
+
+```python
+from deepxl import DetectionQueryParams
+
+params = DetectionQueryParams(
+    limit=25,
+    offset=0,
+    sortBy='createdOn',
+    direction='desc',
+    fraudSeverity='high',
+    minLikelihood=70
+)
+
+history = client.get_detection_history(params)
+print(history['data'])
+```
+
+### Get Detection by ID
+
+```python
+detection = client.get_detection_by_id(123)
+print(detection['result'])
+```
+
+## Document Parsing
+
+### Get Available Parsing Models
+
+```python
+models = client.get_parsing_models()
+print(models)
+```
+
+### Parse a Document
+
+```python
+from deepxl import ParseDocumentOptions
+
+# Read file as bytes
+with open('drivers_license.jpg', 'rb') as f:
+    file_data = f.read()
+
+options = ParseDocumentOptions(
+    model='light',  # or 'performance'
+    file=file_data,
+    fileName='drivers_license.jpg',
+    tags={
+        'customerId': '9999',
+        'customerName': 'Acme Corp'
+    }
+)
+
+result = client.parse_document(options)
+print(result['result']['parsedData'])
+```
+
+### Get Parse History
+
+```python
+from deepxl import ParseQueryParams
+
+params = ParseQueryParams(
+    limit=25,
+    offset=0,
+    sortBy='parseId',
+    direction='desc',
+    documentType='usa_driver_license'
+)
+
+history = client.get_parsing_history(params)
+print(history['data'])
+```
+
+### Get Parse by ID
+
+```python
+parse_result = client.get_parse_by_id(117)
+print(parse_result['result'])
+```
+
+## Verification
+
+### Verify User with ID and Selfie
+
+```python
+from deepxl import VerifyOptions
+
+# Read files as bytes
+with open('id.jpg', 'rb') as f:
+    id_data = f.read()
+
+with open('selfie.jpg', 'rb') as f:
+    selfie_data = f.read()
+
+options = VerifyOptions(
+    idFile=id_data,
+    idFileName='id.jpg',
+    selfieFile=selfie_data,
+    selfieFileName='selfie.jpg',
+    tags={
+        'customerId': '9999',
+        'customerName': 'Acme Corp'
+    }
+)
+
+result = client.verify(options)
+print(result['result']['verified'])
+print(result['result']['technicalChecks'])
+```
+
+### Get Verification History
+
+```python
+from deepxl import VerificationQueryParams
+
+params = VerificationQueryParams(
+    limit=25,
+    offset=0,
+    verified=True,
+    sortBy='timestamp',
+    direction='desc'
+)
+
+history = client.get_verification_history(params)
+print(history['data'])
+```
+
+### Get Verification by ID
+
+```python
+verification = client.get_verification_by_id(456)
+print(verification['result'])
+```
+
+## File Retrieval
+
+### Download a File
+
+```python
+file_bytes = client.download_file('fd_123_document.jpg')
+with open('downloaded_file.jpg', 'wb') as f:
+    f.write(file_bytes)
+```
+
+### Get File as Response
+
+```python
+response = client.get_file('fd_123_document.jpg')
+file_bytes = response.content
+with open('downloaded_file.jpg', 'wb') as f:
+    f.write(file_bytes)
+```
+
+## Type Definitions
+
+All type definitions are available for import:
+
+```python
+from deepxl import (
+    Tag,
+    FileData,
+    ModelMetadata,
+    FraudDetection,
+    DetectionResponse,
+    DetectionQueryParams,
+    AnalyzeFileOptions,
+    APIParse,
+    APIParseResponse,
+    ParseQueryParams,
+    ParseDocumentOptions,
+    Verification,
+    VerificationResponse,
+    VerificationQueryParams,
+    VerifyOptions,
+)
+```
+
+## Error Handling
+
+The SDK raises `ValueError` with descriptive error messages:
+
+```python
+try:
+    result = client.analyze_file(options)
+except ValueError as e:
+    print(f'Error: {e}')
+    # Error messages match API error responses
+```
+
+## Query Parameters
+
+All query parameters are optional and can be used to filter and paginate results:
+
+- `limit`: Number of results (1-100, default: 25)
+- `offset`: Number of results to skip (default: 0)
+- `sortBy`: Field to sort by
+- `direction`: 'asc' or 'desc' (default: 'desc')
+- `tagFilter`: Filter by tags in format 'tagName=tagValue'
+- Various model-specific filters (see type definitions for details)
+
+## Tags
+
+Tags are optional metadata that can be attached to analyses for organization and filtering:
+
+```python
+tags = {
+    'customerId': '9999',
+    'customerName': 'Acme Corp',
+    'documentId': 'DOC-2024-001',
+    'companyName': 'DeepXL',
+    'companyId': 'COMP-001'
+}
+```
+
+You can filter results by tags using the `tagFilter` query parameter:
+
+```python
+params = DetectionQueryParams(tagFilter='customerId=9999')
+history = client.get_detection_history(params)
+```
+
+## Using File Objects
+
+You can also pass file-like objects directly:
+
+```python
+# Using open file handle
+with open('document.jpg', 'rb') as f:
+    options = AnalyzeFileOptions(
+        model='document',
+        file=f,
+        fileName='document.jpg'
+    )
+    result = client.analyze_file(options)
+```

deepxl_python_sdk-1.2.1.dist-info/RECORD

@@ -0,0 +1,7 @@
+deepxl/__init__.py,sha256=L0UbVAmAbJXkrlcA5-jvbiiB1i0Fy54Gpld1U3sau_U,1086
+deepxl/client.py,sha256=8qh4Xk4nS71ySLaIFysei-0ErZ_pv7q6wbHDpDWilyY,8797
+deepxl/types.py,sha256=WAW00trHX8vHREVXG0WshF1DiHF5llrrq_w7xhYqXhs,5181
+deepxl_python_sdk-1.2.1.dist-info/METADATA,sha256=9s4BpDfeu-40hr5h5V0S13N65Hkdkm56gk4PGXf-NdQ,6976
+deepxl_python_sdk-1.2.1.dist-info/WHEEL,sha256=wUyA8OaulRlbfwMtmQsvNngGrxQHAvkKcvRmdizlJi0,92
+deepxl_python_sdk-1.2.1.dist-info/top_level.txt,sha256=b2ahz1A886yOBMBtbesRqvMnd9G8qLcKEvblJYAR9LM,7
+deepxl_python_sdk-1.2.1.dist-info/RECORD,,

{deepxl_python_sdk-1.0.1.dist-info → deepxl_python_sdk-1.2.1.dist-info}/WHEEL

@@ -1,5 +1,5 @@
 Wheel-Version: 1.0
-Generator: setuptools (80.8.0)
+Generator: setuptools (80.10.2)
 Root-Is-Purelib: true
 Tag: py3-none-any
 

deepxl_python_sdk-1.2.1.dist-info/top_level.txt

@@ -0,0 +1 @@
+deepxl

deepxl_python_sdk/__init__.py

@@ -1,9 +0,0 @@
-from .client import DeepXLClient, UsageResponse, AnalysisResponse
-from .error import DeepXLError
-
-__all__ = [
-  "DeepXLClient", 
-  "UsageResponse", 
-  "AnalysisResponse",
-  "DeepXLError"
-]

deepxl_python_sdk/client.py

@@ -1,179 +0,0 @@
-import requests
-from .mimetypes import get_mimetype
-from .error import DeepXLError
-import re
-
-URL = "https://api.deepxl.ai/"
-
-
-class UsageResponse:
-  def __init__(self, image_usage_limit, image_usage, video_usage_limit, video_usage, audio_usage_limit, audio_usage, document_usage_limit, document_usage):
-    self.image_usage_limit = image_usage_limit
-    self.image_usage = image_usage
-    self.video_usage_limit = video_usage_limit
-    self.video_usage = video_usage
-    self.audio_usage_limit = audio_usage_limit
-    self.audio_usage = audio_usage
-    self.document_usage_limit = document_usage_limit
-    self.document_usage = document_usage
-  
-
-  def __str__(self):
-    return f"Image Usage: {self.image_usage} / {self.image_usage_limit}\nVideo Usage: {self.video_usage} / {self.video_usage_limit}\nAudio Usage: {self.audio_usage} / {self.audio_usage_limit}\nDocument Usage: {self.document_usage} / {self.document_usage_limit}"
-
-
-class AnalysisResponse:
-  def __init__(self, likelihood, reasoning, model_results: dict):
-    self.likelihood = likelihood
-    self.reasoning = reasoning
-    self.model_results = model_results
-
-
-  def __str__(self):
-    return f"Likelihood: {self.likelihood}\nReasoning: {self.reasoning}\nModel Results: {self.model_results}"
-  
-
-def handle_http_error(res):
-  json = res.json()
-  # print(res.status_code, json)
-  if res.status_code == 200:
-    return
-  if res.status_code == 400:
-    raise DeepXLError(json["message"] if json["message"] else "Bad request.")
-  if res.status_code == 401:
-    raise DeepXLError("Invalid API key.")
-  if res.status_code == 402:
-    raise DeepXLError(json["message"] if json["message"] else "Usage limit reached.")
-  if res.status_code == 403:
-    pass
-  if res.status_code == 404:
-    raise DeepXLError(json["message"] if json["message"] else "Invalid model.")
-  if res.status_code == 415: 
-    raise DeepXLError(json["message"] if json["message"] else "Invalid file type or file type is not compatible with the model.")
-  if res.statusCode == 500:
-    raise DeepXLError("Server error occured. Contact support or try again later.")
-  raise DeepXLError(f"An unknown error occured. Status code: {res.status_code}, Response: {json}")
-
-
-class DeepXLClient:
-  def __init__(self, api_key):
-    """Initialize the DeepXL client with the given API key.
-    args:
-      api_key (str): The API key to use for authentication.
-    """
-    self.api_key = api_key
-
-
-  def check_usage(self):
-    """Return the usage and limits of the account."""
-    res = requests.get(
-      URL + "v1/account/",
-      headers={ "x-api-key": self.api_key },
-      timeout=5.0
-    )
-    try:
-      if res.status_code == 200:
-        json = res.json()
-        return UsageResponse(
-          json["imageUsageLimit"],
-          json["imageUsage"],
-          json["videoUsageLimit"],
-          json["videoUsage"],
-          json["audioUsageLimit"],
-          json["audioUsage"],
-          json["documentUsageLimit"],
-          json["documentUsage"]
-        )
-      else:
-        handle_http_error(res)
-    except ConnectionError as e:
-      raise e
-
-
-  def analyze(self, model_name: str, file_name: str, file_data: bytes):
-    """Analyze file data with the given model and return the result.
-    
-    args:
-      model_name (str): The name of the model to use for analysis.
-      file_name (str): The name of the file to analyze.
-      file_data (bytes): The file data to analyze.
-    returns:
-      AnalysisResponse: The analysis result.
-    """
-    if (len(file_data) == 0):
-      raise DeepXLError("File data is missing or invalid.")
-    try:
-      file_type = get_mimetype(file_name)
-      res = requests.post(
-        URL + "v1/analysis",
-        headers={
-          "x-api-key": self.api_key,
-        },
-        data={
-          "model": model_name
-        },
-        files={
-          "file": (file_name, file_data, file_type)
-        },
-        timeout=5.0
-      )
-      if res.status_code == 200:
-        result = res.json()["result"]
-        return AnalysisResponse(
-          likelihood=result["likelihood"],
-          reasoning=result["reasoning"],
-          model_results=result["modelResults"]
-        )
-      else:
-        handle_http_error(res)          
-    except ConnectionError as e:
-      raise e
-    except DeepXLError as e:
-      raise e
-
-  
-  def analyze_file(self, model_name: str, file: str):
-    """Analyze a file witht the given model and return the result.
-    args:
-      model_name (str): The name of the model to use for analysis.
-      file (str): The path to the file to analyze.
-    returns:
-      AnalysisResponse: The analysis result.
-    """
-    f = None
-    try:
-      f = open(file, "rb")
-      base_name = file.split(r"[\\/]+")[-1]
-      file_type = get_mimetype(file)
-      res = requests.post(
-        URL + "v1/analysis",
-        headers={
-          "x-api-key": self.api_key,
-        },
-        data={
-          "model": model_name
-        },
-        files={
-          "file": (base_name, f, file_type)
-        },
-        timeout=5.0
-      )
-      f.close()
-      if res.status_code == 200:
-        result = res.json()["result"]
-        return AnalysisResponse(
-          likelihood=result["likelihood"],
-          reasoning=result["reasoning"],
-          model_results=result["modelResults"]
-        )
-      else:
-        handle_http_error(res)
-    except ConnectionError as e:
-      if not f.closed:
-        f.close()
-      raise e
-    except FileNotFoundError as e:
-      raise DeepXLError(f'File "{file}" does not exist.')
-    except DeepXLError as e:
-      raise e
-  

deepxl_python_sdk/error.py

@@ -1,5 +0,0 @@
-class DeepXLError(Exception):
-
-  def __init__(self, message: str):
-    self.message = message
-    super().__init__(self.message)

deepxl_python_sdk/mimetypes.py

@@ -1,36 +0,0 @@
-
-# https://mimetype.io/all-types
-
-# This list is likely incomplete. Expand with need for more file compatibility
-
-def get_mimetype(filename: str):
-  ext = filename.split('.')[-1]
-  if (ext == 'jpg' or ext == 'jpeg'):
-    return 'image/jpeg'
-  elif ext == 'png':
-    return 'image/png'
-  elif ext == 'gif':
-    return 'image/gif'
-  elif ext == 'tif' or ext == 'tiff':
-    return 'image/tiff'
-  elif ext == 'bmp':
-    return 'image/bmp'
-  elif ext == 'mp4' or ext == 'mp4v' or ext == 'mpg4':
-    return 'video/mp4'
-  elif ext == 'avi':
-    return 'video/x-msvideo'
-  elif ext == 'wmv':
-    return 'video/x-ms-wmv'
-  elif ext == 'mpeg' or ext == 'mpg' or ext == 'mpe' or ext == 'm1v' or ext == 'm2v' or ext == 'mpa':
-    return 'video/mpeg'
-  elif ext == 'wav':
-    return 'audio/wav'
-  elif ext == 'mp3' or ext == 'mpga' or ext == 'm2a' or ext == 'm3a' or ext == 'mp2':
-    return 'audio/mpeg'
-  elif ext == 'wma':
-    return 'audio/x-ma-wma'
-  elif ext == 'wax':
-    return 'audio/x-ms-wax'
-  elif ext == 'pdf':
-    return 'application/pdf'
-  return None

deepxl_python_sdk-1.0.1.dist-info/METADATA

@@ -1,92 +0,0 @@
-Metadata-Version: 2.4
-Name: deepxl-python-sdk
-Version: 1.0.1
-Summary: Python Software Development Kit for DeepXL AI Fraud Detection Services
-Author-email: deepxl <david@deepxl.ai>
-License-Expression: MIT
-Project-URL: Homepage, https://deepxl.ai
-Project-URL: Issues, https://github.com/deepxl/python-sdk
-Classifier: Programming Language :: Python :: 3
-Classifier: Operating System :: OS Independent
-Requires-Python: >=3.9
-Description-Content-Type: text/markdown
-License-File: LICENSE
-Dynamic: license-file
-
-# deepxl-python-sdk
-Python Software Development Kit for DeepXL fraud detection services
-
-## Installation
-
-Install the SDK using pip
-
-```bash
-pip install deepxl-python-sdk
-```
-
-## Example
-
-To use the DeepXL client, you must first create an API key in the [dashboard](https://app.deepxl.ai/settings?tab=apiKeys). You can create a new API key in Settings -> API Keys -> Create API Key.
-
-Treat this API key like you would any environment secret. Do not commit to a public repository or store in plain text.
-
-```python
-from deepxl-python-sdk import DeepXLClient
-
-client = new DeepXLClient(MY_API_KEY)
-
-analysis_result = client.analyze_file("documents-model", ".\\file.pdf")
-```
-
-## Client methods
-
-### check_usage
-Returns the monthly usage quota and current usage for the payment period for each media type.
-
-#### Returns:
-
-Returns a ```UsageResponse``` object with the following properties:
-
-|Property|Type|
-|----|----|
-|image_usage_limit|int|
-|image_usage|int|
-|video_usage_limit|int|
-|video_usage|int|
-|audio_usage_limit|int|
-|audio_usage|int|
-|document_usage_limit|int|
-|document_usage|int|
-
-### analyze
-
-Analyze file data with DeepXL fraud detection. 
-
-#### Inputs
-
-- **model_name:** the name of the model to use. You can find a complete list in our docs.
-- **file_name:** the name of the file to analyze
-- **file_data**: byte array of file data to analyze
-
-> Note: while you can use a constant string as file name, it is recommended you use unique identifiers to make files easier to find in analysis history.
-
-### analyze_file
-
-Analyze file with DeepXL fraud detection. This does the same thing as ```analyze``` but takes a file path as input instead of binary file data.
-
-#### Inputs
-
-- **model_name:** the name of the model to use. You can find a complete list in our docs.
-- **file:** path of the file to analyze
-
-#### Returns
-
-Both ```analyze``` and ```analyze_file``` return an ```AnalysisResult``` object with the following properties:
-
-| Property | Type | Description |
-|----------|------|-|
-|likelihood|float|The percent likelihood that the file has been manipulated|
-|reasoning|str[]|model reasoning|
-|model_results|dict|model-specific outputs|
-
-

deepxl_python_sdk-1.0.1.dist-info/RECORD

@@ -1,9 +0,0 @@
-deepxl_python_sdk/__init__.py,sha256=f9ore2vYiITQNfhY8wm-CG0UebQ6QIpMvpHJbqHi9SM,196
-deepxl_python_sdk/client.py,sha256=9cm7eNXOrKyQP4Iv8xVR4PT0T2IkGTSpda-teWttmzk,5722
-deepxl_python_sdk/error.py,sha256=xsu0xp4yR48L0eTJtVi7bmIiG7psXg52TZ78_zfGodQ,132
-deepxl_python_sdk/mimetypes.py,sha256=EfXGU0Z6NKRYl_YV31_fJnM8RoxGWRCAltOH4EHrTPc,1090
-deepxl_python_sdk-1.0.1.dist-info/licenses/LICENSE,sha256=im3EHYsOJNyBv1TGpEPlVoa1gPzRiydDr3tRDUVDP_s,1087
-deepxl_python_sdk-1.0.1.dist-info/METADATA,sha256=eqwwj5IpRpqZdrxoOErSC9VhwRkkLTqEn7Cw4PCaQ1w,2756
-deepxl_python_sdk-1.0.1.dist-info/WHEEL,sha256=zaaOINJESkSfm_4HQVc5ssNzHCPXhJm0kEUakpsEHaU,91
-deepxl_python_sdk-1.0.1.dist-info/top_level.txt,sha256=X1AYAPOdVnNRxDCBdmESz-kPg1hIPAenR9WM2nBWzMQ,18
-deepxl_python_sdk-1.0.1.dist-info/RECORD,,

deepxl_python_sdk-1.0.1.dist-info/licenses/LICENSE

@@ -1,21 +0,0 @@
-MIT License
-
-Copyright (c) 2025 DeepXL.ai
-
-Permission is hereby granted, free of charge, to any person obtaining a copy
-of this software and associated documentation files (the "Software"), to deal
-in the Software without restriction, including without limitation the rights
-to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-copies of the Software, and to permit persons to whom the Software is
-furnished to do so, subject to the following conditions:
-
-The above copyright notice and this permission notice shall be included in all
-copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
-SOFTWARE.

deepxl_python_sdk-1.0.1.dist-info/top_level.txt

@@ -1 +0,0 @@
-deepxl_python_sdk