import requests

API_KEY = "YOUR_API_KEY"
headers = {
    "X-API-KEY": API_KEY
}

# Make API request
response = requests.get(
    "https://platform.dewatermark.ai/api/object_removal/v2/erase_watermark",
    headers=headers
)

# With shell, you can just pass the correct header with each request
curl "https://platform.dewatermark.ai/api/object_removal/v2/erase_watermark" \
  -H "X-API-KEY: <API-KEY>"

import requests
import base64
import uuid
import os
from io import BytesIO


def erase_watermark(original_preview_image=None, mask_base=None, mask_brush=None, session_id=None, remove_text="true"):
    API_KEY = "YOUR_API_KEY"
    erase_url = "https://platform.dewatermark.ai/api/object_removal/v2/erase_watermark"
    headers = {
        "X-API-KEY": API_KEY
    }
    erase_files = {}

    if original_preview_image is not None:
        if isinstance(original_preview_image, str) and os.path.isfile(original_preview_image):
            image_file = open(original_preview_image, "rb")
            file_original_preview_image = ("original_preview_image.jpeg", image_file)
        else:
            image_bytes = base64.b64decode(original_preview_image)
            image_file = BytesIO(image_bytes)
            file_original_preview_image = ("original_preview_image.jpeg", image_file)
        erase_files["original_preview_image"] = file_original_preview_image
    else:
        if session_id is not None:
            erase_files["session_id"] = (None, session_id)
        else:
            raise ValueError("Either original_preview_image or session_id must be provided.")


    if mask_base is not None:
        image_bytes = base64.b64decode(mask_base)
        image_file = BytesIO(image_bytes)
        file_mask_base = ("mask_base.jpeg", image_file)

    if mask_brush is not None:
        image_file = open(mask_brush, "rb")
        file_mask_brush = ("mask_brush.png", image_file)


    if original_preview_image is not None:
        erase_files["original_preview_image"] = file_original_preview_image

    if mask_base is not None:
        erase_files["mask_base"] = file_mask_base

    if mask_brush is not None:
        erase_files["mask_brush"] = file_mask_brush

    erase_files["remove_text"] = (None, remove_text)
    data = {"predict_mode": "3.0"}
    erase_response = requests.post(erase_url, headers=headers, files=erase_files, data = data)

    response_data = erase_response.json()
    return {
        "session_id": response_data["session_id"],
        "image_base64": response_data["edited_image"]["image"],
        "mask_base": response_data["edited_image"]["mask"]
    }

# Initial call: Automatically detect and remove visible watermarks using AI
auto_result = erase_watermark("input.jpeg")

# Optional: Uncomment this line to preview the auto-processed result (Base64-encoded image)
output_image_path = "output_image.jpg"
image_data = base64.b64decode(auto_result['image_base64'])
with open(output_image_path, 'wb') as f:
    f.write(image_data)
print(f"Image saved to {output_image_path}")


# Manual refinement: If some watermarks remain, manually specify areas to remove using a brush mask
# manual_result_step_1 = erase_watermark(
#     original_preview_image=auto_result["image_base64"],
#     mask_base=auto_result["mask_base"],
#     mask_brush="mask_brush_manual_step_1.png"
# )

# Optional: Uncomment this line to preview the result after first manual correction
# print(manual_result_step_1["image_base64"])

# Optimization: On subsequent calls, use session_id instead of re-uploading the original image
# manual_result_step_2 = erase_watermark(
#     session_id=manual_result_step_1["session_id"],
#     mask_base=manual_result_step_1["mask_base"],
#     mask_brush="mask_brush_manual_step_2.png"
# )

# Output the final cleaned image (Base64 format)
# print(manual_result_step_2["image_base64"])

curl -X POST "https://platform.dewatermark.ai/api/object_removal/v2/erase_watermark" \
  -H "X-API-KEY: API_KEY" \
  --form 'session_id="SESSION_ID"' \
  --form 'original_preview_image=@"IMAGE_FILE"' \
  --form 'mask_base=@"MASK_BASE_FILE"'\
  --form 'mask_brush=@"MASK_BRUSH_FILE"' \
  --form 'remove_text="true"'
  --form 'predict_mode="3.0"'

{
  "edited_image": {
    "image": "BASE_64_IMAGE",
    "image_id": "image_id",
    "mask": "BASE64_MASK",
    "watermark_mask":"BASE64_MASK"
  },
  "event_id": "event_id",
  "session_id": "session_id"
}

import requests

API_KEY = "YOUR_API_KEY"
headers = {
    "X-API-KEY": API_KEY,
    "Content-Type": "multipart/form-data"
}

# Generate upload URL
upload_url = "https://platform.dewatermark.ai/api/video/v1/upload"
response = requests.post(upload_url, headers=headers)
data = response.json()

task_id = data["task_id"]
upload_signed_url = data["upload_signed_url"]
file_path = data["file_path"]

print(f"Task ID: {task_id}")
print(f"Upload URL: {upload_signed_url}")

curl --request POST \
  --url https://platform.dewatermark.ai/api/video/v1/upload \
  --header 'Content-Type: multipart/form-data' \
  --header 'X-API-KEY: YOUR_API_KEY'

{
  "task_id": "yIuf8WVuRE2pzP2WM48v",
  "upload_signed_url": "https://storage.googleapis.com/...",
  "file_path": "dewatermark-videos-asia-southeast1-prod/yIuf8WVuRE2pzP2WM48v",
  "status": "CREATED",
  "push_notification_token": null,
  "created_at": 1763794508
}

import requests

# Use the upload_signed_url from Step 1
video_file_path = "path/to/your/video.mp4"

with open(video_file_path, 'rb') as video_file:
    headers = {
        "Content-Type": "application/octet-stream"
    }

    upload_response = requests.put(
        upload_signed_url,
        data=video_file,
        headers=headers
    )

    if upload_response.status_code == 200:
        print("Video uploaded successfully")
    else:
        print(f"Upload failed with status code: {upload_response.status_code}")

# Replace UPLOAD_SIGNED_URL with the URL from Step 1
curl --request PUT \
  --url "UPLOAD_SIGNED_URL" \
  --header 'Content-Type: application/octet-stream' \
  --data-binary '@/path/to/your/video.mp4'

import requests

API_KEY = "YOUR_API_KEY"
submit_url = "https://platform.dewatermark.ai/api/video/v1/tasks"

headers = {
    "X-API-KEY": API_KEY,
    "Content-Type": "multipart/form-data"
}

data = {
    "task_id": task_id  # From Step 1
}

response = requests.post(submit_url, headers=headers, data=data)
result = response.json()

print(f"Task submitted: {result}")

curl --request POST \
  --url https://platform.dewatermark.ai/api/video/v1/tasks \
  --header 'Content-Type: multipart/form-data' \
  --header 'X-API-KEY: YOUR_API_KEY' \
  --form 'task_id=yIuf8WVuRE2pzP2WM48v'

import requests
import time

API_KEY = "YOUR_API_KEY"
status_url = f"https://platform.dewatermark.ai/api/video/v1/tasks/{task_id}"

headers = {
    "X-API-KEY": API_KEY
}

# Poll until task is complete
while True:
    response = requests.get(status_url, headers=headers)
    task_data = response.json()

    status = task_data["status"]
    progress = task_data.get("progress", 0)

    print(f"Status: {status}, Progress: {progress}")

    if status == "COMPLETED":
        download_url = task_data["download_signed_url"]
        duration = task_data["duration"]
        print(f"Video processing completed!")
        print(f"Duration: {duration}s")
        print(f"Download URL: {download_url}")

        # Download the processed video
        video_response = requests.get(download_url)
        with open("processed_video.mp4", "wb") as f:
            f.write(video_response.content)
        print("Video downloaded successfully")
        break

    elif status == "FAILED":
        print("Task failed. Credits will be refunded.")
        break

    # Wait before polling again
    time.sleep(5)

curl --request GET \
  --url https://platform.dewatermark.ai/api/video/v1/tasks/yIuf8WVuRE2pzP2WM48v \
  --header 'X-API-KEY: YOUR_API_KEY'

{
  "created_at": 1763794508,
  "task_id": "yIuf8WVuRE2pzP2WM48v",
  "has_watermark": true,
  "instance_name": "snapedit-dewatermark-video-prod-northeast3-zrtv",
  "progress": 1,
  "file_path": "dewatermark-videos-asia-southeast1-prod/yIuf8WVuRE2pzP2WM48v",
  "completed_at": 1763794728,
  "upload_signed_url": "https://storage.googleapis.com/...",
  "push_notification_token": null,
  "duration": 51.3,
  "status": "COMPLETED",
  "download_signed_url": "https://storage.googleapis.com/...",
  "started_at": 1763794550
}

import requests
import time

API_KEY = "YOUR_API_KEY"
VIDEO_FILE_PATH = "input_video.mp4"

# Step 1: Generate upload URL
print("Step 1: Generating upload URL...")
upload_response = requests.post(
    "https://platform.dewatermark.ai/api/video/v1/upload",
    headers={"X-API-KEY": API_KEY, "Content-Type": "multipart/form-data"}
)
upload_data = upload_response.json()
task_id = upload_data["task_id"]
upload_signed_url = upload_data["upload_signed_url"]
print(f"Task ID: {task_id}")

# Step 2: Upload video file
print("Step 2: Uploading video...")
with open(VIDEO_FILE_PATH, 'rb') as video_file:
    upload_result = requests.put(
        upload_signed_url,
        data=video_file,
        headers={"Content-Type": "application/octet-stream"}
    )
print(f"Upload status: {upload_result.status_code}")

# Step 3: Submit task
print("Step 3: Submitting task...")
submit_response = requests.post(
    "https://platform.dewatermark.ai/api/video/v1/tasks",
    headers={"X-API-KEY": API_KEY, "Content-Type": "multipart/form-data"},
    data={"task_id": task_id}
)
print("Task submitted")

# Step 4: Poll for completion
print("Step 4: Polling for completion...")
status_url = f"https://platform.dewatermark.ai/api/video/v1/tasks/{task_id}"
while True:
    status_response = requests.get(
        status_url,
        headers={"X-API-KEY": API_KEY}
    )
    task_data = status_response.json()
    status = task_data["status"]
    progress = task_data.get("progress", 0)

    print(f"Status: {status}, Progress: {progress * 100}%")

    if status == "COMPLETED":
        download_url = task_data["download_signed_url"]
        duration = task_data["duration"]
        cost = duration * 0.2

        print(f"Processing completed!")
        print(f"Video duration: {duration}s")
        print(f"Credit cost: {cost} credits")

        # Download processed video
        video_data = requests.get(download_url).content
        with open("output_video.mp4", "wb") as f:
            f.write(video_data)
        print("Video downloaded to output_video.mp4")
        break

    elif status == "FAILED":
        print("Processing failed. Credits will be refunded.")
        break

    time.sleep(5)

import requests

API_KEY = "YOUR_API_KEY"
headers = {
    "X-API-KEY": API_KEY
}

response = requests.get(
    "https://platform.dewatermark.ai/api/creditInfo",
    headers=headers
)

data = response.json()
print(f"Available credit: {data['data']['available_credit']}")

curl --request GET \
  --url https://platform.dewatermark.ai/api/creditInfo \
  --header 'X-API-KEY: YOUR_API_KEY'

{
  "status": "OK",
  "data": {
    "available_credit": 1000,
    "user_id": "user_id"
  }
}