def with_client(*features, connected=True, **options):
if not features:
features = (pydle.client.BasicClient, )
if features not in with_client.classes:
with_client.classes[features] = pydle.featurize(MockClient, *features)
def inner(f):
def run():
server = MockServer()
client = with_client.classes[features]('TestcaseRunner',
mock_server=server,
**options)
if connected:
client.connect('mock://local', 1337, eventloop=MockEventLoop())
try:
ret = f(client=client, server=server)
return ret
finally:
if client.eventloop:
client.eventloop.stop()
run.__name__ = f.__name__
return run
return inner
class TwitchBot(pydle.featurize(
pydle.features.RFC1459Support,
pydle.features.IRCv3Support,
pydle.features.ircv3.CapabilityNegotiationSupport
)):
def __init__(self):
nickname = os.getenv('TWITCH_BOT_NICK')
super().__init__(
nickname=nickname,
realname='BakedBeansBot'
)
self.twitch_chan = f'#{nickname}'
async def connect(self):
await super().connect(
hostname='irc.chat.twitch.tv',
port=6697,
password=os.getenv('TWITCH_BOT_PASSWORD'),
tls=True,
tls_verify=False
)
async def on_connect(self):
await super().on_connect()
# await self.capreq(':twitch.tv/membership')
# await self.capreq(':twitch.tv/tags')
# await self.capreq(':twitch.tv/commands')
await self.join(self.twitch_chan)
def on_raw_004(self, msg):
"""
Twitch IRC does not match what the pydle library expects
which causes Pydle to raise exceptions.
Override on_raw_004 and prevent super call
Copied from:
https://github.com/LangridgeDaniel/python-twitch-irc/blob/master/python_twitch_irc/irc.py
"""
logging.debug(f'on_raw_004: {msg}')
async def capreq(self, message):
await self.rawmsg('CAP REQ', message)
async def raid_target(self, host_chan: str, chan: typing.Optional[str] = None):
if chan is None:
await self.message(self.twitch_chan, '.unraid')
else:
await self.message(self.twitch_chan, f'.raid {chan}')
'''
def with_client(*features, connected=True, **options):
if not features:
features = (pydle.client.BasicClient,)
if features not in with_client.classes:
with_client.classes[features] = pydle.featurize(MockClient, *features)
def inner(f):
def run():
server = MockServer()
client = with_client.classes[features]('TestcaseRunner', mock_server=server, **options)
if connected:
client.connect('mock://local', 1337, eventloop=MockEventLoop())
try:
ret = f(client=client, server=server)
return ret
finally:
if client.eventloop:
client.eventloop.stop()
run.__name__ = f.__name__
return run
return inner
import base64
import urllib.request
import pydle
import configparser
config = configparser.ConfigParser()
config.read('config.ini')
twitchConfig = config['twitch']
streamnames = twitchConfig['Stream'].split(',')
nickname = twitchConfig['Nickname']
password = twitchConfig['Password']
BaseIrcClass = pydle.featurize(pydle.features.RFC1459Support,
pydle.features.IRCv3Support)
class MyOwnBot(BaseIrcClass):
async def on_raw_004(self, msg):
return
async def on_connect(self):
for stream in streamnames:
print("Joining", stream)
await self.join(stream)
async def on_message(self, target, nick, message):
name = str(base64.urlsafe_b64encode(nick.encode("utf-8")), "utf-8")
message = str(base64.urlsafe_b64encode(message.encode("utf-8")),
"utf-8")
target = str(base64.urlsafe_b64encode(target.encode("utf-8")), "utf-8")
CommandEventFunc = Callable[['Client', 'ParsedRaw'], None]
CommandEventList = List[CommandEventFunc]
CommandEventPlugsDict = Dict[str, CommandEventList]
InitFunc = Callable[['Client'], None]
InitList = List[CommandEventFunc]
InitDict = Dict[str, CommandEventList]
FuncUnion = Union[InputSieveList, OutputSieveList, CommandEventList, InitList]
AllPlugsDict = Dict[str, FuncUnion]
DBResult = Optional[List[Tuple[Optional[str], ...]]]
PydleClient = pydle.featurize(pydle.features.RFC1459Support,
pydle.features.IRCv3Support,
pydle.features.AccountSupport,
pydle.features.CTCPSupport,
pydle.features.ISUPPORTSupport,
pydle.features.TLSSupport)
class Client(PydleClient):
"""Taigabot Client."""
async def stop(self, reset: bool = False) -> None:
"""Is used to stop or restart the bot."""
global restarted
restarted = reset
os.kill(os.getpid(), signal.SIGINT)
async def message_handler(self, data: 'ParsedRaw') -> None:
"""
Is used for running sieves, events and commands if applicable.
""" PRIVMSG command. """
nick, metadata = self._parse_user(message.source)
tags = message.tags
target, message = message.params
self._sync_user(nick, metadata)
await self.on_message(target, nick, message, tags)
if self.is_channel(target):
await self.on_channel_message(target, nick, message, tags)
else:
await self.on_private_message(nick, message, tags)
# End Github code
BotClass = pydle.featurize(pydle.Client, PrivMessageTagSupport)
# From https://stackoverflow.com/a/3540315/3153319
def random_line(afile):
line = next(afile)
for num, aline in enumerate(afile, 2):
if random.randrange(num): continue
line = aline
return line
# End SO code
class MusicConversationBot(BotClass):
import subprocess
import _thread
from pyfiglet import Figlet
except Exception as e: # oops!
print(
"There has been an error when including modules. It means that you haven't installed one of those. Please check and try again."
)
os._exit(1)
logging.basicConfig(level=logging.DEBUG)
config = json.load(open("config.json"))
BaseClient = pydle.featurize(pydle.features.RFC1459Support,
pydle.features.WHOXSupport,
pydle.features.AccountSupport,
pydle.features.TLSSupport,
pydle.features.IRCv3_1Support)
class Donger(BaseClient):
def __init__(self, nick, *args, **kwargs):
super().__init__(nick, *args, **kwargs)
# This is to remember the millions of misc variable names
self.pendingFights = {
} # Pending (not !accepted) fights. ({'player': {'ts': 123, 'deathmatch': False, 'versusone': False, 'players': [...], 'pendingaccept': [...]}, ...}
# Game vars (Reset these in self.win)
self.deathmatch = False
self.deatharena = False
from configparser import ConfigParser
from functools import partial
from pluginbase import PluginBase
from pydle. async import EventLoop
from tornado.ioloop import PeriodicCallback
from ircbot.webserver import setup_webserver
logger = logging.getLogger(__name__)
here = os.path.abspath(os.path.dirname(__file__))
get_path = partial(os.path.join, here)
plugin_base = PluginBase(package='ircbot.plugins')
BotbotClient = pydle.featurize(pydle.Client, pydle.features.IRCv3Support,
pydle.features.WHOXSupport)
class BotBot(pydle.Client):
def __init__(self,
fallback_nicknames=[],
username=None,
realname=None,
**kwargs):
super(BotBot, self).__init__("botbot-defaultnickname",
fallback_nicknames=fallback_nicknames,
username=username,
realname=realname,
**kwargs)
self.config = None
self.join_channels = None
import configparser
import base64
import datetime
import binascii
import sqlite3
import socket
import json
import urllib.parse
import dns
try:
import getdns
dns_enabled = True
except ModuleNotFoundError:
dns_enabled = False
MyBaseClient = pydle.featurize(pydle.MinimalClient,
pydle.features.ircv3.SASLSupport)
conn = None
valid_tlds = None
class BanaanBot(MyBaseClient):
def on_connect(self):
super().on_connect()
for i in config['Bot']['channels'].split(','):
self.join(i)
def on_unknown(self, message):
super().on_unknown(message)
#print(message)
def on_raw(self, message):
#!/usr/bin/env python3
import pydle
import config
import os
import importlib
import re
import traceback
import threading
import copy
import time
Waifu = pydle.featurize(pydle.features.RFC1459Support, pydle.features.WHOXSupport,
pydle.features.ISUPPORTSupport,
pydle.features.AccountSupport, pydle.features.TLSSupport,
pydle.features.IRCv3_1Support, pydle.features.CTCPSupport)
# Event object!
class Event(object):
def __init__(self, source, target, message):
self.source = source
self.target = target
self.message = message
self.match = None # regex match for stuffHooks
self.pm = False if target.startswith('#') else True
self.replyto = source if self.pm else target
#!/usr/bin/env python3
import pydle
import config
import os
import importlib
import re
import traceback
import threading
import copy
import time
Waifu = pydle.featurize(pydle.features.RFC1459Support, pydle.features.WHOXSupport,
pydle.features.ISUPPORTSupport,
pydle.features.AccountSupport, pydle.features.TLSSupport,
pydle.features.IRCv3_1Support, pydle.features.CTCPSupport)
# Event object!
class Event(object):
def __init__(self, source, target, message):
self.source = source
self.target = target
self.message = message
self.match = None # regex match for stuffHooks
self.pm = False if target.startswith('#') else True
self.replyto = source if self.pm else target
import logging
import socket
import pydle
import config
BotBase = pydle.featurize(pydle.features.RFC1459Support, pydle.features.TLSSupport)
logger = logging.getLogger("IRC")
logger.setLevel(logging.DEBUG)
cfg = config.init()
class IRC(BotBase):
tracking = None
RECONNECT_MAX_ATTEMPTS = 100
announcer = None
# temp fix until pydle handles connect failures
def connect(self, *args, **kwargs):
try:
super().connect(*args, **kwargs)
except socket.error:
self.on_disconnect(expected=False)
def set_tracker(self, track):
self.tracking = track
def on_connect(self):
import random
import time
from pyfiglet import Figlet
import copy
import peewee
import importlib
import subprocess
import datetime
loggingFormat = '%(asctime)s %(levelname)s:%(name)s: %(message)s'
logging.basicConfig(level=logging.DEBUG, format=loggingFormat)
config = json.load(open("config.json"))
BaseClient = pydle.featurize(pydle.features.RFC1459Support, pydle.features.WHOXSupport,
pydle.features.AccountSupport, pydle.features.TLSSupport,
pydle.features.IRCv3_1Support)
class Donger(BaseClient):
def __init__(self, nick, *args, **kwargs):
super().__init__(nick, *args, **kwargs)
# This is to remember the millions of misc variable names
self.pendingFights = {} # Pending (not !accepted) fights. ({'player': {'ts': 123, 'deathmatch': False, 'versusone': False, 'players': [...], 'pendingaccept': [...]}, ...}
# Game vars (Reset these in self.win)
self.deathmatch = False
self.gameRunning = False
self.turnStart = 0
self.players = {} # Players. {'polsaker': {'hp': 100, 'heals': 5, 'zombie': False, 'praised': False, 'gdr': 1}, ...}
#!/usr/bin/env python3
# -- coding: utf-8 --
import pydle
import logging
# import threading
from PyQt5.QtCore import QThread, QObject, pyqtSignal
from imotion.const import *
# from src.database import Database
BaseClient = pydle.featurize(
pydle.features.RFC1459Support,
pydle.features.CTCPSupport,
pydle.features.IRCv3_1Support,
pydle.features.ircv3.SASLSupport
)
logger = logging.getLogger("imotion")
class IRCCommunicator(QObject):
recv_msg = pyqtSignal(str, str, str)
priv_msg = pyqtSignal(str, str)
chan_notice = pyqtSignal(str, str, str)
join_chan = pyqtSignal(str)
server_info = pyqtSignal(str)
chan_info = pyqtSignal(str, str)
connected = pyqtSignal()
def __init__(self):
