Descarga de joe - Descarga del código fuente joe

joe

Código Fuente de IA

1.0.0

Descargar

joe Bot?

Una biblioteca de bots de uso general inspirada en Hubot pero escrita en Go.

joe es una biblioteca que se utiliza para escribir bots de chat en el lenguaje de programación Go. Está muy inspirado en el increíble marco Hubot desarrollado por la gente de Github y brinda su poder a las personas que desean implementar chatbots usando Go.

Empezando

joe es una biblioteca de software empaquetada como módulo Go. Puedes conseguirlo a través de:

joe ">

 go get github.com/go- joe / joe

Uso de ejemplo

Puede encontrar todos los ejemplos de código, más explicaciones y recetas completas en https://joe-bot.net

Cada bot consta de un Adaptador de chat (por ejemplo, para integrarse con Slack), una implementación de Memoria para recordar datos clave-valor (por ejemplo, usando Redis) y un Cerebro que enruta nuevos mensajes o eventos personalizados (por ejemplo, recibir una llamada HTTP) al correspondiente registrado. funciones del manejador .

De forma predeterminada joe .New(…) usa el adaptador CLI que hace que el bot lea mensajes de stdin y responda en stdout. Además, el bot almacenará datos de valores clave en la memoria, lo que significa que olvidará todo lo que le haya dicho cuando se reinicie. Esta configuración predeterminada es útil para el desarrollo local sin dependencias, pero rápidamente querrás agregar otros módulos para ampliar las capacidades de los bots.

El siguiente ejemplo conecta el Bot con un espacio de trabajo de Slack y almacena datos clave-valor en Redis. Para permitir que los controladores de mensajes accedan a la memoria, los definimos como funciones en un tipo de ExampleBot personalizado que incorpora el joe .Bot .

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
}

Módulos disponibles

joe se envía sin módulos de terceros, como la integración de Redis, para evitar incorporar más dependencias de las que realmente necesita. Sin embargo, ya existen algunos módulos que puedes usar directamente para ampliar la funcionalidad de tu bot sin escribir demasiado código.

Si ha escrito un módulo y desea compartirlo, agréguelo a esta lista y abra una solicitud de extracción.

Adaptadores de chat

Adaptador flojo: https://github.com/go-joe/slack-adapter
Adaptador Rocket.Chat: https://github.com/dwmunster/rocket-adapter
Adaptador de Telegram: https://github.com/robertgzr/joe-telegram-adapter
Adaptador IRC: https://github.com/akrennmair/joe-irc-adapter
Adaptador más importante: https://github.com/dwmunster/joe-mattermost-adapter
Adaptador VK: https://github.com/tdakkota/joe-vk-adapter

Módulos de memoria

Memoria de Redis: https://github.com/go-joe/redis-memory
Memoria de archivos: https://github.com/go-joe/file-memory
Memoria de perno: https://github.com/robertgzr/joe-bolt-memory
Memoria SQLite: https://github.com/warmans/sqlite-memory

Otros módulos

Servidor HTTP: https://github.com/go-joe/http-server
Trabajos cron: https://github.com/go-joe/cron

Construido con

zap: registro increíblemente rápido, estructurado y nivelado en Go
multierr: el paquete multierr permite combinar uno o más errores juntos
testify: una biblioteca de pruebas unitarias sencilla

Contribuyendo

Lea CONTRIBUTING.md para obtener detalles sobre nuestro código de conducta y sobre el proceso para enviar solicitudes de extracción a este repositorio.

Versionado

ESTE SOFTWARE AÚN ESTÁ EN ALFA Y AÚN NO HAY GARANTÍAS CON RESPECTO A LA ESTABILIDAD DE API.

Todos los cambios significativos (por ejemplo, importantes) se documentan en CHANGELOG.md.

Después del lanzamiento v1.0 planeamos usar SemVer para el control de versiones. Para conocer las versiones disponibles, consulte las etiquetas en este repositorio.