tripo3d 0.4.0

An unofficial Rust SDK for the Tripo3D API
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145

use serde::{Deserialize, Serialize};

/// A private struct for serializing the text-to-model request body.
#[derive(Serialize)]
pub(crate) struct TextToModelRequest<'a> {
    pub(crate) prompt: &'a str,
    #[serde(rename = "type")]
    pub(crate) type_: &'a str,
}

/// Represents an object stored in an S3-compatible service.
#[derive(Serialize, Debug)]
pub struct S3Object {
    /// The name of the S3 bucket.
    pub bucket: String,
    /// The full key (path) of the object within the bucket.
    pub key: String,
}

/// Describes the input file for a generation task.
///
/// This struct is flexible and can represent a file in one of three ways:
/// 1. As an object in an S3 bucket (`object`).
/// 2. As a publicly accessible URL (`url`).
/// 3. As a token representing a previously uploaded file (`file_token`).
#[derive(Serialize, Debug, Default)]
pub struct FileContent {
    /// The file format, e.g., "png", "jpeg".
    #[serde(rename = "type")]
    pub type_: String,
    /// The S3 object details, if the file was uploaded via STS tokens.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub object: Option<S3Object>,
    /// A direct URL to the image file.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub url: Option<String>,
    /// A token representing a file uploaded via the standard multipart endpoint.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub file_token: Option<String>,
}

/// A request to create an image-to-model task.
#[derive(Serialize, Debug)]
pub struct ImageTaskRequest {
    /// The type of the task, which should be "image_to_model".
    #[serde(rename = "type")]
    pub type_: &'static str,
    /// The file content to be used for the task.
    pub file: FileContent,
}

/// The response from an API call that successfully initiates a task.
#[derive(Deserialize, Debug)]
pub struct TaskResponse {
    /// The unique identifier for the newly created task.
    #[serde(rename = "task_id")]
    pub task_id: String,
}

/// (Internal) Holds temporary STS credentials for uploading to S3.
#[derive(Deserialize, Debug)]
pub(crate) struct StsTokenData {
    pub(crate) sts_ak: String,
    pub(crate) sts_sk: String,
    pub(crate) session_token: String,
    pub(crate) resource_bucket: String,
    pub(crate) resource_uri: String,
}

/// (Internal) Holds the file token from a standard multipart upload.
#[derive(Deserialize, Debug)]
pub(crate) struct StandardUploadData {
    pub(crate) image_token: String,
}

/// Represents the lifecycle state of a generation task.
#[derive(Debug, Deserialize, PartialEq, Eq, Clone, Copy)]
#[serde(rename_all = "lowercase")]
pub enum TaskState {
    /// The task has been submitted but has not yet started processing.
    Pending,
    /// The task is actively being processed.
    Running,
    /// The task completed successfully.
    Success,
    /// The task failed to complete.
    Failure,
}

/// A downloadable file asset, typically a 3D model.
#[derive(Debug, Deserialize, Clone)]
pub struct ResultFile {
    /// The direct URL to download the file.
    pub url: String,
}

/// The set of output files from a successfully completed task.
#[derive(Debug, Deserialize, Clone, Default)]
pub struct TaskResult {
    /// The primary model output in PBR (Physically-Based Rendering) format, typically GLB.
    #[serde(default)]
    pub pbr_model: Option<ResultFile>,
    /// An alternative model output in GLB format.
    #[serde(default)]
    pub glb_model: Option<ResultFile>,
}

/// A preview image generated during the task.
#[derive(Debug, Deserialize, Clone)]
pub struct TaskOutput {
    /// The URL of the generated preview image.
    pub generated_image: Option<String>,
}

/// The detailed status and data of a generation task.
#[derive(Debug, Deserialize, Clone)]
pub struct TaskStatus {
    /// The unique identifier of the task.
    pub task_id: String,
    /// The current lifecycle state of the task.
    pub status: TaskState,
    /// The completion progress of the task, from 0 to 100.
    pub progress: u8,
    /// The Unix timestamp of when the task was created.
    pub create_time: u64,
    /// The resulting output files from the task, if successful.
    pub result: TaskResult,
    /// A link to a generated preview image, if available.
    pub output: Option<TaskOutput>,
}

/// The user's account balance.
#[derive(Deserialize, Debug)]
pub struct Balance {
    /// The available, usable balance.
    pub balance: f64,
    /// The amount of credits currently reserved for ongoing tasks.
    pub frozen: f64,
}

/// (Internal) A generic wrapper for API responses where the content is nested under a "data" field.
#[derive(Debug, Deserialize)]
pub(crate) struct ApiResponse<T> {
    pub(crate) data: T,
}