File size: 4,625 Bytes
713f736
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
"""The Space's spending and fairness limits (DEC-32 §5, §7). All in memory: a restart or a sleep resets them, so the
hard cap is the Anthropic workspace's monthly limit, which Parsa sets. These are the soft ones in front of it.

- `RateLimiter`: live runs per visitor per hour and per day. A visitor is a salted hash of the client address, kept
  only in memory and never logged.
- `SpendCap`: estimated spend per UTC day; a run is admitted only if the cap leaves room for a cold run's estimate.
- `Slots`: at most N live runs at once; the next one falls back at once instead of waiting.
- `ResultCache`: finished live runs by input hash, so a repeat costs nothing.
Every class takes a `clock` (seconds) so the tests can move time.
"""

import hashlib
import os
import threading
import time
from collections import OrderedDict, deque

PER_HOUR = 3
PER_DAY = 10
DAILY_CAP_USD = 1.00          # DEC-32 §7 (Parsa: fewer than 20 live runs expected); a Space variable can change it
COLD_RUN_ESTIMATE_USD = 0.16  # EXP-64 (the dummy): cold runs cost $0.10 and $0.15, warm $0.05-0.08; reserve the dearest
MAX_CONCURRENT = 3
CACHE_SIZE = 500


def visitor_id(address, salt=None):
    """A salted hash of the client address: enough to count runs, useless to identify anyone."""
    salt = salt if salt is not None else os.environ.get("SPACE_SIGNING_SECRET", "local")
    return hashlib.sha256(f"{salt}:{address}".encode()).hexdigest()[:16]


class RateLimiter:
    def __init__(self, per_hour=PER_HOUR, per_day=PER_DAY, clock=time.time):
        self.per_hour, self.per_day, self.clock = per_hour, per_day, clock
        self._runs = {}
        self._lock = threading.Lock()

    def _recent(self, visitor, now):
        runs = self._runs.setdefault(visitor, deque())
        while runs and now - runs[0] > 86400:
            runs.popleft()
        return runs

    def allow(self, visitor):
        """(allowed, reason). Records the run when allowed."""
        with self._lock:
            now = self.clock()
            runs = self._recent(visitor, now)
            if sum(now - t <= 3600 for t in runs) >= self.per_hour:
                return False, f"you have used your {self.per_hour} live runs for this hour"
            if len(runs) >= self.per_day:
                return False, f"you have used your {self.per_day} live runs for today"
            runs.append(now)
            return True, ""


class SpendCap:
    def __init__(self, cap_usd=DAILY_CAP_USD, run_estimate_usd=COLD_RUN_ESTIMATE_USD, clock=time.time):
        self.cap, self.estimate, self.clock = float(cap_usd), float(run_estimate_usd), clock
        self._day, self.spent, self.reserved = None, 0.0, 0.0
        self._lock = threading.Lock()

    def _roll(self):
        day = int(self.clock() // 86400)
        if day != self._day:
            self._day, self.spent, self.reserved = day, 0.0, 0.0

    def reserve(self):
        """Hold a cold run's estimate. (allowed, reason)."""
        with self._lock:
            self._roll()
            if self.spent + self.reserved + self.estimate > self.cap:
                return False, "today's budget for live runs is used up"
            self.reserved += self.estimate
            return True, ""

    def settle(self, actual_usd):
        """Replace a reservation with what the run actually cost (0 for a run that made no call)."""
        with self._lock:
            self._roll()
            self.reserved = max(0.0, self.reserved - self.estimate)
            self.spent += max(0.0, float(actual_usd or 0.0))

    def status(self):
        with self._lock:
            self._roll()
            return {"spent_today_usd": round(self.spent, 4), "cap_usd": self.cap, "reserved_usd": round(self.reserved, 4)}


class Slots:
    def __init__(self, n=MAX_CONCURRENT):
        self._sem = threading.BoundedSemaphore(n)
        self.n = n

    def try_acquire(self):
        return self._sem.acquire(blocking=False)

    def release(self):
        self._sem.release()


class ResultCache:
    def __init__(self, size=CACHE_SIZE):
        self.size = size
        self._items = OrderedDict()
        self._lock = threading.Lock()

    def get(self, key):
        with self._lock:
            if key in self._items:
                self._items.move_to_end(key)
                return self._items[key]
            return None

    def put(self, key, value):
        with self._lock:
            self._items[key] = value
            self._items.move_to_end(key)
            while len(self._items) > self.size:
                self._items.popitem(last=False)

    def __len__(self):
        return len(self._items)