Python SDK

from sha224 import sha224

# Hash a string (default encoding is utf-8)
text_hash = sha224("Hello, world!")
print(f"String hash: {text_hash}")

# Hash with different string encoding
utf16_hash = sha224("Hello, world!", encoding="utf-16")
print(f"UTF-16 string hash: {utf16_hash}")

# Hash bytes
bytes_hash = sha224(b"Hello, world!")
print(f"Bytes hash: {bytes_hash}")

# Hash bytearray
bytearray_hash = sha224(bytearray(b"Hello, world!"))
print(f"Bytearray hash: {bytearray_hash}")

# Hash integers converted to bytes
integer_bytes = (12345).to_bytes(4, byteorder="big")
int_hash = sha224(integer_bytes)
print(f"Integer hash: {int_hash}")

# Different output formats
hex_output = sha224("test", output_format="hex")
bytes_output = sha224("test", output_format="bytes")
base64_output = sha224("test", output_format="base64")

print(f"Hex output: {hex_output}")
print(f"Bytes output: {bytes_output}")
print(f"Base64 output: {base64_output}")

from sha224 import SHA224Hash

# Create a hasher instance
hasher = SHA224Hash()

# Update with different chunks of data
hasher.update("Part 1: ")
hasher.update("Part 2: ")
hasher.update(b"Binary part")  # Can mix string and binary updates

# Get the final hash
final_hash = hasher.hexdigest()
print(f"Incremental hash: {final_hash}")

# Clone a hasher at a specific point
hasher_clone = hasher.copy()
hasher.update(" Additional data")

print(f"Original hasher: {hasher.hexdigest()}")
print(f"Cloned hasher: {hasher_clone.hexdigest()}")

from sha224 import sha224

# Create a hash
data = "Important data to verify"
original_hash = sha224(data)
print(f"Original hash: {original_hash}")

# Later, verify the data hasn't been modified
is_valid = sha224.verify(original_hash, data)
print(f"Valid data: {is_valid}")  # True

# Verify modified data
modified_data = "Important data to verify!"
is_modified_valid = sha224.verify(original_hash, modified_data)
print(f"Valid modified data: {is_modified_valid}")  # False

# Comparing hashes correctly (constant-time comparison)
from sha224.utils import constant_time_compare

hash1 = sha224("data1")
hash2 = sha224("data2")
hash3 = sha224("data1")

print(constant_time_compare(hash1, hash2))  # False
print(constant_time_compare(hash1, hash3))  # True

File Hashing Examples

Hashing Files

from sha224 import sha224

# Hash a small file
small_file_hash = sha224.file("small_file.txt")
print(f"Small file hash: {small_file_hash}")

# Hash a large file with progress reporting
import os
from sha224 import SHA224Hash

def hash_large_file_with_progress(file_path, buffer_size=1048576):  # 1 MB chunks
    file_size = os.path.getsize(file_path)
    bytes_read = 0
    hasher = SHA224Hash()
    
    with open(file_path, "rb") as file:
        while True:
            data = file.read(buffer_size)
            if not data:
                break
                
            hasher.update(data)
            bytes_read += len(data)
            progress = bytes_read / file_size * 100
            print(f"Progress: {progress:.2f}%")
    
    return hasher.hexdigest()

large_file_hash = hash_large_file_with_progress("large_file.bin")
print(f"Large file hash: {large_file_hash}")

Directory Hashing

import os
from sha224 import sha224, SHA224Hash

def hash_directory(directory_path):
    """Compute a hash of all files in a directory (recursively)."""
    if not os.path.isdir(directory_path):
        raise ValueError(f"{directory_path} is not a directory")
        
    # Get all files sorted by path for consistency
    file_paths = []
    for root, _, files in os.walk(directory_path):
        for file in files:
            file_paths.append(os.path.join(root, file))
    file_paths.sort()
    
    # Create a master hasher
    master_hasher = SHA224Hash()
    
    # Hash each file and add its path and hash to the master hasher
    for file_path in file_paths:
        rel_path = os.path.relpath(file_path, directory_path)
        file_hash = sha224.file(file_path)
        
        # Add the relative path and hash to the master hash
        master_hasher.update(rel_path.encode('utf-8'))
        master_hasher.update(file_hash.encode('utf-8'))
        
        print(f"Hashed: {rel_path} - {file_hash}")
        
    return master_hasher.hexdigest()

# Hash a project directory
project_hash = hash_directory("./my_project")
print(f"Project hash: {project_hash}")

File Verification

from sha224 import sha224

# Create a hash of a file
original_file_hash = sha224.file("important_document.pdf")

# Save the hash somewhere
with open("important_document.pdf.sha224", "w") as f:
    f.write(original_file_hash)

# Later, verify the file hasn't been modified
def verify_file_integrity(file_path, hash_file_path):
    with open(hash_file_path, "r") as f:
        expected_hash = f.read().strip()
    
    is_valid = sha224.verify_file(expected_hash, file_path)
    return is_valid

# Check if the file is still valid
is_valid = verify_file_integrity(
    "important_document.pdf", 
    "important_document.pdf.sha224"
)

print(f"File integrity valid: {is_valid}")

API Client Examples

Basic API Usage

from sha224 import SHA224API

# Initialize the API client
api = SHA224API(api_key="YOUR_API_KEY")

# Hash text using the API
api_hash = api.hash_text("Hello, world!")
print(f"API hash: {api_hash}")

# Hash with custom encoding
api_hash_latin1 = api.hash_text("Café", encoding="latin-1")
print(f"API hash (latin-1): {api_hash_latin1}")

# Verify a hash
is_valid = api.verify(
    "8552d8b7a7dc5476cb9e25dee69a8091290764b7f2a64fe6e78e9568",
    "Hello, world!"
)
print(f"Hash verification: {is_valid}")  # True

Batch Operations

from sha224 import SHA224API

# Initialize the API client
api = SHA224API(api_key="YOUR_API_KEY")

# Batch hash multiple strings
items_to_hash = [
    {"id": "user1", "text": "Password123"},
    {"id": "user2", "text": "SecurePass456"},
    {"id": "user3", "text": "StrongPassword789"}
]

batch_results = api.batch_hash(items_to_hash)
print("Batch hash results:")
for item in batch_results["results"]:
    print(f"ID: {item['id']}, Hash: {item['hash']}")

# Later, verify multiple hashes at once
items_to_verify = [
    {
        "id": "user1", 
        "hash": batch_results["results"][0]["hash"],
        "text": "Password123"
    },
    {
        "id": "user2", 
        "hash": batch_results["results"][1]["hash"],
        "text": "WrongPassword"  # This one should fail
    },
    {
        "id": "user3", 
        "hash": batch_results["results"][2]["hash"],
        "text": "StrongPassword789"
    }
]

verify_results = api.batch_verify(items_to_verify)
print("\nBatch verify results:")
for item in verify_results["results"]:
    print(f"ID: {item['id']}, Valid: {item['valid']}")

Advanced API Configuration

from sha224 import SHA224API
import logging

# Configure logging
logging.basicConfig(level=logging.INFO)
logger = logging.getLogger("sha224.api")

# Create an API client with custom settings
api = SHA224API(
    api_key="YOUR_API_KEY",
    endpoint="https://api.sha224.com/v1",
    timeout=5,  # 5 seconds timeout
    retry_attempts=3,  # Retry up to 3 times
    verify_ssl=True  # Verify SSL certificates
)

# Hash with error handling
try:
    result = api.hash_text("Test text")
    print(f"Hash result: {result}")
except Exception as e:
    logger.error(f"API error: {e}")

# Using a proxy
import requests

session = requests.Session()
session.proxies = {
    "http": "http://proxy.example.com:8080",
    "https": "https://proxy.example.com:8080"
}

api_with_proxy = SHA224API(
    api_key="YOUR_API_KEY",
    session=session  # Pass custom session
)

proxy_result = api_with_proxy.hash_text("Proxied request")
print(f"Proxy result: {proxy_result}")

Async API Examples

Basic Async Usage

import asyncio
from sha224 import async_sha224

async def basic_async_example():
    # Hash a string asynchronously
    hash_value = await async_sha224.hash("Hello, world!")
    print(f"Async hash: {hash_value}")
    
    # Hash a file asynchronously
    file_hash = await async_sha224.file("document.pdf")
    print(f"Async file hash: {file_hash}")
    
    # Verify a hash asynchronously
    is_valid = await async_sha224.verify(
        "8552d8b7a7dc5476cb9e25dee69a8091290764b7f2a64fe6e78e9568",
        "Hello, world!"
    )
    print(f"Async verification: {is_valid}")

# Run the async function
asyncio.run(basic_async_example())

Async Incremental Hashing

import asyncio
from sha224 import async_sha224

async def incremental_async_example():
    # Create an async hasher
    hasher = async_sha224.AsyncSHA224Hash()
    
    # Update with data
    await hasher.update("First part")
    await hasher.update(" and second part")
    
    # Get the digest
    hash_value = await hasher.hexdigest()
    print(f"Async incremental hash: {hash_value}")
    
    # Clone and continue
    hasher_clone = await hasher.copy()
    await hasher.update(" and more data")
    
    hash_value = await hasher.hexdigest()
    clone_hash = await hasher_clone.hexdigest()
    
    print(f"Final hash: {hash_value}")
    print(f"Clone hash: {clone_hash}")

asyncio.run(incremental_async_example())

Async API Client

import asyncio
from sha224 import async_sha224

async def async_api_example():
    # Initialize the async API client
    api = async_sha224.AsyncSHA224API(api_key="YOUR_API_KEY")
    
    # Hash using the API
    hash_value = await api.hash_text("Hello, world!")
    print(f"Async API hash: {hash_value}")
    
    # Batch operations
    items_to_hash = [
        {"id": "item1", "text": "First item"},
        {"id": "item2", "text": "Second item"},
        {"id": "item3", "text": "Third item"}
    ]
    
    batch_results = await api.batch_hash(items_to_hash)
    print("Batch hash results:")
    for item in batch_results["results"]:
        print(f"ID: {item['id']}, Hash: {item['hash']}")

asyncio.run(async_api_example())

Parallel Async Processing

import asyncio
import os
from sha224 import async_sha224

async def hash_file_task(file_path):
    file_hash = await async_sha224.file(file_path)
    return {"path": file_path, "hash": file_hash}

async def parallel_file_hashing(directory):
    """Hash all files in a directory in parallel."""
    file_paths = []
    for root, _, files in os.walk(directory):
        for file in files:
            file_paths.append(os.path.join(root, file))
    
    # Process all files in parallel
    tasks = [hash_file_task(file_path) for file_path in file_paths]
    results = await asyncio.gather(*tasks)
    
    # Sort by file path for consistent output
    results.sort(key=lambda x: x["path"])
    return results

async def main():
    print("Starting parallel file hashing...")
    results = await parallel_file_hashing("./project_directory")
    
    print(f"Processed {len(results)} files:")
    for result in results:
        print(f"{result['path']}: {result['hash']}")

asyncio.run(main())