SHA-224 Client SDKs

# Using the Python SDK
from sha224_sdk import SHA224Client

# Initialize the client
client = SHA224Client(
    api_key="YOUR_API_KEY",  # Optional, for API mode
    mode="auto"  # 'local', 'api', or 'auto' (default)
)

# Generate a hash
def generate_hash():
    try:
        # String input
        text_hash = client.hash("Hello, world!")
        print(f"Text hash: {text_hash}")
        
        # Binary input (file, bytes, etc.)
        with open("example.pdf", "rb") as f:
            file_data = f.read()
            file_hash = client.hash_bytes(file_data)
        print(f"File hash: {file_hash}")
        
        # File path input
        file_path_hash = client.hash_file("example.pdf")
        print(f"File path hash: {file_path_hash}")
        
        # Verify a hash
        is_valid = client.verify("Hello, world!", text_hash)
        print(f"Verification result: {is_valid}")
    except Exception as e:
        print(f"Error: {e}")

# Async version
import asyncio

async def generate_hash_async():
    # String input
    text_hash = await client.hash_async("Hello, world!")
    print(f"Async text hash: {text_hash}")

generate_hash()
asyncio.run(generate_hash_async())

// Using the Java SDK
import com.sha224.sdk.SHA224Client;
import com.sha224.sdk.SHA224Config;
import com.sha224.sdk.exception.SHA224Exception;

import java.io.File;
import java.io.IOException;
import java.nio.file.Files;
import java.nio.file.Paths;

public class SHA224Example {
    public static void main(String[] args) {
        // Initialize the client
        SHA224Config config = new SHA224Config.Builder()
            .apiKey("YOUR_API_KEY") // Optional, for API mode
            .mode(SHA224Config.Mode.AUTO) // LOCAL, API, or AUTO (default)
            .build();
            
        SHA224Client client = new SHA224Client(config);
        
        try {
            // String input
            String textHash = client.hash("Hello, world!");
            System.out.println("Text hash: " + textHash);
            
            // Binary input (byte array)
            byte[] fileData = Files.readAllBytes(Paths.get("example.pdf"));
            String fileHash = client.hash(fileData);
            System.out.println("File hash: " + fileHash);
            
            // File input
            File file = new File("example.pdf");
            String filePathHash = client.hashFile(file);
            System.out.println("File path hash: " + filePathHash);
            
            // Verify a hash
            boolean isValid = client.verify("Hello, world!", textHash);
            System.out.println("Verification result: " + isValid);
            
            // Async version
            client.hashAsync("Hello, world!")
                .thenAccept(hash -> System.out.println("Async text hash: " + hash))
                .exceptionally(ex -> {
                    System.err.println("Error: " + ex.getMessage());
                    return null;
                });
                
        } catch (SHA224Exception | IOException e) {
            System.err.println("Error: " + e.getMessage());
        }
    }
}

// Using the Go SDK
package main

import (
	"context"
	"fmt"
	"io/ioutil"
	"log"
	
	"github.com/sha224/go-sdk"
)

func main() {
	// Initialize the client
	config := sha224.Config{
		APIKey: "YOUR_API_KEY", // Optional, for API mode
		Mode:   sha224.ModeAuto, // ModeLocal, ModeAPI, or ModeAuto (default)
	}
	
	client, err := sha224.NewClient(config)
	if err != nil {
		log.Fatalf("Failed to create client: %v", err)
	}
	
	// Create context
	ctx := context.Background()
	
	// String input
	textHash, err := client.Hash(ctx, "Hello, world!")
	if err != nil {
		log.Fatalf("Failed to generate hash: %v", err)
	}
	fmt.Printf("Text hash: %s\n", textHash)
	
	// Binary input (byte slice)
	fileData, err := ioutil.ReadFile("example.pdf")
	if err != nil {
		log.Fatalf("Failed to read file: %v", err)
	}
	
	fileHash, err := client.HashBytes(ctx, fileData)
	if err != nil {
		log.Fatalf("Failed to generate file hash: %v", err)
	}
	fmt.Printf("File hash: %s\n", fileHash)
	
	// File path input
	filePathHash, err := client.HashFile(ctx, "example.pdf")
	if err != nil {
		log.Fatalf("Failed to generate file path hash: %v", err)
	}
	fmt.Printf("File path hash: %s\n", filePathHash)
	
	// Verify a hash
	isValid, err := client.Verify(ctx, "Hello, world!", textHash)
	if err != nil {
		log.Fatalf("Failed to verify hash: %v", err)
	}
	fmt.Printf("Verification result: %v\n", isValid)
}