API接口调用文档

import requests
import json

class APIClient:
    def __init__(self, api_key):
        self.api_key = api_key
        self.api_domain = 'https://api.hymf.top/'
        self.headers = {
            'X-API-KEY': api_key,
            'Content-Type': 'application/json'
        }
    
    def submit_task(self, video_url, audio_url):
        url = f"{self.api_domain}/api/apiKF_submit_task.php"
        data = {
            'source_video_url': video_url,
            'source_audio_url': audio_url
        }
        
        response = requests.post(
            url,
            headers=self.headers,
            json=data
        )
        return response.json()
    
    def get_task_status(self, task_number):
        url = f"{self.api_domain}/api/apiKF_get_task_status.php"
        response = requests.get(
            url,
            headers=self.headers,
            params={'task_number': task_number}
        )
        return response.json()

# 使用示例
def main():
    client = APIClient('YOUR_API_KEY')
    
    # 提交任务
    result = client.submit_task(
        'https://example.com/video.mp4',
        'https://example.com/audio.mp3'
    )
    
    if result.get('success'):
        task_number = result['task_number']
        print(f"任务提交成功，任务编号：{task_number}")
        
        # 查询任务状态
        status = client.get_task_status(task_number)
        print(json.dumps(status, indent=2, ensure_ascii=False))

if __name__ == '__main__':
    main()

const axios = require('axios');

class APIClient {
    constructor(apiKey) {
        this.apiKey = apiKey;
        this.apiDomain = 'https://api.hymf.top/';
        this.headers = {
            'X-API-KEY': apiKey,
            'Content-Type': 'application/json'
        };
    }

    async submitTask(videoUrl, audioUrl) {
        try {
            const response = await axios.post(
                `${this.apiDomain}/api/apiKF_submit_task.php`,
                {
                    source_video_url: videoUrl,
                    source_audio_url: audioUrl
                },
                { headers: this.headers }
            );
            return response.data;
        } catch (error) {
            console.error('提交任务失败:', error.message);
            throw error;
        }
    }

    async getTaskStatus(taskNumber) {
        try {
            const response = await axios.get(
                `${this.apiDomain}/api/apiKF_get_task_status.php`,
                {
                    headers: this.headers,
                    params: { task_number: taskNumber }
                }
            );
            return response.data;
        } catch (error) {
            console.error('获取任务状态失败:', error.message);
            throw error;
        }
    }
}

// 使用示例
async function main() {
    const client = new APIClient('YOUR_API_KEY');

    try {
        // 提交任务
        const result = await client.submitTask(
            'https://example.com/video.mp4',
            'https://example.com/audio.mp3'
        );

        if (result.success) {
            console.log(`任务提交成功，任务编号：${result.task_number}`);

            // 查询任务状态
            const status = await client.getTaskStatus(result.task_number);
            console.log('任务状态:', JSON.stringify(status, null, 2));
        }
    } catch (error) {
        console.error('操作失败:', error.message);
    }
}

main();

import com.fasterxml.jackson.databind.ObjectMapper;
import okhttp3.*;
import java.io.IOException;
import java.util.HashMap;
import java.util.Map;

public class APIClient {
    private final String apiKey;
    private final String apiDomain;
    private final OkHttpClient client;
    private final ObjectMapper mapper;

    public APIClient(String apiKey) {
        this.apiKey = apiKey;
        this.apiDomain = "https://api.hymf.top/";
        this.client = new OkHttpClient();
        this.mapper = new ObjectMapper();
    }

    public Map submitTask(String videoUrl, String audioUrl) throws IOException {
        Map requestBody = new HashMap<>();
        requestBody.put("source_video_url", videoUrl);
        requestBody.put("source_audio_url", audioUrl);

        Request request = new Request.Builder()
            .url(apiDomain + "/api/apiKF_submit_task.php")
            .addHeader("X-API-KEY", apiKey)
            .addHeader("Content-Type", "application/json")
            .post(RequestBody.create(
                mapper.writeValueAsString(requestBody),
                MediaType.parse("application/json")
            ))
            .build();

        try (Response response = client.newCall(request).execute()) {
            String responseBody = response.body().string();
            return mapper.readValue(responseBody, Map.class);
        }
    }

    public Map getTaskStatus(String taskNumber) throws IOException {
        HttpUrl url = HttpUrl.parse(apiDomain + "/api/apiKF_get_task_status.php")
            .newBuilder()
            .addQueryParameter("task_number", taskNumber)
            .build();

        Request request = new Request.Builder()
            .url(url)
            .addHeader("X-API-KEY", apiKey)
            .build();

        try (Response response = client.newCall(request).execute()) {
            String responseBody = response.body().string();
            return mapper.readValue(responseBody, Map.class);
        }
    }

    public static void main(String[] args) {
        APIClient client = new APIClient("YOUR_API_KEY");

        try {
            // 提交任务
            Map result = client.submitTask(
                "https://example.com/video.mp4",
                "https://example.com/audio.mp3"
            );

            if ((Boolean) result.get("success")) {
                String taskNumber = (String) result.get("task_number");
                System.out.println("任务提交成功，任务编号：" + taskNumber);

                // 查询任务状态
                Map status = client.getTaskStatus(taskNumber);
                System.out.println("任务状态：" + mapper.writeValueAsString(status));
            }
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}