Fetch Gallery

The gallery is designed to retrieve details of generated model.

Retrieves a list of gallery cards. When the type is set to Recent, the endpoint returns cards from all users. For any other specified type, it returns cards only from the corresponding category.

Give a gallery list.

Give a gallery list.

POST/api/task/cards

Authorization

bearer

Body

application/json

page_num*number

type*enum

RecentFeaturedMineGroupStory

user_typeenum

AllGeneratedLikedPackingPacked

task_typeenum

DreamFaceImagineFaceAPIPanoramaRodinMedia2FaceSkybox

task_steparray of array

group_uuidstring

tag_idsarray of number

Response

201

Body

application/json

task_uuid*string

type*enum

DreamFaceImagineFaceAPIPanoramaRodinMedia2FaceSkybox

image_urlstring

video_urlstring

promptstring

num_like*number

is_like*boolean

time*string (date-time)

author*UserBasicInformationDto (object)

user_stateenum

GeneratingDonePreviewDoneBasicDoneHighLikedNone

lisencedboolean

titlestring

stylestring

is_privateboolean

groupGroupMetaDto (object)

is_genmeboolean

allow_previewboolean

step*enum

CreatedPreprocessGenerateConfirmModelGenerateTextureGenerateModelRefineTextureRefineSkyboxSketchSkyboxHighRes

pending_jobsarray of string

Request

JavaScriptCurlPython

const response = await fetch('/api/task/cards', {
    method: 'POST',
    headers: {
      "Authorization": "Bearer JWT",
      "Content-Type": "application/json"
    },
    body: JSON.stringify({
      "page_num": 0,
      "type": "Recent"
    }),
});
const data = await response.json();

Response

201

[
  {
    "task_uuid": "text",
    "type": "DreamFace",
    "image_url": "text",
    "video_url": "text",
    "prompt": "text",
    "num_like": 0,
    "is_like": false,
    "time": "2024-12-25T17:53:08.808Z",
    "author": {
      "user_uuid": "text",
      "username": "text",
      "avatar_url": "text",
      "email": "text"
    },
    "user_state": "Generating",
    "lisenced": false,
    "title": "text",
    "style": "text",
    "is_private": false,
    "group": {
      "uuid": "text",
      "name": "text",
      "member_count": 0,
      "expiration_date": "2024-12-25T17:53:08.808Z",
      "settings": {
        "allowed_style": [
          "text"
        ],
        "allowed_topology": [
          "text"
        ],
        "max_member_count": 0,
        "allow_preview": false,
        "additional_settings": [
          "text"
        ]
      }
    },
    "is_genme": false,
    "allow_preview": false,
    "step": "Created",
    "pending_jobs": [
      "text"
    ]
  }
]

Examples

Go

package main

import (
	"bytes"
	"encoding/json"
	"fmt"
	"net/http"
	"time"
)

const BaseURI = "https://hyperhuman.deemos.com/api"

var client = &http.Client{Timeout: 10 * time.Second}

type CommonError struct {
	Error *string `json:"error,omitempty"`
}

type GalleryType string

const (
	Recent   GalleryType = "Recent"
	Featured GalleryType = "Featured"
	Mine     GalleryType = "Mine"
	Group    GalleryType = "Group"
	Story    GalleryType = "Story"
)

type CardStatusType string

const (
	All       CardStatusType = "All"
	Generated CardStatusType = "Generated"
	Liked     CardStatusType = "Liked"
	Packing   CardStatusType = "Packing"
	Packed    CardStatusType = "Packed"
)

type TaskType string

const (
	DreamFace   TaskType = "DreamFace"
	ImagineFace TaskType = "ImagineFace"
	API         TaskType = "API"
	Panorama    TaskType = "Panorama"
	Rodin       TaskType = "Rodin"
	Media2Face  TaskType = "Media2Face"
)

type TaskStep string

const (
	Created         TaskStep = "Created"
	Preprocess      TaskStep = "Preprocess"
	Generate        TaskStep = "Generate"
	ModelGenerate   TaskStep = "ModelGenerate"
	TextureGenerate TaskStep = "TextureGenerate"
	ModelRefine     TaskStep = "ModelRefine"
	TextureRefine   TaskStep = "TextureRefine"
)

type UserBasicInformation struct {
	UserUUID  string `json:"user_uuid,omitempty"`
	Username  string `json:"username,omitempty"`
	AvatarUrl string `json:"avatar_url,omitempty"`
	Email     string `json:"email,omitempty"`
}

type GroupSettings struct {
	AllowedStyle       []string `json:"allowed_style,omitempty"`
	AllowedTopology    []string `json:"allowed_topology,omitempty"`
	MaxMemberCount     *int     `json:"max_member_count,omitempty"`
	AllowPreview       *bool    `json:"allow_preview,omitempty"`
	AdditionalSettings []string `json:"additional_settings,omitempty"`
}

type GroupMeta struct {
	Uuid           string         `json:"uuid"`
	Name           string         `json:"name"`
	MemberCount    int            `json:"member_count"`
	ExpirationDate string         `json:"expiration_date"`
	Settings       *GroupSettings `json:"settings"`
}

type GalleryResponse struct {
	TaskUUID     string               `json:"task_uuid"`
	Type         TaskType             `json:"type"`
	ImageUrl     *string              `json:"image_url,omitempty"`
	VideoUrl     *string              `json:"video_url,omitempty"`
	Prompt       *string              `json:"prompt,omitempty"`
	NumLike      int                  `json:"num_like"`
	IsLike       bool                 `json:"is_like"`
	Time         string               `json:"time"`
	Author       UserBasicInformation `json:"author"`
	UserState    *string              `json:"user_state,omitempty"`
	Lisenced     *bool                `json:"lisenced,omitempty"`
	Title        *string              `json:"title,omitempty"`
	Style        *string              `json:"style,omitempty"`
	IsPrivate    *bool                `json:"is_private,omitempty"`
	Group        *GroupMeta           `json:"group,omitempty"`
	IsGenme      *bool                `json:"is_genme,omitempty"`
	AllowPreview *bool                `json:"allow_preview,omitempty"`
	Step         string               `json:"step"`
	PendingJobs  []string             `json:"pending_jobs,omitempty"`
}

func FetchGallery(token *string, pageIndex int, galleryType GalleryType, userType *CardStatusType, taskType *TaskType, taskStep []TaskStep, groupUuid *string, tagIds []int) (string, []GalleryResponse, error) {
	// Create the request body
	data := map[string]any{"page_num": pageIndex, "type": galleryType}
	if userType != nil {
		data["user_type"] = userType
	}
	if taskType != nil {
		data["task_type"] = taskType
	}
	if taskStep != nil && len(taskStep) > 0 {
		data["task_step"] = taskStep
	}

	if groupUuid != nil {
		data["group_uuid"] = groupUuid
	}

	if tagIds != nil && len(tagIds) > 0 {
		data["tag_ids"] = tagIds
	}

	jsonData, err := json.Marshal(data)
	if err != nil {
		return "", nil, err
	}

	// Create the request
	req, err := http.NewRequest("POST", fmt.Sprintf("%s/task/cards", BaseURI), bytes.NewBuffer(jsonData))
	if err != nil {
		return "", nil, err
	}

	// Set headers
	if token != nil {
		req.Header.Set("Authorization", "Bearer "+*token)
	}
	req.Header.Set("Content-Type", "application/json")

	resp, err := client.Do(req)
	if err != nil {
		return "", nil, err
	}
	defer resp.Body.Close()

	if resp.StatusCode != http.StatusCreated {
		return "", nil, fmt.Errorf("unexpected status code: %d", resp.StatusCode)
	}

	var responseData []GalleryResponse
	err = json.NewDecoder(resp.Body).Decode(&responseData)
	if err != nil {
		return "", nil, err
	}

	return resp.Header.Get("Subscription-Key"), responseData, nil
}

// LoginResponse represents the response from the login endpoint.
type LoginResponse struct {
	CommonError
	UserBasicInformation
	Token string `json:"token,omitempty"`
}

// Login performs JWT-based authentication.
func Login(email, password string) (string, *UserBasicInformation, error) {
	payload := map[string]string{"password": password, "email": email}

	jsonData, err := json.Marshal(payload)
	if err != nil {
		return "", nil, err
	}

	req, err := http.NewRequest("POST", fmt.Sprintf("%s/user/login", BaseURI), bytes.NewBuffer(jsonData))
	if err != nil {
		return "", nil, err
	}

	req.Header.Set("Content-Type", "application/json")

	resp, err := client.Do(req)
	if err != nil {
		return "", nil, err
	}
	defer resp.Body.Close()

	var responseData LoginResponse
	err = json.NewDecoder(resp.Body).Decode(&responseData)
	if err != nil {
		return "", nil, err
	}

	if responseData.Error != nil {
		return "", nil, fmt.Errorf("error: %s", *responseData.Error)
	}

	return responseData.Token, &responseData.UserBasicInformation, nil
}

func main() {
	email := "[e-mail]"
	password := "<your password>"
	token, info, _ := Login(email, password)
	fmt.Println("Logged in successfully. Token:", token, "BasicInformation:", *info)
	userType := All
	_, result, _ := FetchGallery(&token, 0, Mine, &userType, nil, nil, nil, nil)
	fmt.Printf("Fetched %d Gallery items\n", len(result))
	if len(result) > 0 {
		fmt.Printf("The the first gallery item has got %d like(s).\n", result[0].NumLike)
	}
}