Python

Updated May 29, 2026, 12:30 PM

description: CGPT SDK Docs Python

Python

ChainGPT AI NFT Generator SDK Documentation

The ChainGPT AI NFT Generator SDK provides a comprehensive suite of tools to create, manage, and prepare NFTs for minting. This includes enhancing prompts, generating images (synchronously and asynchronously), tracking generation progress, retrieving minting metadata, and querying supported blockchains and contract ABIs.

Installation
Quick Start
SDK Initialization
NFT Service Overview
NFT Service Methods
- enhance_prompt()
- generate_image()
- generate_nft_queue()
- get_progress()
- mint_nft_metadata()
- get_chains()
- get_abi()
Data Models & Types
Enums Reference
Error Handling
Complete Example
Best Practices
New Features

Installation

Install the ChainGPT SDK via pip:

pip install chaingpt

Or add to your requirements.txt:

chaingpt>=1.1.4

For development with environment variables:

pip install python-dotenv  # Optional for .env file support

Quick Start

Here's a minimal example to get you started:

import asyncio
from chaingpt.client import ChainGPTClient
from chaingpt.models import GenerateImageRequestModel, NFTImageModel

async def quick_example():
    client = ChainGPTClient(api_key="YOUR_API_KEY")

    # Generate an image synchronously
    request = GenerateImageRequestModel(
        prompt="a dragon in space",
        model=NFTImageModel.VELOGEN,
        height=512,
        width=512
    )

    response = await client.nft.generate_image(request)

    # Save the image
    with open("dragon.jpg", "wb") as f:
        f.write(bytes(response.data.data))

    await client.close()

if __name__ == "__main__":
    asyncio.run(quick_example())

SDK Initialization

Basic Initialization

import asyncio
from chaingpt.client import ChainGPTClient
from chaingpt.exceptions import ChainGPTError

# Basic initialization
client = ChainGPTClient(api_key="YOUR_API_KEY")

# With environment variable
import os
API_KEY = os.getenv("CHAINGPT_API_KEY")
client = ChainGPTClient(api_key=API_KEY)

Required Imports

from chaingpt.client import ChainGPTClient
from chaingpt.models import (
    EnhancePromptRequestModel,
    GenerateImageRequestModel,
    GenerateNFTQueueRequestModel,
    MintNFTRequestModel,
    TraitModel,
    TraitValueItemModel,
    NFTImageModel,
    ImageEnhanceOption
)
from chaingpt.exceptions import ChainGPTError, APIError

NFT Service Overview

Access the NFT service through the client:

nft_service = client.nft

The NFT service provides seven main methods:

enhance_prompt(): Improve prompts for better image generation
generate_image(): Create images synchronously (fast preview)
generate_nft_queue(): Queue asynchronous NFT generation (high quality)
get_progress(): Track queued generation progress
mint_nft_metadata(): Generate metadata for blockchain minting
get_chains(): List supported blockchain networks
get_abi(): Get smart contract ABI

NFT Service Methods

enhance_prompt()

Enhances or refines a text prompt for better image generation results.

Method Signature:

async def enhance_prompt(self, request_data: EnhancePromptRequestModel) -> EnhancePromptResponseModel

Parameters:

Parameter	Type	Required	Description
`request_data`	`EnhancePromptRequestModel`	Yes	Request containing the prompt to enhance

Request Model (EnhancePromptRequestModel):

Field	Type	Required	Description
`prompt`	`str`	Yes	The text prompt you want to enhance

Response Model (EnhancePromptResponseModel):

Field	Type	Description
`statusCode`	`int`	HTTP status code (200 for success)
`message`	`str`	Response message
`data.enhancedPrompt`	`str`	The enhanced version of your prompt

Example:

async def enhance_example():
    enhance_request = EnhancePromptRequestModel(prompt="a dragon in space")
    response = await client.nft.enhance_prompt(enhance_request)

    if response.statusCode == 200:
        print(f"Original: a dragon in space")
        print(f"Enhanced: {response.data.enhancedPrompt}")
        # Output might be: "A majestic dragon soaring through the cosmic void,
        # surrounded by stars and nebulae, highly detailed, fantasy art"

generate_image()

Generates an image synchronously based on the given prompt and parameters. Best for quick previews and testing.

Method Signature:

async def generate_image(self, request_data: GenerateImageRequestModel) -> GenerateImageResponseModel

Parameters:

Parameter	Type	Required	Description
`request_data`	`GenerateImageRequestModel`	Yes	Image generation parameters

Request Model (GenerateImageRequestModel):

Field	Type	Required	Default	Description
`prompt`	`str`	Yes	-	Text prompt for image generation
`model`	`NFTImageModel`	Yes	-	AI model to use (see Enums)
`height`	`int`	Yes	-	Image height in pixels
`width`	`int`	Yes	-	Image width in pixels
`steps`	`int`	No	Model default	Number of refinement passes for image generation. Higher values can yield more detailed images at the cost of longer generation time. Each model supports a range: for example, velogen supports 1–4 steps (default ~2), while NebulaForge XL and VisionaryForge support up to 50 (default ~25). If not provided, a model-specific default is used.
`enhance`	`ImageEnhanceOption`	No	`ORIGINAL`	Image enhancement level
`style`	`str`	No	`None`	Artistic style (e.g., "fantasy_art", "cyberpunk")
`traits`	`List[TraitModel]`	No	`None`	List of traits to apply
`image`	`HttpUrl`	No	`None`	Reference image URL for image-to-image generation
`isCharacterPreserve`	`bool`	No	`False`	Preserve character features from reference image

Response Model (GenerateImageResponseModel):

Field	Type	Description
`data.type`	`str`	Data type (always "Buffer")
`data.data`	`List[int]`	Raw image bytes as integer array

Image-to-Image Generation:

from pydantic import HttpUrl

# Generate image based on a reference image
request = GenerateImageRequestModel(
    prompt="a dragon in space",
    model=NFTImageModel.VELOGEN,
    height=512,
    width=512,
    image=HttpUrl("https://example.com/reference-image.jpg"),
    isCharacterPreserve=True  # Preserve character features from reference
)

response = await client.nft.generate_image(request)

Example:

async def generate_image_example():
    request = GenerateImageRequestModel(
        prompt="a majestic cyberpunk dragon",
        model=NFTImageModel.VELOGEN,  # Fast model for sync generation
        height=512,
        width=512,
        steps=3,
        enhance=ImageEnhanceOption.ENHANCE_1X,
        style="cyberpunk"
    )

    response = await client.nft.generate_image(request)

    # Save the image
    image_bytes = bytes(response.data.data)
    with open("generated_image.png", "wb") as f:
        f.write(image_bytes)

    print(f"Image generated: {len(image_bytes)} bytes")

Image-to-Image Generation:

from pydantic import HttpUrl

# Generate image based on a reference image
request = GenerateImageRequestModel(
    prompt="a dragon in space",
    model=NFTImageModel.VELOGEN,
    height=512,
    width=512,
    image=HttpUrl("https://example.com/reference-image.jpg"),
    isCharacterPreserve=True  # Preserve character features
)

response = await client.nft.generate_image(request)

Using Traits:

from chaingpt.models import TraitModel, TraitValueItemModel

traits = [
    TraitModel(
        trait_type="Background",
        value=[
            TraitValueItemModel(value="night_sky", ratio=70),
            TraitValueItemModel(value="lava_pit", ratio=30)
        ]
    ),
    TraitModel(
        trait_type="Color",
        value=[
            TraitValueItemModel(value="blue", ratio=50),
            TraitValueItemModel(value="red", ratio=50)
        ]
    )
]

request = GenerateImageRequestModel(
    prompt="a dragon",
    model=NFTImageModel.VELOGEN,
    height=512,
    width=512,
    traits=traits
)

generate_nft_queue()

Initiates an asynchronous NFT image generation job. Use this for high-quality images or when you don't need immediate results.

Method Signature:

async def generate_nft_queue(self, request_data: GenerateNFTQueueRequestModel) -> GenerateNFTQueueResponseModel

Parameters:

Parameter	Type	Required	Description
`request_data`	`GenerateNFTQueueRequestModel`	Yes	NFT generation parameters

Request Model (GenerateNFTQueueRequestModel):

Field	Type	Required	Description
`walletAddress`	`str`	Yes	Blockchain wallet address for the NFT
`prompt`	`str`	Yes	Text prompt for image generation
`model`	`NFTImageModel`	Yes	AI model to use
`height`	`int`	Yes	Image height in pixels
`width`	`int`	Yes	Image width in pixels
`chainId`	`int`	Yes	Blockchain network ID (see get_chains())
`amount`	`int`	Yes	Number of NFTs to generate in this batch
`steps`	`int`	No	Generation steps
`enhance`	`ImageEnhanceOption`	No	Enhancement level
`style`	`str`	No	Artistic style
`traits`	`List[TraitModel]`	No	List of traits
`image`	`HttpUrl`	No	Reference image URL for image-to-image generation
`isCharacterPreserve`	`bool`	No	Preserve character features from reference image

Response Model (GenerateNFTQueueResponseModel):

Field	Type	Description
`statusCode`	`int`	HTTP status code (201 = successfully queued)
`message`	`str`	Response message
`data.collectionId`	`str`	Unique ID for tracking this generation job

Example:

async def generate_nft_queue_example():
    request = GenerateNFTQueueRequestModel(
        walletAddress="0x742d35Cc6635C0532925a3b8D8842A36fF20fd40",
        prompt="A mystical phoenix rising from cosmic ashes",
        model=NFTImageModel.NEBULA_FORGE_XL,  # High-quality model
        height=1024,
        width=1024,
        steps=30,
        enhance=ImageEnhanceOption.ENHANCE_1X,
        chainId=56,  # BSC Mainnet
        amount=1,
        style="cinematic"
    )

    response = await client.nft.generate_nft_queue(request)

    if response.statusCode == 201:
        print(f"NFT queued successfully!")
        print(f"Collection ID: {response.data.collectionId}")
        return response.data.collectionId
    else:
        print(f"Failed to queue: {response.message}")
        return None

get_progress()

Checks the status and progress of a queued NFT generation job.

Method Signature:

async def get_progress(self, collection_id: str) -> NFTProgressResponseModel

Parameters:

Parameter	Type	Required	Description
`collection_id`	`str`	Yes	Collection ID from `generate_nft_queue()` response

Response Model (NFTProgressResponseModel):

Field	Type	Description
`statusCode`	`int`	HTTP status code
`message`	`str`	Response message
`data.generated`	`bool`	`True` if generation is complete
`data.images`	`List[str]`	IPFS URLs (only when `generated=True`)
`data.progress`	`int`	Progress percentage (only when processing)

Example:

async def track_progress_example(collection_id: str):
    max_attempts = 20
    attempt = 0

    while attempt < max_attempts:
        response = await client.nft.get_progress(collection_id)

        print(f"Status: {response.data.generated}")
        if response.data.progress:
            print(f"Progress: {response.data.progress}%")

        if response.data.generated:
            print("Generation completed!")
            if response.data.images:
                print(f"IPFS URLs: {response.data.images}")
            return True

        await asyncio.sleep(15)  # Wait 15 seconds
        attempt += 1

    print("Timeout reached")
    return False

mint_nft_metadata()

Generates the metadata required for minting NFTs on a blockchain. Call this after NFT generation is complete.

Method Signature:

async def mint_nft_metadata(self, request_data: MintNFTRequestModel) -> MintNFTResponseModel

Parameters:

Parameter	Type	Required	Description
`request_data`	`MintNFTRequestModel`	Yes	Metadata generation parameters

Request Model (MintNFTRequestModel):

Field	Type	Required	Description
`collectionId`	`str`	Yes	ID of completed NFT generation job
`name`	`str`	Yes	Name of the NFT
`description`	`str`	Yes	Description of the NFT
`symbol`	`str`	Yes	Symbol for the NFT collection
`ids`	`List[int]`	Yes	List of NFT IDs to mint (e.g., `[1]` for single NFT)

Response Model (MintNFTResponseModel):

Field	Type	Description
`statusCode`	`int`	HTTP status code
`message`	`str`	Response message
`data._id`	`str`	MongoDB document ID
`data._id`	`str`	MongoDB document ID
`data.name`	`str`	NFT name
`data.description`	`str`	NFT description
`data.image`	`str`	IPFS URL for the NFT image
`data.attributes`	`List[Dict]`	NFT attributes/traits
`data.collectionId`	`str`	Collection ID
`data.transaction`	`Any`	Transaction details (if applicable)
`data.__v`	`int`	MongoDB version field
`data.createdAt`	`str`	Creation timestamp
`data.updatedAt`	`str`	Last update timestamp
`data.__v`	`int`	MongoDB version field
`data.createdAt`	`str`	Creation timestamp
`data.updatedAt`	`str`	Last update timestamp

Example:

async def mint_metadata_example(collection_id: str):
    request = MintNFTRequestModel(
        collectionId=collection_id,
        name="Cosmic Phoenix #1",
        description="A stunning AI-generated phoenix from the ChainGPT NFT Forge.",
        symbol="CPHX",
        ids=[1]  # Single NFT
    )

    response = await client.nft.mint_nft_metadata(request)

    if response.statusCode in [200, 201]:
        print("Metadata generated successfully:")
        print(f"  ID: {response.data._id}")
        print(f"  Name: {response.data.name or 'Not provided'}")
        print(f"  Image: {response.data.image or 'Not provided'}")
        print(f"  Attributes: {response.data.attributes or 'None'}")
        print(f"  Collection ID: {response.data.collectionId or 'Not provided'}")
        print(f"  Created At: {response.data.createdAt or 'Not provided'}")

        # This metadata can now be used with smart contracts
        return response.data
    else:
        print(f"Failed to generate metadata: {response.message}")
        return None

get_chains()

Retrieves the list of supported blockchain networks for NFT operations.

Method Signature:

async def get_chains(self, test_net: Optional[bool] = None) -> GetChainsResponseModel

Parameters:

Parameter	Type	Required	Default	Description
`test_net`	`bool`	No	`None`	`True` for testnets, `False` for mainnets, `None` for all

Response Model (GetChainsResponseModel):

Field	Type	Description
`statusCode`	`int`	HTTP status code
`message`	`str`	Response message
`data.chains`	`List[ChainInfoModel]`	List of supported chains

Chain Info Model (ChainInfoModel):

Field	Type	Description
`chainId`	`int`	Numerical chain ID
`chainName`	`str`	Chain name (e.g., "Ethereum Mainnet")
`network`	`str`	Network type ("mainnet", "testnet")
`networkType`	`str`	Additional network classification

Example:

async def get_chains_example():
    # Get mainnet chains
    mainnet_response = await client.nft.get_chains(test_net=False)
    print("Mainnet Chains:")
    for chain in mainnet_response.data.chains[:5]:
        print(f"  ID: {chain.chainId}, Name: {chain.chainName}")

    # Get testnet chains
    testnet_response = await client.nft.get_chains(test_net=True)
    print("\nTestnet Chains:")
    for chain in testnet_response.data.chains[:5]:
        print(f"  ID: {chain.chainId}, Name: {chain.chainName}")

    # Common chain IDs:
    # 1 = Ethereum Mainnet
    # 56 = BSC Mainnet
    # 137 = Polygon Mainnet
    # 97 = BSC Testnet
    # 11155111 = Ethereum Sepolia

get_abi()

Provides the ABI (Application Binary Interface) of the ChainGPT NFT smart contract for direct blockchain interaction.

Method Signature:

async def get_abi(self) -> ContractABIResponseModel

Parameters: None

Response Model (ContractABIResponseModel):

Field	Type	Description
`statusCode`	`int`	HTTP status code
`message`	`str`	Response message
`data`	`List[Dict]`	Contract ABI as JSON objects

Example:

async def get_abi_example():
    response = await client.nft.get_abi()

    if response.statusCode == 200:
        abi = response.data
        print(f"Contract ABI contains {len(abi)} functions/events")

        # Use with web3.py
        from web3 import Web3
        w3 = Web3(Web3.HTTPProvider("YOUR_RPC_URL"))
        contract = w3.eth.contract(
            address="CONTRACT_ADDRESS",
            abi=abi
        )

        return abi
    else:
        print(f"Failed to get ABI: {response.message}")
        return None

Data Models & Types

TraitModel

Defines NFT traits/attributes for generation:

class TraitModel(BaseModel):
    trait_type: str          # Name of the trait (e.g., "Background", "Color")
    value: List[TraitValueItemModel]  # Possible values with ratios

class TraitValueItemModel(BaseModel):
    value: str               # Specific trait value (e.g., "night_sky")
    ratio: int              # Rarity/probability (higher = more common)

Error Models

All methods can raise the following exceptions:

from chaingpt.exceptions import (
    ChainGPTError,          # Base exception
    APIError,               # API-specific errors
    AuthenticationError,    # Invalid API key (401)
    ValidationError,        # Bad request (400)
    InsufficientCreditsError, # No credits (402/403)
    RateLimitError,         # Too many requests (429)
    NotFoundError,          # Endpoint not found (404)
    ServerError,            # Server errors (5xx)
    TimeoutError           # Request timeout
)

Enums Reference

NFTImageModel

Available AI models for image generation:

Model	Value	Description	Best For
`VELOGEN`	`"velogen"`	Fast generation	Quick previews, testing
`NEBULA_FORGE_XL`	`"nebula_forge_xl"`	High quality	Final NFTs, detailed art
`VISIONARY_FORGE`	`"VisionaryForge"`	Balanced	General purpose
`DALE3`	`"Dale3"`	Alternative model	Experimental

ImageEnhanceOption

Image enhancement levels:

Option	Value	Description
`ORIGINAL`	`"original"`	No enhancement
`ENHANCE_1X`	`"1x"`	1x enhancement
`ENHANCE_2X`	`"2x"`	2x enhancement

Error Handling

Basic Error Handling

from chaingpt.exceptions import ChainGPTError, APIError

async def safe_nft_generation():
    try:
        request = GenerateImageRequestModel(
            prompt="a dragon",
            model=NFTImageModel.VELOGEN,
            height=512,
            width=512
        )
        response = await client.nft.generate_image(request)
        return response

    except AuthenticationError:
        print("Invalid API key!")
    except ValidationError as e:
        print(f"Invalid request: {e.message}")
        if e.field:
            print(f"Problem with field: {e.field}")
    except InsufficientCreditsError:
        print("Not enough credits in your account")
    except RateLimitError as e:
        print(f"Rate limited. Retry after: {e.retry_after} seconds")
    except APIError as e:
        print(f"API error {e.status_code}: {e.message}")
    except ChainGPTError as e:
        print(f"General error: {e.message}")

Specific Error Scenarios

# Handle generation failures
async def robust_generation(collection_id: str):
    try:
        while True:
            progress = await client.nft.get_progress(collection_id)

            if progress.data.generated:
                return progress.data.images
            elif progress.statusCode >= 400:
                raise ChainGPTError("Generation failed")

            await asyncio.sleep(10)

    except ChainGPTError as e:
        print(f"Generation error: {e}")
        return None

Complete Example

Here's a comprehensive example showing the full NFT creation workflow:

import asyncio
import os
from chaingpt.client import ChainGPTClient
from chaingpt.models import *
from chaingpt.exceptions import ChainGPTError

async def complete_nft_workflow():
    """Complete NFT generation workflow from prompt to metadata."""

    # Initialize client
    client = ChainGPTClient(api_key=os.getenv("CHAINGPT_API_KEY"))

    try:
        # Step 1: Enhance the prompt
        print("1. Enhancing prompt...")
        enhance_request = EnhancePromptRequestModel(
            prompt="a mystical dragon guardian"
        )
        enhanced = await client.nft.enhance_prompt(enhance_request)
        enhanced_prompt = enhanced.data.enhancedPrompt
        print(f"Enhanced: {enhanced_prompt}")

        # Step 2: Generate a quick preview
        print("\n2. Generating preview...")
        preview_request = GenerateImageRequestModel(
            prompt=enhanced_prompt,
            model=NFTImageModel.VELOGEN,
            height=512,
            width=512,
            enhance=ImageEnhanceOption.ORIGINAL
        )
        preview = await client.nft.generate_image(preview_request)

        # Save preview
        with open("preview.jpg", "wb") as f:
            f.write(bytes(preview.data.data))
        print("Preview saved as preview.jpg")

        # Step 3: Queue high-quality NFT generation
        print("\n3. Queueing NFT generation...")
        nft_request = GenerateNFTQueueRequestModel(
            walletAddress="0x742d35Cc6635C0532925a3b8D8842A36fF20fd40",
            prompt=enhanced_prompt,
            model=NFTImageModel.NEBULA_FORGE_XL,
            height=1024,
            width=1024,
            steps=30,
            enhance=ImageEnhanceOption.ENHANCE_1X,
            chainId=56,  # BSC Mainnet
            amount=1,
            style="fantasy-art",
            traits=[
                TraitModel(
                    trait_type="Element",
                    value=[
                        TraitValueItemModel(value="fire", ratio=60),
                        TraitValueItemModel(value="ice", ratio=40)
                    ]
                )
            ]
        )

        queue_response = await client.nft.generate_nft_queue(nft_request)
        collection_id = queue_response.data.collectionId
        print(f"Queued with ID: {collection_id}")

        # Step 4: Track progress
        print("\n4. Tracking progress...")
        max_attempts = 20
        for attempt in range(max_attempts):
            progress = await client.nft.get_progress(collection_id)
            print(f"Attempt {attempt + 1}: Generated: {progress.data.generated} - Progress: {progress.data.progress}%")

            if progress.data.generated:
                print(f"Completed! IPFS URLs: {progress.data.images}")
                break

            await asyncio.sleep(15)
        else:
            raise ChainGPTError("Generation timeout")

        # Step 5: Generate metadata
        print("\n5. Generating metadata...")
        metadata_request = MintNFTRequestModel(
            collectionId=collection_id,
            name="Mystical Dragon Guardian #1",
            description="An AI-generated mystical dragon guardian, protector of ancient realms.",
            symbol="MDG",
            ids=[1]
        )

        metadata = await client.nft.mint_nft_metadata(metadata_request)
        print("Metadata generated:")
        print(f"  ID: {metadata.data._id}")
        print(f"  Name: {metadata.data.name or 'Not provided'}")
        print(f"  Image: {metadata.data.image or 'Not provided'}")
        print(f"  Attributes: {metadata.data.attributes or 'None'}")

        # Step 6: Get chain info for minting
        print("\n6. Getting chain information...")
        chains = await client.nft.get_chains(test_net=False)
        bsc_mainnet = next((c for c in chains.data.chains if c.chainId == 56), None)
        if bsc_mainnet:
            print(f"Target chain: {bsc_mainnet.chainName} (ID: {bsc_mainnet.chainId})")

        # Step 7: Get contract ABI
        print("\n7. Getting contract ABI...")
        abi_response = await client.nft.get_abi()
        print(f"Contract ABI received (first few elements): {abi_response.data[:2]}")

        print("\n✅ NFT workflow completed successfully!")
        return metadata.data

    except ChainGPTError as e:
        print(f"❌ Error: {e}")
        return None

    finally:
        await client.close()

# Run the complete workflow
if __name__ == "__main__":
    result = asyncio.run(complete_nft_workflow())

Best Practices

1. Resource Management

Always close the client when done:

async def proper_usage():
    client = ChainGPTClient(api_key="YOUR_API_KEY")
    try:
        # Your NFT operations here
        pass
    finally:
        await client.close()

# Or use async context manager if available
async with ChainGPTClient(api_key="YOUR_API_KEY") as client:
    # Operations here
    pass

2. Error Handling

Handle specific errors appropriately:

async def robust_operation():
    try:
        # Your operation
        pass
    except AuthenticationError:
        # Handle auth issues - check API key
        pass
    except InsufficientCreditsError:
        # Handle billing issues
        pass
    except RateLimitError as e:
        # Handle rate limiting - wait and retry
        await asyncio.sleep(e.retry_after or 60)
    except ValidationError as e:
        # Handle validation errors - fix request
        print(f"Fix field: {e.field}")

3. Progress Tracking

Use reasonable polling intervals:

async def track_with_backoff(collection_id: str):
    wait_time = 10  # Start with 10 seconds
    max_wait = 60   # Max 60 seconds between polls

    while True:
        progress = await client.nft.get_progress(collection_id)

        if progress.data.generated:
            return progress.data.images

        await asyncio.sleep(wait_time)
        wait_time = min(wait_time * 1.2, max_wait)  # Exponential backoff

4. Model Selection

Choose the right model for your use case:

# For quick previews and testing
preview_model = NFTImageModel.VELOGEN

# For final high-quality NFTs
production_model = NFTImageModel.NEBULA_FORGE_XL

# Adjust steps based on model and quality needs
quick_steps = 10      # For previews
quality_steps = 30    # For final NFTs

5. Prompt Engineering

Create effective prompts:

# Good prompt structure
prompt = "a majestic dragon, fantasy art, highly detailed, vibrant colors, mystical atmosphere"

# Use enhancement for better results
enhanced = await client.nft.enhance_prompt(
    EnhancePromptRequestModel(prompt=prompt)
)
final_prompt = enhanced.data.enhancedPrompt

New Features

Image-to-Image Generation

The NFT service now supports image-to-image generation, allowing you to create variations based on reference images:

from pydantic import HttpUrl

# Generate image based on a reference image
request = GenerateImageRequestModel(
    prompt="a dragon in space",
    model=NFTImageModel.VELOGEN,
    height=512,
    width=512,
    image=HttpUrl("https://example.com/reference-image.jpg"),
    isCharacterPreserve=True  # Preserve character features from reference
)

response = await client.nft.generate_image(request)

Character Preservation

When using image-to-image generation, you can preserve character features from the reference image:

# Preserve character features
request = GenerateImageRequestModel(
    prompt="a dragon in a cyberpunk city",
    model=NFTImageModel.NEBULA_FORGE_XL,
    height=1024,
    width=1024,
    image=HttpUrl("https://example.com/dragon-reference.jpg"),
    isCharacterPreserve=True  # Maintains dragon's appearance
)

Enhanced Traits System

The traits system has been enhanced with better support for NFT collections:

traits = [
    TraitModel(
        trait_type="Background",
        value=[
            TraitValueItemModel(value="night_sky", ratio=70),
            TraitValueItemModel(value="lava_pit", ratio=30)
        ]
    ),
    TraitModel(
        trait_type="Accessory",
        value=[
            TraitValueItemModel(value="crown", ratio=20),
            TraitValueItemModel(value="sword", ratio=40),
            TraitValueItemModel(value="none", ratio=40)
        ]
    )
]

Updated Chain Support

The chain information now includes more detailed network information:

chains = await client.nft.get_chains(test_net=False)
for chain in chains.data.chains:
    print(f"Chain: {chain.chainName}")
    print(f"  ID: {chain.chainId}")
    print(f"  Network: {chain.network}")
    print(f"  Type: {chain.networkType}")

Improved Response Structures

All API responses now follow a consistent structure with proper error handling:

# All responses include statusCode, message, and data
response = await client.nft.enhance_prompt(request)
if response.statusCode == 200:
    enhanced_prompt = response.data.enhancedPrompt
else:
    print(f"Error: {response.message}")

This ensures better error handling and consistent data access patterns across all NFT service methods.

View original source

Python

description: CGPT SDK Docs Python

Python

ChainGPT AI NFT Generator SDK Documentation

Table of Contents

Installation

Quick Start

SDK Initialization

Basic Initialization

Required Imports

NFT Service Overview

NFT Service Methods

enhance_prompt()

generate_image()

generate_nft_queue()

get_progress()

mint_nft_metadata()

get_chains()

get_abi()

Data Models & Types

TraitModel

Error Models

Enums Reference

NFTImageModel

ImageEnhanceOption

Error Handling

Basic Error Handling

Specific Error Scenarios

Complete Example

Best Practices

1. Resource Management

2. Error Handling

3. Progress Tracking

4. Model Selection

5. Prompt Engineering

New Features

Image-to-Image Generation

Character Preservation

Enhanced Traits System

Updated Chain Support

Improved Response Structures