Чтобы забрать подарки:

1. Подпишись на всех экспертов из папки
2. Перейди в закрытый канал с названием «ПОДАРКИ»

// Room (Android) — локальное хранилище
@Entity(tableName = "orders")
data class Order(
    @PrimaryKey val id: String,
    val address: String,
    val status: String,
    val synced: Boolean = false
)

@Dao
interface OrderDao {
    @Insert
    suspend fun insert(order: Order)

    @Query("SELECT * FROM orders WHERE synced = 0")
    suspend fun getUnsyncedOrders(): List<Order>

    @Update
    suspend fun update(order: Order)
}

// Менеджер синхронизации
class SyncManager(private val dao: OrderDao, private val api: ApiService) {
    suspend fun sync() {
        val unsynced = dao.getUnsyncedOrders()
        unsynced.forEach { order ->
            try {
                api.sendOrder(order)
                dao.update(order.copy(synced = true))
            } catch (e: Exception) {
                // Оставляем synced = false для следующей попытки
            }
        }
    }
}

import time
from threading import Lock

class CircuitBreaker:
    def __init__(self, failure_threshold=5, timeout=30):
        self.failure_threshold = failure_threshold
        self.timeout = timeout
        self.failures = 0
        self.last_failure_time = 0
        self.state = "CLOSED"  # CLOSED, OPEN, HALF_OPEN
        self.lock = Lock()

    def call(self, func, fallback):
        with self.lock:
            if self.state == "OPEN":
                if time.time() - self.last_failure_time > self.timeout:
                    self.state = "HALF_OPEN"
                else:
                    return fallback()

        try:
            result = func()
            if self.state == "HALF_OPEN":
                self.state = "CLOSED"
                self.failures = 0
            return result
        except Exception:
            with self.lock:
                self.failures += 1
                self.last_failure_time = time.time()
                if self.failures >= self.failure_threshold:
                    self.state = "OPEN"
            return fallback()

# Использование
cb = CircuitBreaker(failure_threshold=3, timeout=15)

def risky_payment():
    # вызов внешнего API
    response = requests.post("https://payment-gateway/pay", timeout=5)
    response.raise_for_status()
    return response.json()

def fallback_payment():
    return {"status": "pending", "message": "Сервис временно недоступен, повторите позже"}

result = cb.call(risky_payment, fallback_payment)

import time
from threading import Lock

class CircuitBreaker:
    def __init__(self, failure_threshold=5, timeout=30):
        self.failure_threshold = failure_threshold
        self.timeout = timeout
        self.failures = 0
        self.last_failure_time = 0
        self.state = "CLOSED"  # CLOSED, OPEN, HALF_OPEN
        self.lock = Lock()

    def call(self, func, fallback):
        with self.lock:
            if self.state == "OPEN":
                if time.time() - self.last_failure_time > self.timeout:
                    self.state = "HALF_OPEN"
                else:
                    return fallback()

        try:
            result = func()
            if self.state == "HALF_OPEN":
                self.state = "CLOSED"
                self.failures = 0
            return result
        except Exception:
            with self.lock:
                self.failures += 1
                self.last_failure_time = time.time()
                if self.failures >= self.failure_threshold:
                    self.state = "OPEN"
            return fallback()

# Использование
cb = CircuitBreaker(failure_threshold=3, timeout=15)

def risky_payment():
    # вызов внешнего API
    response = requests.post("https://payment-gateway/pay", timeout=5)
    response.raise_for_status()
    return response.json()

def fallback_payment():
    return {"status": "pending", "message": "Сервис временно недоступен, повторите позже"}

result = cb.call(risky_payment, fallback_payment)