Skip to content

AlisChain

SDK Documentation

AlisChain SDK Documentation¶

Overview¶

The AlisChain SDK provides easy-to-use interfaces for interacting with the AlisChain platform in multiple programming languages.

Python SDK¶

Installation¶

pip install alischain-sdk

Basic Usage¶

from alischain import AlisChainClient

# Initialize client
client = AlisChainClient('YOUR_API_KEY')

# Submit a claim
claim = client.submit_claim(
    text="This is a claim",
    sources=["https://source1.com"],
    category="news"
)

# Check claim status
status = client.get_claim_status(claim.id)

Advanced Features¶

Async Support¶

import asyncio
from alischain.async_client import AsyncAlisChainClient

async def process_claims():
    client = AsyncAlisChainClient('YOUR_API_KEY')

    # Submit multiple claims
    claims = await asyncio.gather(*[
        client.submit_claim(text=f"Claim {i}")
        for i in range(10)
    ])

    # Process results
    for claim in claims:
        print(f"Claim {claim.id}: {claim.status}")

asyncio.run(process_claims())

WebSocket Integration¶

from alischain import WebSocketClient

async def handle_updates(update):
    if update.type == 'claim_update':
        print(f"Claim {update.claim_id} status: {update.status}")
    elif update.type == 'verification_request':
        result = await process_verification(update.claim_id)
        await client.submit_verification(result)

client = WebSocketClient('YOUR_API_KEY')
client.subscribe(['claims', 'verifications'], callback=handle_updates)
client.connect()

Batch Operations¶

from alischain import AlisChainClient

client = AlisChainClient('YOUR_API_KEY')

# Batch claim submission
results = client.batch_submit_claims([
    {"text": "Claim 1", "sources": ["source1"]},
    {"text": "Claim 2", "sources": ["source2"]},
])

# Batch verification
verifications = client.batch_verify_claims([
    {"claim_id": "id1", "verdict": True},
    {"claim_id": "id2", "verdict": False},
])

JavaScript/TypeScript SDK¶

Installation¶

npm install @alischain/sdk

Basic Usage¶

import { AlisChain } from '@alischain/sdk';

// Initialize client
const client = new AlisChain('YOUR_API_KEY');

// Submit a claim
const claim = await client.claims.create({
    text: "This is a claim",
    sources: ["https://source1.com"],
    category: "news"
});

// Check status
const status = await client.claims.getStatus(claim.id);

Advanced Features¶

Real-time Updates¶

import { WebSocketClient } from '@alischain/sdk';

const ws = new WebSocketClient('YOUR_API_KEY');

ws.on('claim_update', (update) => {
    console.log('Claim update:', update);
});

ws.on('verification_request', async (request) => {
    const result = await processVerification(request);
    await ws.sendVerification(result);
});

ws.connect();

React Integration¶

import { useAlisChain } from '@alischain/react';

function ClaimComponent({ claimId }) {
    const { claim, loading, error } = useAlisChain(
        client => client.claims.get(claimId)
    );

    if (loading) return <Loading />;
    if (error) return <Error message={error.message} />;

    return <ClaimDisplay claim={claim} />;
}

Error Handling¶

import { AlisChainError } from '@alischain/sdk';

try {
    const claim = await client.claims.create({
        text: "Test claim"
    });
} catch (error) {
    if (error instanceof AlisChainError) {
        switch (error.code) {
            case 'rate_limit_exceeded':
                await sleep(1000);
                retry();
                break;
            case 'invalid_input':
                showValidationError(error.details);
                break;
            default:
                console.error('Unexpected error:', error);
        }
    }
}

Java SDK¶

Installation¶

<dependency>
    <groupId>com.alischain</groupId>
    <artifactId>alischain-sdk</artifactId>
    <version>1.0.0</version>
</dependency>

Basic Usage¶

import com.alischain.sdk.AlisChainClient;

// Initialize client
AlisChainClient client = new AlisChainClient("YOUR_API_KEY");

// Submit claim
Claim claim = client.claims()
    .create(new ClaimRequest.Builder()
        .text("This is a claim")
        .source("https://source1.com")
        .build());

// Check status
ClaimStatus status = client.claims().getStatus(claim.getId());

Advanced Features¶

Async Operations¶

import com.alischain.sdk.async.AsyncAlisChainClient;

AsyncAlisChainClient client = new AsyncAlisChainClient("YOUR_API_KEY");

CompletableFuture<Claim> futureResult = client.claims()
    .createAsync(new ClaimRequest.Builder()
        .text("Async claim")
        .build());

futureResult.thenAccept(claim -> {
    System.out.println("Claim created: " + claim.getId());
});

SDK Examples¶

Content Verification System¶

from alischain import AlisChainClient
import asyncio

class ContentVerifier:
    def __init__(self, api_key):
        self.client = AlisChainClient(api_key)

    async def verify_content(self, content):
        # Submit for verification
        claim = await self.client.submit_claim(
            text=content,
            category="content_verification"
        )

        # Wait for verification
        while True:
            status = await self.client.get_claim_status(claim.id)
            if status.is_final:
                return status.verified
            await asyncio.sleep(1)

Real-time Dashboard¶

import { WebSocketClient } from '@alischain/sdk';

class DashboardManager {
    constructor(apiKey) {
        this.ws = new WebSocketClient(apiKey);
        this.stats = {
            claims: 0,
            verifications: 0,
            accuracy: 0
        };
    }

    initialize() {
        this.ws.on('claim_update', this.handleClaimUpdate);
        this.ws.on('verification_update', this.handleVerification);
        this.ws.on('system_status', this.handleSystemStatus);

        this.ws.connect();
    }

    handleClaimUpdate(update) {
        this.stats.claims++;
        this.updateUI();
    }

    updateUI() {
        // Update dashboard UI
    }
}

Batch Processing System¶

import com.alischain.sdk.AlisChainClient;
import com.alischain.sdk.models.*;

public class BatchProcessor {
    private final AlisChainClient client;
    private final Queue<ClaimRequest> queue;

    public BatchProcessor(String apiKey) {
        this.client = new AlisChainClient(apiKey);
        this.queue = new ConcurrentLinkedQueue<>();
    }

    public void addToQueue(ClaimRequest request) {
        queue.add(request);
        if (queue.size() >= 100) {
            processBatch();
        }
    }

    private void processBatch() {
        List<ClaimRequest> batch = new ArrayList<>();
        for (int i = 0; i < 100 && !queue.isEmpty(); i++) {
            batch.add(queue.poll());
        }

        client.claims().batchCreate(batch)
            .thenAccept(this::handleResults);
    }
}

Last update: 2024-12-08