System-to-System File Transfer in an Application

// InnorixClient — shared helper the examples `import static`

// ── Auth & call (used by nearly every example)
void   login(String email, String password);           // obtain & store the access token
Object api(String method, String path, Object body);    // JSON call -> returns data; throws on 4xx

// ── Path & status
String  encodePath(String deviceId, String path);       // item token: {deviceId}_ino_{base64(path)}
boolean isTerminal(Object detail);                      // finished (complete/failed) status?
// status codes: COMPLETE=2 · PAUSE=3 · TRANSFERRING=6 · PARTIAL=9 · FAIL=99

// ── JSON helpers
Map<String,Object> obj(Object... kv);   List<Object> arr(Object... items);    // builders
String str(Object n, String key);   int intv(Object n, String key, int def);  // value access
List<Object> pageItems(Object page);    // normalize list-or-{items}/{data}

// ── Env & JSON:  env(key[, def]) · requireEnv(keys...)  |  Json.write() · Json.parse()

"""Example 01 - One-to-one transfer.

Send a single file from a source device to a target device, then poll until it finishes.

Required environment variables: INNORIX_EMAIL, INNORIX_PASSWORD, INNORIX_WORKSPACE_ID
See ../.env.example for the full list and defaults.

Run:  python "01-1to1-transfer/example.py"
"""

import os
import sys
import time
from pathlib import Path

import requests
from dotenv import load_dotenv

# Load .env from the example's own folder first (so a single downloaded example works
# with a .env placed next to it), then fall back to the shared python/.env one level up.
# python-dotenv does not overwrite variables that are already set, so the folder-local
# .env wins and the shared one only fills in whatever is missing.
_here = Path(__file__).resolve().parent
load_dotenv(_here / ".env")          # same folder as this script
load_dotenv(_here.parent / ".env")   # shared python/.env (used by the full example set)

BASE_URL = os.getenv("INNORIX_BASE_URL", "https://app.innorix.com")
EMAIL = os.getenv("INNORIX_EMAIL")
PASSWORD = os.getenv("INNORIX_PASSWORD")
WORKSPACE_ID = os.getenv("INNORIX_WORKSPACE_ID")
# INNORIX_SOURCE_DEVICE / TARGET_DEVICE accept a device ID, device name, or IP address.
SOURCE_DEVICE = os.getenv("INNORIX_SOURCE_DEVICE", "device-source-01")
TARGET_DEVICE = os.getenv("INNORIX_TARGET_DEVICE", "device-target-01")
SOURCE_PATH = os.getenv("INNORIX_SOURCE_PATH", "/data/report.pdf")
TARGET_PATH = os.getenv("INNORIX_TARGET_PATH", "/data/incoming")

# Transfer status codes and the subset that means "no longer running".
TRANSFER_STATUS = {
    "transferComplete": 2,
    "transferError": 4,
    "transferCancel": 5,
    "transferPartialComplete": 9,
    "transferFail": 99,
}
TERMINAL_TRANSFER_STATUSES = set(TRANSFER_STATUS.values())

def api(method, path, token=None, body=None):
    """Minimal JSON API helper shared by every example."""
    headers = {"Content-Type": "application/json"}
    if token:
        headers["Authorization"] = f"Bearer {token}"
        headers["x-workspace-id"] = WORKSPACE_ID
    response = requests.request(method, BASE_URL + path, headers=headers, json=body)
    try:
        payload = response.json()
    except ValueError:
        payload = {}
    if not response.ok:
        raise RuntimeError(payload.get("message") or f"HTTP {response.status_code}")
    return payload.get("data")

def require_env():
    for name, value in {
        "INNORIX_EMAIL": EMAIL,
        "INNORIX_PASSWORD": PASSWORD,
        "INNORIX_WORKSPACE_ID": WORKSPACE_ID,
    }.items():
        if not value:
            raise RuntimeError(f"Missing required environment variable: {name}")

def main():
    require_env()

    # Log in once; the same token and workspace header are reused for every call.
    login = api("POST", "/api/auth/login", None, {"email": EMAIL, "password": PASSWORD})
    token = login["user"]["accessToken"]

    # Send one file from the source device to the target device.
    transfer = api("POST", "/api/transfers/manual", token, {
        "sourceDevice": SOURCE_DEVICE,
        "targetDevice": TARGET_DEVICE,
        "targetPath": TARGET_PATH,
        "sourcePaths": [SOURCE_PATH],
        "sendAllFolder": False,
    })
    monitor_id = transfer["monitorId"]
    print("transfer created", {
        "monitorId": monitor_id,
        "status": transfer.get("status"),
        "statusName": transfer.get("statusName"),
    })

    # Poll the combined active/history detail endpoint until the transfer reaches a terminal status.
    while True:
        detail = api("GET", f"/api/transfers/{monitor_id}", token)
        is_terminal = detail.get("isTerminal", detail.get("status") in TERMINAL_TRANSFER_STATUSES)
        print({
            "monitorId": monitor_id,
            "status": detail.get("status"),
            "statusName": detail.get("statusName"),
            "isTerminal": is_terminal,
            "percent": detail.get("percent", 0),
        })
        if is_terminal:
            if detail.get("status") != TRANSFER_STATUS["transferComplete"]:
                raise RuntimeError(detail.get("errorCode") or "Transfer failed")
            print("Transfer completed")
            return
        time.sleep(2)

if __name__ == "__main__":
    try:
        main()
    except Exception as error:  # noqa: BLE001 - surface a clean message to the CLI
        print(error, file=sys.stderr)
        sys.exit(1)

"""Example 02 - File collect.

Collect the same source path from several branch devices into one HQ device,
running the transfers in parallel and waiting for all of them to finish.

INNORIX_SOURCE_DEVICE / TARGET_DEVICE (and branch names) accept a device ID,
device name, or IP address.

Required environment variables: INNORIX_EMAIL, INNORIX_PASSWORD, INNORIX_WORKSPACE_ID
See ../.env.example for the full list and defaults.

Run:  python "02-file-collect/example.py"
"""

import os
import sys
import time
from pathlib import Path

import requests
from dotenv import load_dotenv

# Load .env from the example's own folder first (so a single downloaded example works
# with a .env placed next to it), then fall back to the shared python/.env one level up.
# python-dotenv does not overwrite variables that are already set, so the folder-local
# .env wins and the shared one only fills in whatever is missing.
_here = Path(__file__).resolve().parent
load_dotenv(_here / ".env")          # same folder as this script
load_dotenv(_here.parent / ".env")   # shared python/.env (used by the full example set)

BASE_URL = os.getenv("INNORIX_BASE_URL", "https://app.innorix.com")
EMAIL = os.getenv("INNORIX_EMAIL")
PASSWORD = os.getenv("INNORIX_PASSWORD")
WORKSPACE_ID = os.getenv("INNORIX_WORKSPACE_ID")
# Comma-separated list of branch (source) devices to collect from.
BRANCH_DEVICES = [
    name.strip()
    for name in os.getenv("INNORIX_BRANCH_DEVICES", "branch-01,branch-02,branch-03").split(",")
    if name.strip()
]
# Single HQ (target) device that receives everything.
HQ_DEVICE = os.getenv("INNORIX_HQ_DEVICE", "device-target-01")
SOURCE_PATH = os.getenv("INNORIX_SOURCE_PATH", "/var/log")
TARGET_PATH = os.getenv("INNORIX_TARGET_PATH", "/collect/logs")

TRANSFER_STATUS = {
    "transferComplete": 2,
    "transferError": 4,
    "transferCancel": 5,
    "transferPartialComplete": 9,
    "transferFail": 99,
}
TERMINAL_TRANSFER_STATUSES = set(TRANSFER_STATUS.values())

def api(method, path, token=None, body=None):
    headers = {"Content-Type": "application/json"}
    if token:
        headers["Authorization"] = f"Bearer {token}"
        headers["x-workspace-id"] = WORKSPACE_ID
    response = requests.request(method, BASE_URL + path, headers=headers, json=body)
    try:
        payload = response.json()
    except ValueError:
        payload = {}
    if not response.ok:
        raise RuntimeError(payload.get("message") or f"HTTP {response.status_code}")
    return payload.get("data")

def require_env():
    for name, value in {
        "INNORIX_EMAIL": EMAIL,
        "INNORIX_PASSWORD": PASSWORD,
        "INNORIX_WORKSPACE_ID": WORKSPACE_ID,
    }.items():
        if not value:
            raise RuntimeError(f"Missing required environment variable: {name}")

def main():
    require_env()

    login = api("POST", "/api/auth/login", None, {"email": EMAIL, "password": PASSWORD})
    token = login["user"]["accessToken"]

    # Start one collect transfer per branch: branch (source) -> HQ (target).
    pending = {}  # branch_name -> monitor_id
    for branch_name in BRANCH_DEVICES:
        transfer = api("POST", "/api/transfers/manual", token, {
            "sourceDevice": branch_name,
            "targetDevice": HQ_DEVICE,
            "targetPath": TARGET_PATH,
            "sourcePaths": [SOURCE_PATH],
            "sendAllFolder": True,
            "transferOptions": {"target-action": "numbering"},
        })
        print(branch_name, {
            "monitorId": transfer["monitorId"],
            "status": transfer.get("status"),
            "targetPath": TARGET_PATH,
        })
        pending[branch_name] = transfer["monitorId"]

    # Poll every branch transfer until each one reaches a terminal status.
    total = len(pending)
    while pending:
        for branch_name, monitor_id in list(pending.items()):
            detail = api("GET", f"/api/transfers/{monitor_id}", token)
            print(branch_name, {
                "status": detail.get("status"),
                "statusName": detail.get("statusName"),
                "percent": detail.get("percent", 0),
            })
            if detail.get("isTerminal", detail.get("status") in TERMINAL_TRANSFER_STATUSES):
                if detail.get("status") != TRANSFER_STATUS["transferComplete"]:
                    raise RuntimeError(f"{branch_name}: {detail.get('errorCode') or 'failed'}")
                del pending[branch_name]
        if pending:
            time.sleep(2)

    print(f"Collected logs from {total} branches")

if __name__ == "__main__":
    try:
        main()
    except Exception as error:  # noqa: BLE001
        print(error, file=sys.stderr)
        sys.exit(1)

"""Example 03 - File distribution.

Distribute one package from a source device to many target devices in parallel,
then wait for all of them and report which succeeded and which failed.

Targets can be supplied via numbered environment variables:
    INNORIX_TARGET_DEVICE_1 / INNORIX_TARGET_PATH_1, _2, _3, ... (up to 50)
If none are set, the DEFAULT_TARGETS below are used.

Required environment variables: INNORIX_EMAIL, INNORIX_PASSWORD, INNORIX_WORKSPACE_ID
See ../.env.example for the full list and defaults.

Run:  python "03-file-distribution/example.py"
"""

import os
import sys
import time
from pathlib import Path

import requests
from dotenv import load_dotenv

# Load .env from the example's own folder first (so a single downloaded example works
# with a .env placed next to it), then fall back to the shared python/.env one level up.
# python-dotenv does not overwrite variables that are already set, so the folder-local
# .env wins and the shared one only fills in whatever is missing.
_here = Path(__file__).resolve().parent
load_dotenv(_here / ".env")          # same folder as this script
load_dotenv(_here.parent / ".env")   # shared python/.env (used by the full example set)

BASE_URL = os.getenv("INNORIX_BASE_URL", "https://app.innorix.com")
EMAIL = os.getenv("INNORIX_EMAIL")
PASSWORD = os.getenv("INNORIX_PASSWORD")
WORKSPACE_ID = os.getenv("INNORIX_WORKSPACE_ID")
# INNORIX_SOURCE_DEVICE accepts a device ID, device name, or IP address.
SOURCE_DEVICE = os.getenv("INNORIX_SOURCE_DEVICE", "device-source-01")
SOURCE_ROOT = os.getenv("INNORIX_SOURCE_ROOT", "/deploy")
PACKAGE_NAME = os.getenv("INNORIX_PACKAGE_NAME", "deployment-package")

TRANSFER_STATUS = {
    "transferComplete": 2,
    "transferError": 4,
    "transferCancel": 5,
    "transferPartialComplete": 9,
    "transferFail": 99,
}
TERMINAL_TRANSFER_STATUSES = set(TRANSFER_STATUS.values())

# Used only when no INNORIX_TARGET_DEVICE_N variables are configured.
DEFAULT_TARGETS = [
    {"device": "branch-01", "path": "/deploy/branch-01"},
    {"device": "branch-02", "path": "/deploy/branch-02"},
    {"device": "branch-03", "path": "/deploy/branch-03"},
    {"device": "branch-04", "path": "/deploy/branch-04"},
    {"device": "branch-05", "path": "/deploy/branch-05"},
]

def join_path(root, name):
    normalized_root = str(root or "").replace("\\", "/").rstrip("/")
    normalized_name = str(name or "").replace("\\", "/").lstrip("/")
    if not normalized_root:
        return normalized_name or "/"
    if not normalized_name:
        return normalized_root
    return f"{normalized_root}/{normalized_name}"

SOURCE_PATH = os.getenv("INNORIX_SOURCE_PATH") or join_path(SOURCE_ROOT, PACKAGE_NAME)

def api(method, path, token=None, body=None):
    headers = {"Content-Type": "application/json"}
    if token:
        headers["Authorization"] = f"Bearer {token}"
        headers["x-workspace-id"] = WORKSPACE_ID
    response = requests.request(method, BASE_URL + path, headers=headers, json=body)
    try:
        payload = response.json()
    except ValueError:
        payload = {}
    if not response.ok:
        raise RuntimeError(payload.get("message") or f"HTTP {response.status_code}")
    return payload.get("data")

def require_env():
    for name, value in {
        "INNORIX_EMAIL": EMAIL,
        "INNORIX_PASSWORD": PASSWORD,
        "INNORIX_WORKSPACE_ID": WORKSPACE_ID,
    }.items():
        if not value:
            raise RuntimeError(f"Missing required environment variable: {name}")

def distribution_targets():
    """Read INNORIX_TARGET_DEVICE_N / INNORIX_TARGET_PATH_N pairs, or fall back to DEFAULT_TARGETS."""
    targets = []
    for index in range(1, 51):
        device = os.getenv(f"INNORIX_TARGET_DEVICE_{index}")
        path = os.getenv(f"INNORIX_TARGET_PATH_{index}")
        if not device and not path:
            continue
        if not device or not path:
            raise RuntimeError(
                f"INNORIX_TARGET_DEVICE_{index} and INNORIX_TARGET_PATH_{index} must be set together"
            )
        targets.append({"device": device.strip(), "path": path.replace("\\", "/")})
    return targets if targets else DEFAULT_TARGETS

def main():
    require_env()

    login = api("POST", "/api/auth/login", None, {"email": EMAIL, "password": PASSWORD})
    token = login["user"]["accessToken"]

    # Start one transfer per target, reusing the same source package path.
    pending = {}  # target_device -> monitor_id
    for target in distribution_targets():
        transfer = api("POST", "/api/transfers/manual", token, {
            "sourceDevice": SOURCE_DEVICE,
            "targetDevice": target["device"],
            "targetPath": target["path"],
            "sourcePaths": [SOURCE_PATH],
            "sendAllFolder": True,
            "transferOptions": {"target-action": "overwrite"},
        })
        print(target["device"], {
            "monitorId": transfer["monitorId"],
            "status": transfer.get("status"),
            "targetPath": target["path"],
        })
        pending[target["device"]] = transfer["monitorId"]

    # Poll every pending transfer until each one reaches a terminal status.
    results = {}  # target_device -> "success" | error_code
    while pending:
        for target_name, monitor_id in list(pending.items()):
            detail = api("GET", f"/api/transfers/{monitor_id}", token)
            print(target_name, {
                "status": detail.get("status"),
                "statusName": detail.get("statusName"),
                "percent": detail.get("percent", 0),
            })
            if detail.get("isTerminal", detail.get("status") in TERMINAL_TRANSFER_STATUSES):
                results[target_name] = (
                    "success"
                    if detail.get("status") == TRANSFER_STATUS["transferComplete"]
                    else (detail.get("errorCode") or "failed")
                )
                del pending[target_name]
        if pending:
            time.sleep(2)

    # Split the outcome into succeeded devices and failed devices with their reasons.
    succeeded = [name for name, value in results.items() if value == "success"]
    failed = {name: value for name, value in results.items() if value != "success"}
    print({"succeeded": succeeded, "failed": failed})

if __name__ == "__main__":
    try:
        main()
    except Exception as error:  # noqa: BLE001
        print(error, file=sys.stderr)
        sys.exit(1)

"""Example 04 - Transfer rules.

Validate the source/target paths first, then start a manual transfer and wait for it to finish.

Required environment variables: INNORIX_EMAIL, INNORIX_PASSWORD, INNORIX_WORKSPACE_ID
See ../.env.example for the full list and defaults.

Run:  python "04-transfer-rules/example.py"
"""

import os
import sys
import time
from pathlib import Path

import requests
from dotenv import load_dotenv

# Load .env from the example's own folder first (so a single downloaded example works
# with a .env placed next to it), then fall back to the shared python/.env one level up.
# python-dotenv does not overwrite variables that are already set, so the folder-local
# .env wins and the shared one only fills in whatever is missing.
_here = Path(__file__).resolve().parent
load_dotenv(_here / ".env")          # same folder as this script
load_dotenv(_here.parent / ".env")   # shared python/.env (used by the full example set)

BASE_URL = os.getenv("INNORIX_BASE_URL", "https://app.innorix.com")
EMAIL = os.getenv("INNORIX_EMAIL")
PASSWORD = os.getenv("INNORIX_PASSWORD")
WORKSPACE_ID = os.getenv("INNORIX_WORKSPACE_ID")
# INNORIX_SOURCE_DEVICE / TARGET_DEVICE accept a device ID, device name, or IP address.
SOURCE_DEVICE = os.getenv("INNORIX_SOURCE_DEVICE", "device-source-01")
TARGET_DEVICE = os.getenv("INNORIX_TARGET_DEVICE", "device-target-01")
SOURCE_PATH = os.getenv("INNORIX_SOURCE_PATH", "/data/report.pdf").replace("\\", "/")
TARGET_PATH = os.getenv("INNORIX_TARGET_PATH", "/data/incoming")

TRANSFER_STATUS = {
    "transferComplete": 2,
    "transferError": 4,
    "transferCancel": 5,
    "transferPartialComplete": 9,
    "transferFail": 99,
}
TERMINAL_TRANSFER_STATUSES = set(TRANSFER_STATUS.values())

def api(method, path, token=None, body=None):
    headers = {"Content-Type": "application/json"}
    if token:
        headers["Authorization"] = f"Bearer {token}"
        headers["x-workspace-id"] = WORKSPACE_ID
    response = requests.request(method, BASE_URL + path, headers=headers, json=body)
    try:
        payload = response.json()
    except ValueError:
        payload = {}
    if not response.ok:
        raise RuntimeError(payload.get("message") or f"HTTP {response.status_code}")
    return payload.get("data")

def require_env():
    for name, value in {
        "INNORIX_EMAIL": EMAIL,
        "INNORIX_PASSWORD": PASSWORD,
        "INNORIX_WORKSPACE_ID": WORKSPACE_ID,
    }.items():
        if not value:
            raise RuntimeError(f"Missing required environment variable: {name}")

def wait_for_completion(monitor_id, token):
    while True:
        detail = api("GET", f"/api/transfers/{monitor_id}", token)
        is_terminal = detail.get("isTerminal", detail.get("status") in TERMINAL_TRANSFER_STATUSES)
        print({
            "monitorId": monitor_id,
            "status": detail.get("status"),
            "statusName": detail.get("statusName"),
            "isTerminal": is_terminal,
            "percent": detail.get("percent", 0),
        })
        if is_terminal:
            if detail.get("status") != TRANSFER_STATUS["transferComplete"]:
                raise RuntimeError(detail.get("errorCode") or "Transfer failed")
            return detail
        time.sleep(2)

def main():
    require_env()

    login = api("POST", "/api/auth/login", None, {"email": EMAIL, "password": PASSWORD})
    token = login["user"]["accessToken"]

    request = {
        "sourceDevice": SOURCE_DEVICE,
        "targetDevice": TARGET_DEVICE,
        "targetPath": TARGET_PATH,
        "sourcePaths": [SOURCE_PATH],
        "sendAllFolder": False,
    }

    # 1) Validate the transfer request before running it (checks devices and paths).
    validation = api("POST", "/api/transfers/validate-path", token, request)
    print("validate-path", validation)

    # 2) Start the manual transfer using the same request.
    transfer = api("POST", "/api/transfers/manual", token, request)
    print("transfer created", {"monitorId": transfer["monitorId"], "status": transfer.get("status")})

    # 3) Wait until the transfer reaches a terminal status.
    wait_for_completion(transfer["monitorId"], token)
    print("Transfer completed")

if __name__ == "__main__":
    try:
        main()
    except Exception as error:  # noqa: BLE001
        print(error, file=sys.stderr)
        sys.exit(1)

"""Example 05 - Conflict handling.

Send the same file to the same location under each conflict policy and compare the
file-level results.

Required environment variables: INNORIX_EMAIL, INNORIX_PASSWORD, INNORIX_WORKSPACE_ID
See ../.env.example for the full list and defaults.

Run:  python "05-conflict-handling/example.py"
"""

import os
import sys
import time
from pathlib import Path

import requests
from dotenv import load_dotenv

# Load .env from the example's own folder first (so a single downloaded example works
# with a .env placed next to it), then fall back to the shared python/.env one level up.
# python-dotenv does not overwrite variables that are already set, so the folder-local
# .env wins and the shared one only fills in whatever is missing.
_here = Path(__file__).resolve().parent
load_dotenv(_here / ".env")          # same folder as this script
load_dotenv(_here.parent / ".env")   # shared python/.env (used by the full example set)

BASE_URL = os.getenv("INNORIX_BASE_URL", "https://app.innorix.com")
EMAIL = os.getenv("INNORIX_EMAIL")
PASSWORD = os.getenv("INNORIX_PASSWORD")
WORKSPACE_ID = os.getenv("INNORIX_WORKSPACE_ID")
# INNORIX_SOURCE_DEVICE / TARGET_DEVICE accept a device ID, device name, or IP address.
SOURCE_DEVICE = os.getenv("INNORIX_SOURCE_DEVICE", "device-source-01")
TARGET_DEVICE = os.getenv("INNORIX_TARGET_DEVICE", "device-target-01")
SOURCE_PATH = os.getenv("INNORIX_SOURCE_PATH", "/data/report.pdf")
TARGET_PATH = os.getenv("INNORIX_TARGET_PATH", "/data/incoming")

# Conflict policies to compare: add a number suffix, skip, or overwrite on conflict.
CONFLICT_POLICIES = ["numbering", "nosend", "overwrite"]

TRANSFER_STATUS = {
    "transferComplete": 2,
    "transferError": 4,
    "transferCancel": 5,
    "transferPartialComplete": 9,
    "transferFail": 99,
}
TERMINAL_TRANSFER_STATUSES = set(TRANSFER_STATUS.values())

def api(method, path, token=None, body=None):
    headers = {"Content-Type": "application/json"}
    if token:
        headers["Authorization"] = f"Bearer {token}"
        headers["x-workspace-id"] = WORKSPACE_ID
    response = requests.request(method, BASE_URL + path, headers=headers, json=body)
    try:
        payload = response.json()
    except ValueError:
        payload = {}
    if not response.ok:
        raise RuntimeError(payload.get("message") or f"HTTP {response.status_code}")
    return payload.get("data")

def require_env():
    for name, value in {
        "INNORIX_EMAIL": EMAIL,
        "INNORIX_PASSWORD": PASSWORD,
        "INNORIX_WORKSPACE_ID": WORKSPACE_ID,
    }.items():
        if not value:
            raise RuntimeError(f"Missing required environment variable: {name}")

def wait_for_terminal(monitor_id, token):
    """The 'nosend'/'fail' policies may end without success, so wait for any terminal status."""
    while True:
        detail = api("GET", f"/api/transfers/{monitor_id}", token)
        if detail.get("isTerminal", detail.get("status") in TERMINAL_TRANSFER_STATUSES):
            return detail
        time.sleep(2)

def main():
    require_env()

    login = api("POST", "/api/auth/login", None, {"email": EMAIL, "password": PASSWORD})
    token = login["user"]["accessToken"]

    for policy in CONFLICT_POLICIES:
        # Same file, same destination - only the conflict policy changes.
        transfer = api("POST", "/api/transfers/manual", token, {
            "sourceDevice": SOURCE_DEVICE,
            "targetDevice": TARGET_DEVICE,
            "targetPath": TARGET_PATH,
            "sourcePaths": [SOURCE_PATH],
            "sendAllFolder": False,
            "transferOptions": {"target-action": policy},
        })
        detail = wait_for_terminal(transfer["monitorId"], token)

        # Inspect the per-file result for this policy. The /files response returns the rows
        # under `children`, and each row names the file/state as sourceFileName / statusName.
        files = api("GET", f"/api/transfers/{transfer['monitorId']}/files?state=any&size=100", token)
        rows = (files or {}).get("children") or (files or {}).get("items") or []
        print(
            f"policy={policy} status={detail.get('status')}",
            [
                {
                    "name": f.get("sourceFileName") or f.get("targetFileName") or f.get("sourceFilePath"),
                    "state": f.get("statusName") or f.get("status"),
                }
                for f in rows
            ],
        )

if __name__ == "__main__":
    try:
        main()
    except Exception as error:  # noqa: BLE001
        print(error, file=sys.stderr)
        sys.exit(1)

"""Example 06 - Recurring automation.

Full lifecycle of a scheduled automation: create, read, update the schedule,
list past executions, pause, then delete.

INNORIX_SOURCE_ID / TARGET_ID must be the exact device IDs - they are encoded into the
path token, so a device name will not work here (unlike the manual-transfer examples).

Required environment variables: INNORIX_EMAIL, INNORIX_PASSWORD, INNORIX_WORKSPACE_ID
See ../.env.example for the full list and defaults.

Run:  python "06-Recurring Automation/example.py"
"""

import base64
import os
import sys
from datetime import datetime, timezone
from pathlib import Path

import requests
from dotenv import load_dotenv

# Load .env from the example's own folder first (so a single downloaded example works
# with a .env placed next to it), then fall back to the shared python/.env one level up.
# python-dotenv does not overwrite variables that are already set, so the folder-local
# .env wins and the shared one only fills in whatever is missing.
_here = Path(__file__).resolve().parent
load_dotenv(_here / ".env")          # same folder as this script
load_dotenv(_here.parent / ".env")   # shared python/.env (used by the full example set)

BASE_URL = os.getenv("INNORIX_BASE_URL", "https://app.innorix.com")
EMAIL = os.getenv("INNORIX_EMAIL")
PASSWORD = os.getenv("INNORIX_PASSWORD")
WORKSPACE_ID = os.getenv("INNORIX_WORKSPACE_ID")
SOURCE_ID = os.getenv("INNORIX_SOURCE_ID", "device-source-01")
TARGET_ID = os.getenv("INNORIX_TARGET_ID", "device-target-01")
SOURCE_PATH = os.getenv("INNORIX_SOURCE_PATH", "/data/report.pdf").replace("\\", "/")
TARGET_PATH = os.getenv("INNORIX_TARGET_PATH", "/data/incoming")
TIMEZONE = os.getenv("INNORIX_TIMEZONE", "UTC")

def api(method, path, token=None, body=None):
    headers = {"Content-Type": "application/json"}
    if token:
        headers["Authorization"] = f"Bearer {token}"
        headers["x-workspace-id"] = WORKSPACE_ID
    response = requests.request(method, BASE_URL + path, headers=headers, json=body)
    try:
        payload = response.json()
    except ValueError:
        payload = {}
    if not response.ok:
        raise RuntimeError(payload.get("message") or f"HTTP {response.status_code}")
    return payload.get("data")

def require_env():
    for name, value in {
        "INNORIX_EMAIL": EMAIL,
        "INNORIX_PASSWORD": PASSWORD,
        "INNORIX_WORKSPACE_ID": WORKSPACE_ID,
    }.items():
        if not value:
            raise RuntimeError(f"Missing required environment variable: {name}")

def encode_path(device_id, raw_path):
    """Build the `<deviceId>_ino_<base64(path)>` token used by the automation API."""
    normalized = str(raw_path or "").replace("\\", "/")
    token = base64.b64encode(normalized.encode("utf-8")).decode("ascii")
    return f"{device_id}_ino_{token}"

def now_iso():
    """UTC timestamp in the same ISO 8601 format Node's Date#toISOString() produces."""
    return datetime.now(timezone.utc).strftime("%Y-%m-%dT%H:%M:%S.%f")[:-3] + "Z"

def main():
    require_env()

    login = api("POST", "/api/auth/login", None, {"email": EMAIL, "password": PASSWORD})
    token = login["user"]["accessToken"]

    # Schedule: run every day at 02:00 AM to send the previous day's settlement file.
    schedule = {
        "type": "day",
        "startDateType": "now",
        "hour": "02",
        "minute": "00",
        "ampm": "am",
        "startDate": now_iso(),
        "timezone": TIMEZONE,
    }

    # 1) Create the automation.
    created = api("POST", "/api/automations", token, {
        "name": "Daily Settlement Transfer",
        "details": [
            {
                "sourceItem": [{"hash": encode_path(SOURCE_ID, SOURCE_PATH), "isDir": False}],
                "targetPath": TARGET_PATH,
                "senderId": SOURCE_ID,
                "receiverId": TARGET_ID,
                "step": 1,
                "transferOptions": {
                    "noSchedule": False,
                    "target-action": "numbering",
                    "send-fileoption": {},
                },
            }
        ],
        "transferType": "normal",
        "timezone": TIMEZONE,
        "schedules": [schedule],
    })
    automation_id = created["automationId"]
    print("automation created", automation_id)

    # 2) Read the automation.
    print("detail", api("GET", f"/api/automations/{automation_id}", token))

    # 3) Update the schedule.
    api("PATCH", f"/api/automations/{automation_id}", token, {
        "name": "Daily Settlement Transfer",
        "isUpdateSchedule": True,
        "schedules": [schedule],
    })

    # 4) List past executions.
    print("executions", api("GET", f"/api/automations/{automation_id}/executions", token))

    # 5) Pause the automation.
    api("POST", f"/api/automations/{automation_id}/pause", token, {"pause": True})

    # 6) Delete the automation (example cleanup).
    api("DELETE", f"/api/automations/{automation_id}", token)
    print("automation deleted", automation_id)

if __name__ == "__main__":
    try:
        main()
    except Exception as error:  # noqa: BLE001
        print(error, file=sys.stderr)
        sys.exit(1)

"""Example 07 - Webhook.

Create an automation that fires a webhook when it runs. The webhook is defined as a
processor on the automation (events: "Run"), so the server calls your URL on execution.

INNORIX_SOURCE_ID / TARGET_ID must be the exact device IDs - they are encoded into the
path token, so a device name will not work here (unlike the manual-transfer examples).

Required environment variables: INNORIX_EMAIL, INNORIX_PASSWORD, INNORIX_WORKSPACE_ID
See ../.env.example for the full list and defaults.

Run:  python "07-Webhook/example.py"
"""

import base64
import os
import sys
from datetime import datetime, timezone
from pathlib import Path

import requests
from dotenv import load_dotenv

# Load .env from the example's own folder first (so a single downloaded example works
# with a .env placed next to it), then fall back to the shared python/.env one level up.
# python-dotenv does not overwrite variables that are already set, so the folder-local
# .env wins and the shared one only fills in whatever is missing.
_here = Path(__file__).resolve().parent
load_dotenv(_here / ".env")          # same folder as this script
load_dotenv(_here.parent / ".env")   # shared python/.env (used by the full example set)

BASE_URL = os.getenv("INNORIX_BASE_URL", "https://app.innorix.com")
EMAIL = os.getenv("INNORIX_EMAIL")
PASSWORD = os.getenv("INNORIX_PASSWORD")
WORKSPACE_ID = os.getenv("INNORIX_WORKSPACE_ID")
SOURCE_ID = os.getenv("INNORIX_SOURCE_ID", "device-source-01")
TARGET_ID = os.getenv("INNORIX_TARGET_ID", "device-target-01")
SOURCE_PATH = os.getenv("INNORIX_SOURCE_PATH", "/data/report.pdf").replace("\\", "/")
TARGET_PATH = os.getenv("INNORIX_TARGET_PATH", "/data/incoming")
TIMEZONE = os.getenv("INNORIX_TIMEZONE", "UTC")
# Webhook processor settings.
WEBHOOK_TYPE = os.getenv("INNORIX_WEBHOOK_TYPE", "https")
WEBHOOK_URL = os.getenv("INNORIX_WEBHOOK_URL", "https://example.com/webhook")
WEBHOOK_METHOD = os.getenv("INNORIX_WEBHOOK_METHOD", "POST")
WEBHOOK_BODY = os.getenv("INNORIX_WEBHOOK_BODY", "")

def api(method, path, token=None, body=None):
    headers = {"Content-Type": "application/json"}
    if token:
        headers["Authorization"] = f"Bearer {token}"
        headers["x-workspace-id"] = WORKSPACE_ID
    response = requests.request(method, BASE_URL + path, headers=headers, json=body)
    try:
        payload = response.json()
    except ValueError:
        payload = {}
    if not response.ok:
        raise RuntimeError(payload.get("message") or f"HTTP {response.status_code}")
    return payload.get("data")

def require_env():
    for name, value in {
        "INNORIX_EMAIL": EMAIL,
        "INNORIX_PASSWORD": PASSWORD,
        "INNORIX_WORKSPACE_ID": WORKSPACE_ID,
    }.items():
        if not value:
            raise RuntimeError(f"Missing required environment variable: {name}")

def encode_path(device_id, raw_path):
    """Build the `<deviceId>_ino_<base64(path)>` token used by the automation API."""
    normalized = str(raw_path or "").replace("\\", "/")
    token = base64.b64encode(normalized.encode("utf-8")).decode("ascii")
    return f"{device_id}_ino_{token}"

def now_iso():
    return datetime.now(timezone.utc).strftime("%Y-%m-%dT%H:%M:%S.%f")[:-3] + "Z"

def main():
    require_env()

    login = api("POST", "/api/auth/login", None, {"email": EMAIL, "password": PASSWORD})
    token = login["user"]["accessToken"]

    # Create an automation with a webhook processor that fires on run.
    automation = api("POST", "/api/automations", token, {
        "name": "Webhook Automation",
        "flowName": "Webhook Automation",
        "details": [
            {
                "sourceItem": [{"hash": encode_path(SOURCE_ID, SOURCE_PATH), "isDir": False}],
                "targetPath": TARGET_PATH,
                "senderId": SOURCE_ID,
                "receiverId": TARGET_ID,
                "step": 1,
                "transferOptions": {
                    "noSchedule": False,
                    "target-action": "numbering",
                    "send-fileoption": {},
                },
            }
        ],
        "transferType": "normal",
        "isUpcoming": False,
        "timezone": TIMEZONE,
        "schedules": [
            {
                "type": "none",
                "startDateType": "now",
                "hour": "00",
                "minute": "00",
                "ampm": "am",
                "startDate": now_iso(),
                "timezone": TIMEZONE,
            }
        ],
        # Webhook: the server calls this URL when the automation runs.
        "processors": [
            {
                "events": "Run",
                "type": WEBHOOK_TYPE,
                "method": WEBHOOK_METHOD,
                "url": WEBHOOK_URL,
                "body": WEBHOOK_BODY,
            }
        ],
    })
    automation_id = automation["automationId"]
    print("automation created", automation_id)

    # Read the automation details, including the configured webhook processor.
    print("details", api("GET", f"/api/automations/{automation_id}/details", token))

if __name__ == "__main__":
    try:
        main()
    except Exception as error:  # noqa: BLE001
        print(error, file=sys.stderr)
        sys.exit(1)

"""Example 08 - Workflow (A -> B -> C chain).

Define a relayed transfer as two automations sharing one flowId: A -> B, then B -> C.
Both are marked isUpcoming; B -> C is chained to A -> B via `triggerAutomation`, so the
server runs it automatically once A -> B completes (the client does not orchestrate the
hand-off).

INNORIX_SOURCE_ID / MIDDLE_ID / TARGET_ID must be the exact device IDs - they are encoded
into the path token, so a device name will not work here.

Required environment variables: INNORIX_EMAIL, INNORIX_PASSWORD, INNORIX_WORKSPACE_ID
See ../.env.example for the full list and defaults.

Run:  python "08-Workflow/example.py"
"""

import base64
import os
import random
import sys
import time
from datetime import datetime, timezone
from pathlib import Path

import requests
from dotenv import load_dotenv

# Load .env from the example's own folder first (so a single downloaded example works
# with a .env placed next to it), then fall back to the shared python/.env one level up.
# python-dotenv does not overwrite variables that are already set, so the folder-local
# .env wins and the shared one only fills in whatever is missing.
_here = Path(__file__).resolve().parent
load_dotenv(_here / ".env")          # same folder as this script
load_dotenv(_here.parent / ".env")   # shared python/.env (used by the full example set)

BASE_URL = os.getenv("INNORIX_BASE_URL", "https://app.innorix.com")
EMAIL = os.getenv("INNORIX_EMAIL")
PASSWORD = os.getenv("INNORIX_PASSWORD")
WORKSPACE_ID = os.getenv("INNORIX_WORKSPACE_ID")
# A -> B -> C: source -> middle (relay) -> target.
SOURCE_ID = os.getenv("INNORIX_SOURCE_ID", "device-source-01")
MIDDLE_ID = os.getenv("INNORIX_MIDDLE_ID", "device-middle-01")
TARGET_ID = os.getenv("INNORIX_TARGET_ID", "device-target-01")
SOURCE_PATH = os.getenv("INNORIX_SOURCE_PATH", "/data/report.pdf").replace("\\", "/")
MIDDLE_PATH = os.getenv("INNORIX_MIDDLE_PATH", SOURCE_PATH).replace("\\", "/")
TARGET_PATH = os.getenv("INNORIX_TARGET_PATH", "/data/incoming")
TIMEZONE = os.getenv("INNORIX_TIMEZONE", "UTC")

def api(method, path, token=None, body=None):
    headers = {"Content-Type": "application/json"}
    if token:
        headers["Authorization"] = f"Bearer {token}"
        headers["x-workspace-id"] = WORKSPACE_ID
    response = requests.request(method, BASE_URL + path, headers=headers, json=body)
    try:
        payload = response.json()
    except ValueError:
        payload = {}
    if not response.ok:
        raise RuntimeError(payload.get("message") or f"HTTP {response.status_code}")
    return payload.get("data")

def require_env():
    for name, value in {
        "INNORIX_EMAIL": EMAIL,
        "INNORIX_PASSWORD": PASSWORD,
        "INNORIX_WORKSPACE_ID": WORKSPACE_ID,
    }.items():
        if not value:
            raise RuntimeError(f"Missing required environment variable: {name}")

def encode_path(device_id, raw_path):
    """Build the `<deviceId>_ino_<base64(path)>` token used by the automation API."""
    normalized = str(raw_path or "").replace("\\", "/")
    token = base64.b64encode(normalized.encode("utf-8")).decode("ascii")
    return f"{device_id}_ino_{token}"

def now_iso():
    return datetime.now(timezone.utc).strftime("%Y-%m-%dT%H:%M:%S.%f")[:-3] + "Z"

def generate_transfer_id():
    """Generate a transfer id like 'T1234-5678-9012' from time, pid, and randomness."""
    ts = str(int(time.time() * 1000))
    pid = f"{os.getpid() % 1000:03d}"
    rand = f"{random.randint(0, 999):03d}"
    raw = (ts + pid + rand)[-12:]
    return f"T{raw[0:4]}-{raw[4:8]}-{raw[8:12]}"

def generate_flow_id():
    """Flow id derived from a transfer id, e.g. 'F-1234-5678-9012'."""
    return f"F-{generate_transfer_id()[1:]}"

def build_automation(name, flow_name, sender_id, sender_path, receiver_id, flow_id,
                     trigger_automation_id=None):
    """Build one automation body for a single hop (sender -> receiver).

    Pass trigger_automation_id to chain this automation after another one completes.
    """
    schedule = {
        "type": "none",
        "startDateType": "now",
        "hour": "00",
        "minute": "00",
        "ampm": "am",
        "startDate": now_iso(),
        "timezone": TIMEZONE,
    }
    if trigger_automation_id:
        schedule["triggerAutomation"] = {"value": trigger_automation_id}

    return {
        "name": name,
        "flowName": flow_name,
        "details": [
            {
                "sourceItem": [{"hash": encode_path(sender_id, sender_path), "isDir": False}],
                "targetPath": TARGET_PATH,
                "senderId": sender_id,
                "receiverId": receiver_id,
                "step": 1,
                "transferOptions": {
                    "noSchedule": False,
                    "target-action": "numbering",
                    "send-fileoption": {},
                },
            }
        ],
        "transferType": "normal",
        "isUpcoming": True,
        "timezone": TIMEZONE,
        "schedules": [schedule],
        "flowId": flow_id,
    }

def main():
    require_env()

    login = api("POST", "/api/auth/login", None, {"email": EMAIL, "password": PASSWORD})
    token = login["user"]["accessToken"]

    # Both hops share one flowId so they belong to the same workflow.
    flow_id = generate_flow_id()

    # 1) A -> B.
    transfer_ab = api("POST", "/api/automations", token, build_automation(
        name="A to B Workflow",
        flow_name="A-B Workflow",
        sender_id=SOURCE_ID,
        sender_path=SOURCE_PATH,
        receiver_id=MIDDLE_ID,
        flow_id=flow_id,
    ))
    automation_id = transfer_ab["automationId"]
    print("A->B automation created", automation_id)

    # 2) B -> C, triggered automatically after the A -> B automation completes.
    transfer_bc = api("POST", "/api/automations", token, build_automation(
        name="B to C Workflow",
        flow_name="B-C Workflow",
        sender_id=MIDDLE_ID,
        sender_path=MIDDLE_PATH,
        receiver_id=TARGET_ID,
        flow_id=flow_id,
        trigger_automation_id=automation_id,
    ))
    print("B->C automation created", transfer_bc["automationId"])

    # 3) Inspect the per-step definition and execution history of the A -> B automation.
    print("details", api("GET", f"/api/automations/{automation_id}/details", token))
    print("executions", api("GET", f"/api/automations/{automation_id}/executions", token))

if __name__ == "__main__":
    try:
        main()
    except Exception as error:  # noqa: BLE001
        print(error, file=sys.stderr)
        sys.exit(1)

"""Example 09 - Source filter.

Create an automation that transfers only files matching a filter (e.g. *.log / *.csv),
while excluding others (e.g. *.tmp) and applying size rules.

INNORIX_SOURCE_ID / TARGET_ID must be the exact device IDs - they are encoded into the
path token, so a device name will not work here (unlike the manual-transfer examples).

Required environment variables: INNORIX_EMAIL, INNORIX_PASSWORD, INNORIX_WORKSPACE_ID
See ../.env.example for the full list and defaults.

Run:  python "09-source-filter/example.py"
"""

import base64
import os
import sys
from datetime import datetime, timezone
from pathlib import Path

import requests
from dotenv import load_dotenv

# Load .env from the example's own folder first (so a single downloaded example works
# with a .env placed next to it), then fall back to the shared python/.env one level up.
# python-dotenv does not overwrite variables that are already set, so the folder-local
# .env wins and the shared one only fills in whatever is missing.
_here = Path(__file__).resolve().parent
load_dotenv(_here / ".env")          # same folder as this script
load_dotenv(_here.parent / ".env")   # shared python/.env (used by the full example set)

BASE_URL = os.getenv("INNORIX_BASE_URL", "https://app.innorix.com")
EMAIL = os.getenv("INNORIX_EMAIL")
PASSWORD = os.getenv("INNORIX_PASSWORD")
WORKSPACE_ID = os.getenv("INNORIX_WORKSPACE_ID")
SOURCE_ID = os.getenv("INNORIX_SOURCE_ID", "device-source-01")
TARGET_ID = os.getenv("INNORIX_TARGET_ID", "device-target-01")
SOURCE_PATH = os.getenv("INNORIX_SOURCE_PATH", "/var/log").replace("\\", "/")
TARGET_PATH = os.getenv("INNORIX_TARGET_PATH", "/collect/logs").replace("\\", "/")
TIMEZONE = os.getenv("INNORIX_TIMEZONE", "UTC")

def api(method, path, token=None, body=None):
    headers = {"Content-Type": "application/json"}
    if token:
        headers["Authorization"] = f"Bearer {token}"
        headers["x-workspace-id"] = WORKSPACE_ID
    response = requests.request(method, BASE_URL + path, headers=headers, json=body)
    try:
        payload = response.json()
    except ValueError:
        payload = {}
    if not response.ok:
        raise RuntimeError(payload.get("message") or f"HTTP {response.status_code}")
    return payload.get("data")

def require_env():
    for name, value in {
        "INNORIX_EMAIL": EMAIL,
        "INNORIX_PASSWORD": PASSWORD,
        "INNORIX_WORKSPACE_ID": WORKSPACE_ID,
    }.items():
        if not value:
            raise RuntimeError(f"Missing required environment variable: {name}")

def encode_path(device_id, raw_path):
    """Build the `<deviceId>_ino_<base64(path)>` token used by the automation API."""
    normalized = str(raw_path or "").replace("\\", "/")
    token = base64.b64encode(normalized.encode("utf-8")).decode("ascii")
    return f"{device_id}_ino_{token}"

def now_iso():
    return datetime.now(timezone.utc).strftime("%Y-%m-%dT%H:%M:%S.%f")[:-3] + "Z"

def main():
    require_env()

    login = api("POST", "/api/auth/login", None, {"email": EMAIL, "password": PASSWORD})
    token = login["user"]["accessToken"]

    automation = api("POST", "/api/automations", token, {
        "name": "Source Filter Transfer",
        "flowName": "Source Filter Transfer",
        "details": [
            {
                "sourceItem": [{"hash": encode_path(SOURCE_ID, SOURCE_PATH), "isDir": True}],
                "targetPath": encode_path(TARGET_ID, TARGET_PATH),
                "senderId": SOURCE_ID,
                "receiverId": TARGET_ID,
                "step": 1,
                "transferOptions": {
                    "noSchedule": True,
                    "send-filetype-cus": r"\.(log|csv)$",  # include only .log and .csv files
                    "savepath": True,
                    "optionPath": "relative",  # keep the folder structure under the target path
                    "target-action": "numbering",  # on conflict, append a number
                    "send-fileoption": {
                        # only files >= 1024 bytes
                        "fileSize": {"size": 1024, "over": True, "equal": True},
                        # exclude *.tmp
                        "fileName": {"name": "*.tmp", "allow": False, "isMatchCase": False},
                    },
                },
            }
        ],
        "transferType": "no_schedule",
        "timezone": TIMEZONE,
        "callbackURL": "",
        "schedules": [
            {
                "type": "none",
                "startDateType": "now",
                "hour": "05",
                "minute": "00",
                "ampm": "pm",
                "startDate": now_iso(),
                "timezone": TIMEZONE,
            }
        ],
    })

    print("automation created", {
        "automationId": automation.get("automationId"),
        "flowName": automation.get("flowName") or automation.get("automationName"),
    })

if __name__ == "__main__":
    try:
        main()
    except Exception as error:  # noqa: BLE001
        print(error, file=sys.stderr)
        sys.exit(1)

"""Example 10 - Target options.

Create an automation that controls how files land on the target: a fixed save path,
conflict numbering, and how much of the source path structure to keep.

INNORIX_SOURCE_ID / TARGET_ID must be the exact device IDs - they are encoded into the
path token, so a device name will not work here (unlike the manual-transfer examples).

Required environment variables: INNORIX_EMAIL, INNORIX_PASSWORD, INNORIX_WORKSPACE_ID
See ../.env.example for the full list and defaults.

Run:  python "10-target-options/example.py"
"""

import base64
import os
import sys
from datetime import datetime, timezone
from pathlib import Path

import requests
from dotenv import load_dotenv

# Load .env from the example's own folder first (so a single downloaded example works
# with a .env placed next to it), then fall back to the shared python/.env one level up.
# python-dotenv does not overwrite variables that are already set, so the folder-local
# .env wins and the shared one only fills in whatever is missing.
_here = Path(__file__).resolve().parent
load_dotenv(_here / ".env")          # same folder as this script
load_dotenv(_here.parent / ".env")   # shared python/.env (used by the full example set)

BASE_URL = os.getenv("INNORIX_BASE_URL", "https://app.innorix.com")
EMAIL = os.getenv("INNORIX_EMAIL")
PASSWORD = os.getenv("INNORIX_PASSWORD")
WORKSPACE_ID = os.getenv("INNORIX_WORKSPACE_ID")
SOURCE_ID = os.getenv("INNORIX_SOURCE_ID", "device-source-01")
TARGET_ID = os.getenv("INNORIX_TARGET_ID", "device-target-01")
SOURCE_PATH = os.getenv("INNORIX_SOURCE_PATH", "/var/log").replace("\\", "/")
TARGET_PATH = os.getenv("INNORIX_TARGET_PATH", "/collect/logs").replace("\\", "/")
# Relative subfolder created under the target path (not a full path), e.g. "/incoming/2026/08".
SAVE_PATH = os.getenv("INNORIX_SAVE_PATH", "/incoming/2026/08")
TIMEZONE = os.getenv("INNORIX_TIMEZONE", "UTC")

def api(method, path, token=None, body=None):
    headers = {"Content-Type": "application/json"}
    if token:
        headers["Authorization"] = f"Bearer {token}"
        headers["x-workspace-id"] = WORKSPACE_ID
    response = requests.request(method, BASE_URL + path, headers=headers, json=body)
    try:
        payload = response.json()
    except ValueError:
        payload = {}
    if not response.ok:
        raise RuntimeError(payload.get("message") or f"HTTP {response.status_code}")
    return payload.get("data")

def require_env():
    for name, value in {
        "INNORIX_EMAIL": EMAIL,
        "INNORIX_PASSWORD": PASSWORD,
        "INNORIX_WORKSPACE_ID": WORKSPACE_ID,
    }.items():
        if not value:
            raise RuntimeError(f"Missing required environment variable: {name}")

def encode_path(device_id, raw_path):
    """Build the `<deviceId>_ino_<base64(path)>` token used by the automation API."""
    normalized = str(raw_path or "").replace("\\", "/")
    token = base64.b64encode(normalized.encode("utf-8")).decode("ascii")
    return f"{device_id}_ino_{token}"

def now_iso():
    return datetime.now(timezone.utc).strftime("%Y-%m-%dT%H:%M:%S.%f")[:-3] + "Z"

def main():
    require_env()

    login = api("POST", "/api/auth/login", None, {"email": EMAIL, "password": PASSWORD})
    token = login["user"]["accessToken"]

    # Target options: fixed save path, conflict numbering, and how many path levels to keep.
    target_options = {
        "noSchedule": True,
        "send-fileoption": {},
        "target-action": "numbering",  # on conflict, append a number
        "savePath": SAVE_PATH,  # subfolder created under the target path (relative)
        "optionPath": 3,  # keep this many levels of the source path
    }

    automation = api("POST", "/api/automations", token, {
        "name": "Target Options Transfer",
        "flowName": "Target Options Transfer",
        "details": [
            {
                "sourceItem": [{"hash": encode_path(SOURCE_ID, SOURCE_PATH), "isDir": True}],
                "targetPath": encode_path(TARGET_ID, TARGET_PATH),
                "senderId": SOURCE_ID,
                "receiverId": TARGET_ID,
                "step": 1,
                "transferOptions": target_options,
            }
        ],
        "global": target_options,
        "transferType": "no_schedule",
        "timezone": TIMEZONE,
        "callbackURL": "",
        "schedules": [
            {
                "type": "none",
                "startDateType": "now",
                "hour": "05",
                "minute": "00",
                "ampm": "pm",
                "startDate": now_iso(),
                "timezone": TIMEZONE,
            }
        ],
    })

    print("automation created", {
        "automationId": automation.get("automationId"),
        "flowName": automation.get("flowName") or automation.get("automationName"),
    })

if __name__ == "__main__":
    try:
        main()
    except Exception as error:  # noqa: BLE001
        print(error, file=sys.stderr)
        sys.exit(1)

"""Example 11 - Synchronization overview.

A synchronization is an automation whose detail has isSync=true (syncType 1 = one-way).
This example creates one, reads it back, then deletes it.

INNORIX_SOURCE_ID / TARGET_ID must be the exact device IDs - they are encoded into the
path token, so a device name will not work here (unlike the manual-transfer examples).

Required environment variables: INNORIX_EMAIL, INNORIX_PASSWORD, INNORIX_WORKSPACE_ID
See ../.env.example for the full list and defaults.

Run:  python "11-Synchronization-Overview/example.py"
"""

import base64
import os
import sys
from pathlib import Path
from urllib.parse import quote

import requests
from dotenv import load_dotenv

# Load .env from the example's own folder first (so a single downloaded example works
# with a .env placed next to it), then fall back to the shared python/.env one level up.
# python-dotenv does not overwrite variables that are already set, so the folder-local
# .env wins and the shared one only fills in whatever is missing.
_here = Path(__file__).resolve().parent
load_dotenv(_here / ".env")          # same folder as this script
load_dotenv(_here.parent / ".env")   # shared python/.env (used by the full example set)

BASE_URL = os.getenv("INNORIX_BASE_URL", "https://app.innorix.com")
EMAIL = os.getenv("INNORIX_EMAIL")
PASSWORD = os.getenv("INNORIX_PASSWORD")
WORKSPACE_ID = os.getenv("INNORIX_WORKSPACE_ID")
SOURCE_ID = os.getenv("INNORIX_SOURCE_ID", "device-source-01")
TARGET_ID = os.getenv("INNORIX_TARGET_ID", "device-target-01")
SOURCE_PATH = os.getenv("INNORIX_SOURCE_PATH", "/data/shared").replace("\\", "/")
TARGET_PATH = os.getenv("INNORIX_TARGET_PATH", "/data/mirror").replace("\\", "/")
TIMEZONE = os.getenv("INNORIX_TIMEZONE", "UTC")

def api(method, path, token=None, body=None):
    headers = {"Content-Type": "application/json"}
    if token:
        headers["Authorization"] = f"Bearer {token}"
        headers["x-workspace-id"] = WORKSPACE_ID
    response = requests.request(method, BASE_URL + path, headers=headers, json=body)
    try:
        payload = response.json()
    except ValueError:
        payload = {}
    if not response.ok:
        raise RuntimeError(payload.get("message") or f"HTTP {response.status_code}")
    return payload.get("data")

def require_env():
    for name, value in {
        "INNORIX_EMAIL": EMAIL,
        "INNORIX_PASSWORD": PASSWORD,
        "INNORIX_WORKSPACE_ID": WORKSPACE_ID,
    }.items():
        if not value:
            raise RuntimeError(f"Missing required environment variable: {name}")

def encode_path(device_id, raw_path):
    """Build the `<deviceId>_ino_<base64(path)>` token used by the automation API."""
    normalized = str(raw_path or "").replace("\\", "/")
    token = base64.b64encode(normalized.encode("utf-8")).decode("ascii")
    return f"{device_id}_ino_{token}"

def main():
    require_env()

    login = api("POST", "/api/auth/login", None, {"email": EMAIL, "password": PASSWORD})
    token = login["user"]["accessToken"]

    # 1) Create a one-way synchronization automation (isSync=true, syncType=1).
    print("Create automation")
    automation = api("POST", "/api/automations", token, {
        "name": "Synchronization Overview",
        "transferType": "sync",
        "timezone": TIMEZONE,
        "isUpcoming": False,
        "schedules": [],
        "details": [
            {
                "sourceItem": [
                    {
                        "hash": encode_path(SOURCE_ID, SOURCE_PATH),
                        "filePath": SOURCE_PATH,
                        "isDir": True,
                        "fileSize": 0,
                    }
                ],
                "targetPath": encode_path(TARGET_ID, TARGET_PATH),
                "senderId": SOURCE_ID,
                "receiverId": TARGET_ID,
                "step": 1,
                "fileCount": 0,
                "folderCount": 1,
                "sizeCount": 0,
                "isSync": True,
                "transferOptions": {"syncType": 1},  # 1 = one-way, 2 = two-way
            }
        ],
    })
    automation_id = automation.get("automationId")
    if not automation_id:
        raise RuntimeError("Automation creation response did not include an automationId")
    print("automation created", automation_id)

    # 2) Read the automation back; its status reflects the current sync state.
    print("Get automation")
    print(api("GET", f"/api/automations/{quote(str(automation_id))}", token))

    # 3) Delete the automation (example cleanup).
    print("Delete automation")
    api("DELETE", f"/api/automations/{quote(str(automation_id))}", token)
    print("automation deleted", automation_id)

if __name__ == "__main__":
    try:
        main()
    except Exception as error:  # noqa: BLE001
        print(error, file=sys.stderr)
        sys.exit(1)