@@ -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"])
|
||||
Reference in New Issue
Block a user