三家店都叫“青禾茶铺”，助手该填哪个商户 ID？

"""Offline name-to-resource workflow using fictional shops and fixed inputs."""
from dataclasses import dataclass, replace
import re
from uuid import uuid4


PREFIX = "//directory.example/regions/jp/shops/"
FIELDS = ("city", "branch")


def key(text):
    if not isinstance(text, str) or not text.strip():
        raise ValueError("a non-blank string is required")
    # Local matching policy only: strip outer spaces and fold letter case.
    return text.strip().casefold()


@dataclass(frozen=True)
class Shop:
    resource: str
    display_name: str
    city: str
    branch: str
    address: str
    hours: str
    aliases: tuple = ()


@dataclass(frozen=True)
class View:
    token: str
    label: str
    candidates: tuple
    clues: tuple
    status: str
    evidence: tuple


class StaleChoice(Exception):
    pass


class InvalidChoice(Exception):
    pass


class Resolver:
    def __init__(self, catalog):
        self.catalog = tuple(catalog)
        self.by_id = {}
        for shop in self.catalog:
            if not re.fullmatch(re.escape(PREFIX) + r"[a-z0-9-]+", shop.resource):
                raise ValueError("resource must include this source, region and shop type")
            if shop.resource in self.by_id:
                raise ValueError("duplicate canonical resource")
            self.by_id[shop.resource] = shop
        self.serial = 0
        self.session = uuid4().hex
        self.current = None
        self.detail_reads = []

    def publish(self, label, candidates, clues, evidence):
        self.serial += 1
        status = "not_found" if not candidates else "resolved" if len(candidates) == 1 else "ambiguous"
        self.current = View(f"{self.session}:{self.serial}", label, tuple(candidates), tuple(clues), status, tuple(evidence))
        return self.current

    def checked(self, token):
        if self.current is None or token != self.current.token:
            raise StaleChoice("this choice belongs to a different candidate view")
        return self.current

    def start(self, label):
        normalized = key(label)
        candidates = [shop for shop in self.catalog
                      if any(normalized == key(name) for name in (shop.display_name,) + shop.aliases)]
        return self.publish(label, candidates, (), ("exact display-name or declared-alias match",))

    def question(self, token):
        view = self.checked(token)
        if view.status != "ambiguous":
            return None
        # Ask the first understandable field that actually distinguishes rows.
        for field in FIELDS:
            values = tuple(dict.fromkeys(getattr(shop, field) for shop in view.candidates))
            if len({key(value) for value in values}) > 1:
                return {"view_token": token, "field": field, "values": values}
        return {"view_token": token, "field": "candidate", "values": tuple(
            (shop.resource, shop.display_name, shop.city, shop.branch, shop.address)
            for shop in view.candidates)}

    def refine(self, token, field, value):
        view = self.checked(token)
        if view.status != "ambiguous" or field not in FIELDS:
            raise InvalidChoice("refinement needs an ambiguous view and a supported field")
        normalized = key(value)
        candidates = tuple(shop for shop in view.candidates if key(getattr(shop, field)) == normalized)
        if len(candidates) == len(view.candidates):
            raise InvalidChoice("this information does not narrow the current candidates")
        return self.publish(view.label, candidates, view.clues + ((field, value),),
                            view.evidence + (f"filter {field}: {len(view.candidates)} -> {len(candidates)}",))

    def choose(self, token, resource):
        view = self.checked(token)
        matches = tuple(shop for shop in view.candidates if shop.resource == resource)
        if len(matches) != 1:
            raise InvalidChoice("resource is not one of the current candidates")
        return self.publish(view.label, matches, view.clues,
                            view.evidence + ("explicit choice from current candidate IDs",))

    def details(self, token):
        view = self.checked(token)
        if view.status != "resolved":
            raise InvalidChoice("resolve the shop before reading its details")
        resource = view.candidates[0].resource
        self.detail_reads.append(resource)
        shop = self.by_id[resource]  # Canonical lookup; never search again by display name.
        return {"resource": resource, "display_name": shop.display_name,
                "city": shop.city, "branch": shop.branch, "address": shop.address, "hours": shop.hours}


CATALOG = (
    Shop(PREFIX + "t1", "青禾茶铺", "东京", "车站店", "示例街 1 号", "09:00-18:00", ("青禾",)),
    Shop(PREFIX + "t2", "青禾茶铺", "东京", "大学店", "示例街 2 号", "10:00-19:00", ("青禾",)),
    Shop(PREFIX + "t3", "青禾茶铺", "京都", "车站店", "样本路 3 号", "11:00-18:00", ("青禾",)),
    Shop(PREFIX + "c1", "纸船咖啡", "东京", "公园店", "样本路 4 号", "08:00-17:00"),
)


def expect(exception, action):
    try:
        action()
    except exception:
        return
    raise AssertionError(f"expected {exception.__name__}")


def main():
    resolver = Resolver(CATALOG)
    # A name-keyed dict silently loses two distinct shops.
    bad_index = {shop.display_name: shop for shop in CATALOG}
    assert len(CATALOG) == 4 and len(bad_index) == 2
    print("name-keyed index: 4 resources become 2 entries")

    initial = resolver.start("青禾茶铺")
    assert initial.status == "ambiguous" and len(initial.candidates) == 3
    assert resolver.question(initial.token)["field"] == "city"
    expect(InvalidChoice, lambda: resolver.details(initial.token))
    assert resolver.detail_reads == []
    print("name lookup: ambiguous; candidates=3; next=city")

    city = resolver.refine(initial.token, "city", "东京")
    assert len(city.candidates) == 2 and resolver.question(city.token)["field"] == "branch"
    expect(InvalidChoice, lambda: resolver.refine(city.token, "city", "东京"))
    assert resolver.current == city
    print("city clue: ambiguous; candidates=2; next=branch")

    resolved = resolver.refine(city.token, "branch", "大学店")
    detail = resolver.details(resolved.token)
    assert resolved.status == "resolved" and detail["resource"] == PREFIX + "t2"
    assert detail["branch"] == "大学店" and detail["hours"] == "10:00-19:00"
    print("branch clue: resolved; resource=" + detail["resource"])
    print("detail lookup: branch and opening-hours assertions passed")

    old = resolver.start("青禾茶铺")
    current = resolver.start("青禾")  # Same candidate IDs, a new conversation state.
    assert old.candidates == current.candidates
    expect(StaleChoice, lambda: resolver.choose(old.token, PREFIX + "t1"))
    other_session = Resolver(CATALOG)
    other_view = other_session.start("青禾")
    expect(StaleChoice, lambda: resolver.choose(other_view.token, PREFIX + "t1"))
    assert resolver.current == current
    print("old view with still-matching ID: rejected as stale")
    expect(InvalidChoice, lambda: resolver.choose(current.token, PREFIX + "c1"))
    expect(InvalidChoice, lambda: resolver.choose(current.token, "t1"))
    expect(InvalidChoice, lambda: resolver.choose(current.token, "//other.example/regions/jp/shops/t1"))
    chosen = resolver.choose(current.token, PREFIX + "t3")
    assert resolver.details(chosen.token)["city"] == "京都"
    print("explicit current choice: resolved; resource=" + chosen.candidates[0].resource)

    initial = resolver.start("青禾茶铺")
    missing = resolver.refine(initial.token, "city", "大阪")
    assert missing.status == "not_found" and missing.candidates == ()
    expect(InvalidChoice, lambda: resolver.details(missing.token))
    expect(StaleChoice, lambda: resolver.choose(initial.token, PREFIX + "t1"))
    print("unmatched clue: not_found; no fallback to a previous shop")

    unknown = resolver.start("目录里没有的名字")
    assert unknown.status == "not_found" and resolver.question(unknown.token) is None
    alias = Resolver((replace(CATALOG[0], display_name="青禾新名", aliases=("青禾茶铺",)),))
    renamed = alias.start("青禾茶铺")
    assert alias.details(renamed.token)["resource"] == PREFIX + "t1"
    expect(ValueError, lambda: Resolver((CATALOG[0], CATALOG[0])))
    expect(ValueError, lambda: Resolver((replace(CATALOG[0], resource="t1"),)))
    expect(ValueError, lambda: resolver.start("   "))
    # If both supported fields are equal, do not ask a useless city/branch question.
    identical_labels = Resolver((CATALOG[0], replace(CATALOG[0], resource=PREFIX + "t9")))
    view = identical_labels.start("青禾茶铺")
    assert identical_labels.question(view.token)["field"] == "candidate"
    print("PASS: identity, strict narrowing, scoped IDs, stale-choice rejection")


if __name__ == "__main__":
    main()