joe Download - joe Quellcode herunterladen

joe

AI-Quellcode

1.0.0

Herunterladen

joe Bot?

Eine von Hubot inspirierte, aber in Go geschriebene Allzweck-Bot-Bibliothek.

joe ist eine Bibliothek zum Schreiben von Chatbots in der Programmiersprache Go. Es ist stark von dem großartigen Hubot-Framework inspiriert, das von den Leuten bei Github entwickelt wurde, und bringt seine Leistungsfähigkeit zu Leuten, die Chatbots mit Go implementieren möchten.

Erste Schritte

joe ist eine Softwarebibliothek, die als Go-Modul verpackt ist. Sie können es erhalten über:

joe ">

 go get github.com/go- joe / joe

Beispielverwendung

Alle Codebeispiele, weitere Erklärungen und vollständige Rezepte finden Sie unter https://joe-bot.net

Jeder Bot besteht aus einem Chat- Adapter (z. B. zur Integration mit Slack), einer Speicherimplementierung zum Speichern von Schlüsselwertdaten (z. B. mithilfe von Redis) und einem Gehirn , das neue Nachrichten oder benutzerdefinierte Ereignisse (z. B. den Empfang eines HTTP-Aufrufs) an die entsprechenden registrierten Bots weiterleitet Handlerfunktionen .

Standardmäßig verwendet joe .New(…) den CLI-Adapter, der den Bot dazu bringt, Nachrichten von stdin zu lesen und auf stdout zu antworten. Darüber hinaus speichert der Bot Schlüsselwertdaten im Speicher, was bedeutet, dass er alles vergisst, was Sie ihm gesagt haben, wenn er neu gestartet wird. Dieses Standard-Setup ist für die lokale Entwicklung ohne Abhängigkeiten nützlich, Sie möchten jedoch schnell weitere Module hinzufügen, um die Fähigkeiten des Bots zu erweitern.

Das folgende Beispiel verbindet den Bot mit einem Slack-Arbeitsbereich und speichert Schlüsselwertdaten in Redis. Um den Nachrichtenhandlern den Zugriff auf den Speicher zu ermöglichen, definieren wir sie als Funktionen für einen benutzerdefinierten ExampleBot -Typ, der den joe .Bot einbettet.

joe " "github.com/go- joe /redis-memory" "github.com/go- joe /slack-adapter/v2" ) type ExampleBot struct { * joe .Bot } func main() { b := &ExampleBot{ Bot: joe .New("example", redis.Memory("localhost:6379"), slack.Adapter("xoxb-1452345…"), ), } b.Respond("remember (.+) is (.+)", b.Remember) b.Respond("what is (.+)", b.WhatIs) err := b.Run() if err != nil { b.Logger.Fatal(err.Error()) } } func (b *ExampleBot) Remember(msg joe .Message) error { key, value := msg.Matches[0], msg.Matches[1] msg.Respond("OK, I'll remember %s is %s", key, value) return b.Store.Set(key, value) } func (b *ExampleBot) WhatIs(msg joe .Message) error { key := msg.Matches[0] var value string ok, err := b.Store.Get(key, &value) if err != nil { return fmt.Errorf("failed to retrieve key %q from brain: %w", key, err) } if ok { msg.Respond("%s is %s", key, value) } else { msg.Respond("I do not remember %q", key) } return nil }">

 package main

import (
	"fmt"

	"github.com/go- joe / joe "
	"github.com/go- joe /redis-memory"
	"github.com/go- joe /slack-adapter/v2"
)

type ExampleBot struct {
	* joe . Bot
}

func main () {
	b := & ExampleBot {
		Bot : joe . New ( "example" ,
			redis . Memory ( "localhost:6379" ),
			slack . Adapter ( "xoxb-1452345…" ),
		),
	}

	b . Respond ( "remember (.+) is (.+)" , b . Remember )
	b . Respond ( "what is (.+)" , b . WhatIs )

	err := b . Run ()
	if err != nil {
		b . Logger . Fatal ( err . Error ())
	}
}

func ( b * ExampleBot ) Remember ( msg joe . Message ) error {
	key , value := msg . Matches [ 0 ], msg . Matches [ 1 ]
	msg . Respond ( "OK, I'll remember %s is %s" , key , value )
	return b . Store . Set ( key , value )
}

func ( b * ExampleBot ) WhatIs ( msg joe . Message ) error {
	key := msg . Matches [ 0 ]
	var value string
	ok , err := b . Store . Get ( key , & value )
	if err != nil {
		return fmt . Errorf ( "failed to retrieve key %q from brain: %w" , key , err )
	}

	if ok {
		msg . Respond ( "%s is %s" , key , value )
	} else {
		msg . Respond ( "I do not remember %q" , key )
	}

	return nil
}

Verfügbare Module

joe wird ohne Module von Drittanbietern wie der Redis-Integration ausgeliefert, um zu vermeiden, dass mehr Abhängigkeiten einbezogen werden, als Sie tatsächlich benötigen. Es gibt jedoch bereits einige Module, mit denen Sie die Funktionalität Ihres Bots direkt erweitern können, ohne selbst zu viel Code schreiben zu müssen.

Wenn Sie ein Modul geschrieben haben und es teilen möchten, fügen Sie es bitte dieser Liste hinzu und öffnen Sie eine Pull-Anfrage.

Chat-Adapter

Slack-Adapter: https://github.com/go-joe/slack-adapter
Rocket.Chat-Adapter: https://github.com/dwmunster/rocket-adapter
Telegram-Adapter: https://github.com/robertgzr/joe-telegram-adapter
IRC-Adapter: https://github.com/akrennmair/joe-irc-adapter
Mattermost-Adapter: https://github.com/dwmunster/joe-mattermost-adapter
VK-Adapter: https://github.com/tdakkota/joe-vk-adapter

Speichermodule

Redis-Speicher: https://github.com/go-joe/redis-memory
Dateispeicher: https://github.com/go-joe/file-memory
Bolt-Speicher: https://github.com/robertgzr/joe-bolt-memory
SQLite-Speicher: https://github.com/warmans/sqlite-memory

Andere Module

HTTP-Server: https://github.com/go-joe/http-server
Cron-Jobs: https://github.com/go-joe/cron

Gebaut mit

zap – Blitzschnelle, strukturierte und ebene Protokollierung in Go
multierr – Das Paket multierr ermöglicht die Kombination eines oder mehrerer Fehler
testify – Eine einfache Unit-Test-Bibliothek

Mitwirken

Bitte lesen Sie CONTRIBUTING.md für Einzelheiten zu unserem Verhaltenskodex und zum Verfahren zum Senden von Pull-Anfragen an dieses Repository.

Versionierung

DIESE SOFTWARE BEFINDET SICH NOCH IN ALPHA UND ES GIBT NOCH KEINE GARANTIEN BEZÜGLICH DER API-STABILITÄT.

Alle wesentlichen (z. B. bahnbrechenden) Änderungen werden im CHANGELOG.md dokumentiert.

Nach der Veröffentlichung von v1.0 planen wir, SemVer für die Versionierung zu verwenden. Die verfügbaren Versionen finden Sie in den Tags in diesem Repository.