👨‍💻 dev new chatter skill

[fukurou]

stub:

class DiChatter(Skill):
    def __init__(self):
        super().__init__()
        self.set_skill_type(2)
        self.faucet: DailyEngager = DailyEngager(span=10, times=3)

    def input(self, ear: str, skin: str, eye: str):
        if ear in ("stop", "shut up", "quiet"):
            self.faucet.stop()
            return
        if self.faucet.poll(ear in ("hey", "lets talk")):
            self.setSimpleAlg("yo")

    def skillNotes(self, param: str) -> str:
        if param == "notes":
            return "toggle chatter, one DailyEngager window per trigger (10 min, 3 per day)"
        if param == "triggers":
            return "on: hey / lets talk. off: stop / shut up / quiet"
        return "note unavailable"

 

[fukurou]

new railpunk:

class RailPunk:
    def __init__(self, limit=5, db: AbsDictionaryDB | None = None):
        self.ec = EventChatV2(limit)
        self.context = "stand by"
        self.db: AbsDictionaryDB | None = db
        self.eliza_wrapper: ElizaDBWrapper | None = ElizaDBWrapper() if db is not None else None
        self.funcs: dict[str, PopulatorFunc] = {}
        self.add_populator(KeysFunnel())
        self.removables: set[str] = Tokenizer.exclusions
        self.skip = False

    def add_populator(self, func: PopulatorFunc):
        if len(func.regex) > 0:
            self.funcs[func.regex] = func

    def _populate(self, str1: str):
        for func in self.funcs.values():
            func.populate(self, str1)

    def set_context(self, context):
        if not context:
            return
        self.context = context

    def _lookup(self, key: str, latest: bool) -> str:
        if self.eliza_wrapper is None:
            return self.ec.response_latest(key) if latest else self.ec.response(key)
        if latest:
            return self.eliza_wrapper.respond_latest(key, self.ec, self.db)
        return self.eliza_wrapper.respond(key, self.ec, self.db)

    def _respond_monolog(self, ear):
        if not ear:
            return ""
        temp = self._lookup(ear, False)
        if temp:
            self.context = temp
        return temp

    def learn(self, ear):
        if not ear or ear == self.context:
            return
        self._populate(ear)
        self.ec.add_key_value(self.context, ear)
        self.context = ear

    def monolog(self):
        if self.skip:
            self._respond_monolog(self.context)
            self.skip = False
        return self._respond_monolog(self.context)

    def respond_dialog(self, ear):
        self.skip = True
        result = self._lookup(ear, False)
        if result:
            return result
        return self._lookup(Tokenizer.canonical_key(ear, self.removables), False)

    def respond_latest(self, ear):
        self.skip = True
        result = self._lookup(ear, True)
        if result:
            return result
        return self._lookup(Tokenizer.canonical_key(ear, self.removables), True)

    def learn_key_value(self, context, reply):
        self.ec.add_key_value(context, reply)

    def feed_key_value_pairs(self, kv_list: list[AXKeyValuePair]):
        if not kv_list:
            return
        for kv in kv_list:
            self.learn_key_value(kv.get_key(), kv.get_value())

    def save_learned_data(self):
        if self.eliza_wrapper is None:
            return
        self.eliza_wrapper.sleep_n_save(self.ec, self.db)

    def clear(self):
        """Wipe in-memory state, and DB-backed state if this instance has a DB."""
        self.ec.clear()
        self.context = "stand by"
        self.skip = False
        if self.eliza_wrapper is not None:
            self.eliza_wrapper.clear()
        if self.db is not None:
            self.db.clear()