External File Upload API

import mimetypes
import requests
from pathlib import Path

# Configuration
API_KEY = "your-api-key-here"
BUSINESS_UNIT_ID = "your-business-unit-id-here"
FILE_PATH = "/path/to/your/file.xlsx"
API_URL = "https://api-data-ingestion.deducta.ai/m2m/api/file/upload"

ACCEPTED_EXTENSIONS = {".xlsx", ".parquet", ".csv", ".zip"}
MAX_FILE_SIZE_MB = 50

def upload_file(file_path, business_unit_id, api_key):
    """
    Upload a data file to the Deducta Data Ingestion API.

    Accepts .xlsx, .parquet, .csv, and .zip files; Excel and Parquet are
    preferred. Use a .zip archive to upload a batch of files in one request.

    Args:
        file_path (str): Path to the file to upload
        business_unit_id (str): GUID of the business unit
        api_key (str): API key for authentication

    Returns:
        dict: Response containing fileId, fileName, and businessUnitId

    Raises:
        requests.exceptions.HTTPError: If the request fails
    """
    # Validate file exists
    file = Path(file_path)
    if not file.exists():
        raise FileNotFoundError(f"File not found: {file_path}")

    # Validate file format
    if file.suffix.lower() not in ACCEPTED_EXTENSIONS:
        raise ValueError(f"Unsupported file format: {file.suffix}")

    # Check file size — for a .zip this is the size of the compressed archive
    file_size_mb = file.stat().st_size / (1024 * 1024)
    if file_size_mb > MAX_FILE_SIZE_MB:
        raise ValueError(
            f"File size ({file_size_mb:.2f}MB) exceeds maximum allowed size of {MAX_FILE_SIZE_MB}MB"
        )

    # Prepare the request
    headers = {
        "X-API-Key": api_key
    }

    params = {
        "businessUnitId": business_unit_id
    }

    # Open and upload the file (content type is inferred from the file name)
    content_type = mimetypes.guess_type(file.name)[0] or 'application/octet-stream'
    with open(file_path, 'rb') as f:
        files = {
            'file': (file.name, f, content_type)
        }

        response = requests.put(
            API_URL,
            headers=headers,
            params=params,
            files=files
        )

    # Raise exception for HTTP errors
    response.raise_for_status()

    return response.json()

# Example usage
if __name__ == "__main__":
    try:
        result = upload_file(FILE_PATH, BUSINESS_UNIT_ID, API_KEY)
        print("Upload successful!")
        print(f"File ID: {result['fileId']}")
        print(f"File Name: {result['fileName']}")
        print(f"Business Unit ID: {result['businessUnitId']}")
    except FileNotFoundError as e:
        print(f"Error: {e}")
    except ValueError as e:
        print(f"Validation Error: {e}")
    except requests.exceptions.HTTPError as e:
        print(f"HTTP Error: {e}")
        if e.response.status_code == 400:
            print(f"Validation failed: {e.response.json()}")
        elif e.response.status_code == 401:
            print("Authentication failed - check your API key")
        elif e.response.status_code == 500:
            print(f"Server error: {e.response.json()}")
    except Exception as e:
        print(f"Unexpected error: {e}")

using System;
using System.Collections.Generic;
using System.IO;
using System.Net.Http;
using System.Net.Http.Headers;
using System.Threading.Tasks;
using System.Text.Json;

public class FileUploadClient
{
    private readonly HttpClient _httpClient;
    private readonly string _apiKey;
    private const long MaxFileSizeBytes = 50 * 1024 * 1024; // 50MB

    private static readonly HashSet<string> AcceptedExtensions = new(StringComparer.OrdinalIgnoreCase)
    {
        ".xlsx", ".parquet", ".csv", ".zip"
    };

    public FileUploadClient(string baseUrl, string apiKey)
    {
        _httpClient = new HttpClient { BaseAddress = new Uri(baseUrl) };
        _apiKey = apiKey;
    }

    public async Task<FileUploadResponse> UploadFileAsync(
        string filePath,
        Guid businessUnitId)
    {
        // Validate file exists
        if (!File.Exists(filePath))
        {
            throw new FileNotFoundException("File not found", filePath);
        }

        // Validate file format
        var extension = Path.GetExtension(filePath);
        if (!AcceptedExtensions.Contains(extension))
        {
            throw new ArgumentException($"Unsupported file format: {extension}");
        }

        // Validate file size — for a .zip this is the size of the compressed archive
        var fileInfo = new FileInfo(filePath);
        if (fileInfo.Length > MaxFileSizeBytes)
        {
            throw new ArgumentException(
                $"File size ({fileInfo.Length / 1024 / 1024}MB) exceeds maximum allowed size of 50MB");
        }

        // Validate businessUnitId
        if (businessUnitId == Guid.Empty)
        {
            throw new ArgumentException("businessUnitId cannot be empty");
        }

        // Prepare the multipart form data
        using var content = new MultipartFormDataContent();
        using var fileStream = File.OpenRead(filePath);
        using var streamContent = new StreamContent(fileStream);

        streamContent.Headers.ContentType = new MediaTypeHeaderValue("application/octet-stream");

        content.Add(streamContent, "file", Path.GetFileName(filePath));

        // Prepare the request
        var requestUri = $"/api/file/upload?businessUnitId={businessUnitId}";
        var request = new HttpRequestMessage(HttpMethod.Put, requestUri)
        {
            Content = content
        };
        request.Headers.Add("X-API-Key", _apiKey);

        // Send the request
        var response = await _httpClient.SendAsync(request);

        // Parse response
        var responseContent = await response.Content.ReadAsStringAsync();

        if (!response.IsSuccessStatusCode)
        {
            throw new HttpRequestException(
                $"Upload failed with status {response.StatusCode}: {responseContent}");
        }

        return JsonSerializer.Deserialize<FileUploadResponse>(responseContent);
    }
}

public class FileUploadResponse
{
    public Guid FileId { get; set; }
    public string FileName { get; set; }
    public Guid BusinessUnitId { get; set; }
}

// Example usage
public class Program
{
    public static async Task Main(string[] args)
    {
        var apiKey = "your-api-key-here";
        var businessUnitId = Guid.Parse("your-business-unit-id-here");
        var filePath = @"C:\path\to\your\file.xlsx";
        var apiUrl = "https://api-data-ingestion.deducta.ai/m2m";

        var client = new FileUploadClient(apiUrl, apiKey);

        try
        {
            var result = await client.UploadFileAsync(filePath, businessUnitId);

            Console.WriteLine("Upload successful!");
            Console.WriteLine($"File ID: {result.FileId}");
            Console.WriteLine($"File Name: {result.FileName}");
            Console.WriteLine($"Business Unit ID: {result.BusinessUnitId}");
        }
        catch (FileNotFoundException ex)
        {
            Console.WriteLine($"Error: {ex.Message}");
        }
        catch (ArgumentException ex)
        {
            Console.WriteLine($"Validation Error: {ex.Message}");
        }
        catch (HttpRequestException ex)
        {
            Console.WriteLine($"HTTP Error: {ex.Message}");
        }
        catch (Exception ex)
        {
            Console.WriteLine($"Unexpected error: {ex.Message}");
        }
    }
}