Zo doen wijdat in oost
DevPlace CI / test (push) Failing after 3m13s

This commit is contained in:
2026-10-16 07:20:44 +02:00
parent 25d9cb1c7d
commit 6f80a820da
229 changed files with 23894 additions and 74 deletions
+194
View File
@@ -0,0 +1,194 @@
# retoor <retoor@molodetz.nl>
from __future__ import annotations
import asyncio
import hashlib
import json
import logging
import random
import re
from devplacepy.database.sync import (
claim_identity,
identity_by_source,
identity_map,
identity_name_taken,
save_style_samples,
username_taken,
)
from devplacepy.services.sync import ai
from devplacepy.services.sync.normalize import ORIGIN_UID_PATTERN
from devplacepy.services.sync.spec import ALIAS, LIMITS
from devplacepy.services.sync.style import Style, plausible
logger = logging.getLogger("sync.identity")
SYLLABLES = (
"ka", "ro", "vi", "te", "mu", "sa", "lo", "ne", "di", "po", "ra", "ke", "zu", "mi", "to", "la",
"ve", "no", "ba", "ri", "so", "ta", "ni", "ku", "me", "fa", "li", "do", "re", "gu",
)
NAME_SYSTEM = (
"You invent a replacement username for a member of a developer forum. Reply with JSON only: "
'{"username": "<name>"}. Match the style notes exactly: the casing pattern, a length within 2 '
"characters, whether it contains a digit, and the separator character. Use only letters, digits, "
"underscore and hyphen. The name must look like a real person's handle, must not contain words such "
"as user or bot, and must not be any name from the forbidden list."
)
FENCE = re.compile(r"^```(?:json)?\s*|\s*```$", re.I)
def source_key(name: str) -> str | None:
key = str(name or "").strip().lower()
if not key or len(key) > LIMITS.max_origin_uid_length or not ORIGIN_UID_PATTERN.match(key):
return None
return key
def fallback_name(origin: str, source: str, style: Style, attempt: int) -> str:
rng = random.Random(hashlib.sha256(f"{origin}:{source.lower()}:{attempt}".encode()).digest())
target = max(ALIAS.min_name_length, style.length - (2 if style.has_digit else 0))
separator = style.separator
parts: list[str] = []
while len("".join(parts)) + len(separator) * max(len(parts) - 1, 0) < target:
parts.append("".join(rng.choice(SYLLABLES) for _ in range(rng.choice((1, 2)))))
if separator and len(parts) == 2:
break
name = separator.join(parts)
if style.has_digit:
name += str(rng.randrange(10, 100))
name = name[: ALIAS.max_name_length]
if style.casing == "upper":
return name.upper()
if style.casing == "title":
return name.capitalize()
if style.casing == "mixed" and len(name) > 2:
return name[:2] + name[2:].capitalize()
return name
class NameGenerator:
async def generate(self, origin: str, source: str, style: Style, forbidden: list[str]) -> tuple[str, bool] | None:
for _ in range(ALIAS.name_attempts):
reply = await ai.complete(
NAME_SYSTEM,
json.dumps({"style": style.describe(), "forbidden": forbidden[-50:]}),
ALIAS.name_timeout_seconds,
)
candidate = self.parse(reply)
if candidate and plausible(candidate, source, style) and candidate not in forbidden:
return candidate, True
if reply is None:
break
for attempt in range(ALIAS.fallback_attempts):
candidate = fallback_name(origin, source, style, attempt)
if plausible(candidate, source, style) and candidate not in forbidden:
return candidate, False
return None
@staticmethod
def parse(reply: str | None) -> str | None:
if not reply:
return None
cleaned = FENCE.sub("", reply.strip())
start, end = cleaned.find("{"), cleaned.rfind("}")
try:
value = json.loads(cleaned[start : end + 1])["username"]
except (ValueError, KeyError, TypeError):
return None
return value.strip() if isinstance(value, str) else None
class IdentityResolver:
def __init__(self, origin: str, *, persist: bool = True, generator: NameGenerator | None = None, cap: int = ALIAS.max_new_identities_per_run):
self.origin = origin
self.persist = persist
self.generator = generator or NameGenerator()
self.cap = cap
self.created = 0
self.rows: dict[str, dict] = identity_map(origin)
self.projected: dict[str, str] = {}
self.lock = asyncio.Lock()
def mapping(self) -> dict[str, str]:
return {key: row["our_name"] for key, row in self.rows.items()} | self.projected
def known(self, name: str) -> str | None:
key = source_key(name)
if key is None:
return None
if key in self.rows:
return self.rows[key]["our_name"]
return self.projected.get(key)
def taken(self, candidate: str) -> bool:
lowered = candidate.lower()
return (
identity_name_taken(lowered)
or username_taken(candidate)
or lowered in {name.lower() for name in self.projected.values()}
)
async def ensure(self, name: str) -> str | None:
key = source_key(name)
if key is None:
return None
existing = self.known(name)
if existing:
return existing
async with self.lock:
existing = self.known(name)
if existing:
return existing
if self.created >= self.cap:
logger.warning("identity cap of %d new identities reached", self.cap)
return None
return await self.create(name, key)
async def create(self, name: str, key: str) -> str | None:
style = Style.of(name)
forbidden: list[str] = []
for _ in range(ALIAS.name_attempts + 1):
generated = await self.generator.generate(self.origin, name, style, forbidden)
if generated is None:
return None
candidate, by_ai = generated
if self.taken(candidate):
forbidden.append(candidate)
continue
self.created += 1
if not self.persist:
self.projected[key] = candidate
return candidate
if claim_identity(self.origin, name, key, candidate, style.dump(), by_ai):
self.rows[key] = identity_by_source(self.origin, key)
logger.info("identity created for %s (ai=%s)", self.origin, by_ai)
return candidate
winner = identity_by_source(self.origin, key)
if winner:
self.rows[key] = winner
return winner["our_name"]
forbidden.append(candidate)
return None
def samples(self, name: str) -> list[str]:
key = source_key(name)
row = self.rows.get(key) if key else None
try:
return list(json.loads(row["style_samples"])) if row and row.get("style_samples") else []
except ValueError:
return []
def remember(self, name: str, text: str) -> None:
key = source_key(name)
row = self.rows.get(key) if key else None
sample = " ".join((text or "").split())[: ALIAS.sample_chars]
if not self.persist or row is None or not sample:
return
kept = self.samples(name)
if len(kept) >= ALIAS.samples_kept or sample in kept:
return
kept.append(sample)
row["style_samples"] = json.dumps(kept, ensure_ascii=False)
save_style_samples(row["uid"], row["style_samples"])