Примеры кода

import requests

API_KEY = "YOUR_API_KEY"
BASE_URL = "https://api.humandata.ru/api/v1"

def clean_name(query: str) -> dict:
    response = requests.post(
        f"{BASE_URL}/clean/name",
        json={"query": query},
        headers={"Authorization": f"Token {API_KEY}"}
    )
    response.raise_for_status()
    return response.json()

# Использование
result = clean_name("иванов сергей петрович")
print(f"Фамилия: {result['result']['surname']}")
print(f"Имя: {result['result']['name']}")
print(f"Пол: {result['result']['gender']}")

import { useState, useEffect } from 'react';
import { useDebounce } from '@/hooks/useDebounce';

const API_KEY = "YOUR_API_KEY";

export function useNameSuggestions(query: string) {
  const [suggestions, setSuggestions] = useState<string[]>([]);
  const [isLoading, setIsLoading] = useState(false);
  const debouncedQuery = useDebounce(query, 300);

  useEffect(() => {
    if (debouncedQuery.length < 2) {
      setSuggestions([]);
      return;
    }

    const fetchSuggestions = async () => {
      setIsLoading(true);
      try {
        const response = await fetch(
          `https://api.humandata.ru/api/v1/suggest/name?query=${encodeURIComponent(debouncedQuery)}`,
          { headers: { Authorization: `Token ${API_KEY}` } }
        );
        const data = await response.json();
        setSuggestions(data.suggestions.map(s => s.value));
      } catch (error) {
        console.error('Failed to fetch suggestions:', error);
      } finally {
        setIsLoading(false);
      }
    };

    fetchSuggestions();
  }, [debouncedQuery]);

  return { suggestions, isLoading };
}

import requests
from concurrent.futures import ThreadPoolExecutor

API_KEY = "YOUR_API_KEY"
BASE_URL = "https://api.humandata.ru/api/v1"

def clean_name(query: str) -> dict:
    response = requests.post(
        f"{BASE_URL}/clean/name",
        json={"query": query},
        headers={"Authorization": f"Token {API_KEY}"}
    )
    return response.json()

def batch_clean_names(names: list[str], max_workers: int = 5) -> list[dict]:
    """Параллельная обработка списка ФИО."""
    with ThreadPoolExecutor(max_workers=max_workers) as executor:
        results = list(executor.map(clean_name, names))
    return results

# Использование
names = [
    "иванов сергей петрович",
    "петрова мария ивановна",
    "сидоров иван"
]

results = batch_clean_names(names)
for r in results:
    print(f"{r['source']} -> {r['result']['surname']} {r['result']['name']}")

import requests
import time
from functools import wraps

def retry_with_backoff(max_retries: int = 3, backoff_factor: float = 1.0):
    """Декоратор для retry с exponential backoff."""
    def decorator(func):
        @wraps(func)
        def wrapper(*args, **kwargs):
            for attempt in range(max_retries):
                try:
                    return func(*args, **kwargs)
                except requests.exceptions.RequestException as e:
                    if attempt == max_retries - 1:
                        raise
                    wait_time = backoff_factor * (2 ** attempt)
                    print(f"Attempt {attempt + 1} failed, retrying in {wait_time}s...")
                    time.sleep(wait_time)
        return wrapper
    return decorator

@retry_with_backoff(max_retries=3)
def clean_name_with_retry(query: str) -> dict:
    response = requests.post(
        f"{BASE_URL}/clean/name",
        json={"query": query},
        headers={"Authorization": f"Token {API_KEY}"},
        timeout=10
    )
    response.raise_for_status()
    return response.json()