이름 붙은 룩

def parse_subject(value):
    """'dad' -> ('dad', None); 'dad:anime' -> ('dad', 'anime')."""
    subject, separator, look = value.partition(":")
    if not subject or (separator and not FRAME.fullmatch(look)):
        raise StudioError(f"Use a registered subject ID, optionally with a named look such as dad:anime, not {value!r}.")
    return subject, look or None

    async def profile(self, soul, actor=None):
        subject = (await self.subjects([soul], actor))[0]
        soul = subject["soul_pk"]
        profiles = await self.io("list", "profile", soul)
        record = profiles[0] if profiles else {"id": None, "parent": soul, "version": None, "mode": "default", "assets": []}
        record = {"appearance": "", "variants": {}, **record}
        if record["mode"] == "override":
            assets = await self.reference_assets(record["assets"], actor)
        else:
            default = next((s for s in await self.io("list", "set") if s["soul_pk"] == soul and s["channel"] == "standard" and s["name"] == "default"), None)
            id = (default or {}).get("published", {}).get("default")
            assets = [await self.asset(id, actor)] if id else []
        looks = {}
        for name, look in record["variants"].items():
            looks[name] = {"assets": look["assets"], "appearance": look.get("appearance"), "resolved": await self.reference_assets(look["assets"], actor)}
        return {**record, "display_name": subject.get("display_name") or soul, "variants": looks, "resolved": assets, "missing": not assets}

    @staticmethod
    def look_assets(profile, look):
        if look is None:
            return profile["resolved"]
        variant = profile["variants"].get(look)
        if variant is None:
            available = ", ".join(sorted(profile["variants"])) or "none"
            raise StudioError(f"{profile['display_name']} has no look named {look!r}. Saved looks: {available}.")
        return variant["resolved"]

    @staticmethod
    def look_rule(profile, look):
        text = ((profile["variants"].get(look) or {}).get("appearance") if look else None) or profile.get("appearance") or ""
        return f"{profile['display_name']}: {text.strip()}" if text.strip() else None

    async def resolve_references(self, subjects, ids, actor=None):
        """Ordered reference assets, the registry subjects they name, and the
        identity rules the depicted subjects carry."""
        specs = [parse_subject(value) for value in dict.fromkeys(subjects)]
        bare = list(dict.fromkeys(subject for subject, _ in specs))
        records = dict(zip(bare, await self.subjects(bare, actor)))
        refs, rules, profiles = [], [], {}
        for subject, look in specs:
            pk = records[subject]["soul_pk"]
            if pk not in profiles:
                profiles[pk] = await self.profile(pk, actor)
            profile = profiles[pk]
            assets = self.look_assets(profile, look)
            if not assets:
                raise StudioError(f"Choose a default reference for {profile['display_name']} first." if look is None else f"The look {look!r} for {profile['display_name']} has no images.")
            refs.extend(assets)
            rule = self.look_rule(profile, look)
            if rule and rule not in rules:
                rules.append(rule)
        refs.extend(await self.reference_assets(ids, actor))
        unique = list({a["id"]: a for a in refs}.values())
        ancestry_subjects = list({s for a in unique for s in a["subjects"]} | {r["soul_pk"] for r in records.values()})
        return unique, [s["soul_pk"] for s in await self.subjects(ancestry_subjects, actor)], rules