def on_load(self):
setting = utils.FunctionSetting(self._get_location,
"location",
"Set your location",
example="London, GB")
self.exports.add("set", setting)
self.exports.add("get-location", self._get_location)
import socks
from src import ModuleManager, utils
TYPES = {
"socks4": socks.SOCKS4,
"socks5": socks.SOCKS5,
"http": socks.HTTP
}
def _parse(value):
parsed = urllib.parse.urlparse(value)
if parsed.scheme in TYPES and parsed.hostname:
return value
@utils.export("serverset", utils.FunctionSetting(_parse, "proxy",
"Proxy configuration for the current server",
example="socks5://localhost:9050"))
class Module(ModuleManager.BaseModule):
@utils.hook("preprocess.connect")
def new_server(self, event):
proxy = event["server"].get_setting("proxy", None)
if proxy:
proxy_parsed = urllib.parse.urlparse(proxy)
type = TYPES.get(proxy_parsed.scheme)
if type == None:
raise ValueError("Invalid proxy type '%s' for '%s'" %
(proxy_parsed.scheme, str(event["server"])))
event["server"].socket._make_socket = self._socket_factory(
type, proxy_parsed.hostname, proxy_parsed.port)
#--depends-on rest_api
import urllib.parse
from src import IRCBot, ModuleManager, utils
from . import ap_actor, ap_security, ap_server, ap_utils
def _format_username(username, instance):
return "@%s@%s" % (username, instance)
def _setting_parse(s):
username, instance = ap_utils.split_username(s)
if username and instance:
return _format_username(username, instance)
return None
@utils.export("botset", utils.FunctionSetting(_setting_parse,
"fediverse-server", "The bot's local fediverse server username",
example="@[email protected]"))
@utils.export("set", utils.FunctionSetting(_setting_parse, "fediverse",
help="Set your fediverse account", example="@[email protected]"))
class Module(ModuleManager.BaseModule):
_name = "Fedi"
def on_load(self):
server_username = self.bot.get_setting("fediverse-server", None)
if server_username:
if not "tls-key" in self.bot.config:
raise ValueError("`tls-key` not provided in bot config")
if not "tls-certificate" in self.bot.config:
raise ValueError("`tls-certificate` not provided in bot config")
if not ap_security.has_crypto:
raise ValueError("cyprography library is not installed "
DEFAULT_PORT = 64738
def _parse(s):
host, _, port = s.partition(":")
if port:
if not port.isdigit():
return None
else:
port = str(DEFAULT_PORT)
return "%s:%s" % (host, port)
SETTING = utils.FunctionSetting(_parse,
"mumble-server",
"Set the mumble server for this channel",
example="example.com:%s" % DEFAULT_PORT)
@utils.export("channelset", SETTING)
@utils.export("serverset", SETTING)
class Module(ModuleManager.BaseModule):
@utils.hook("received.command.mumble")
@utils.kwarg("help", "Get user and bandwidth stats for a mumble server")
@utils.kwarg("usage", "[server[:<port>]]")
def mumble(self, event):
server = None
if not event["args"]:
server = event["target"].get_setting(
"mumble-server",
event["server"].get_setting("mumble-server", None))
REGEX_IP = re.compile("%s|%s" % (REGEX_IPv4, REGEX_IPv6), re.I)
def _parse(value):
if utils.is_ip(value):
return value
return None
@utils.export("botset",
utils.BoolSetting(
"configurable-nameservers",
"Whether or not users can configure their own nameservers"))
@utils.export("serverset",
utils.FunctionSetting(_parse,
"dns-nameserver",
"Set DNS nameserver",
example="8.8.8.8"))
@utils.export("channelset",
utils.FunctionSetting(_parse,
"dns-nameserver",
"Set DNS nameserver",
example="8.8.8.8"))
class Module(ModuleManager.BaseModule):
@utils.hook("received.command.dns", min_args=1)
def dns(self, event):
"""
:help: Get all addresses for a given hostname (IPv4/IPv6)
:usage: <hostname> [type [type ...]]
:prefix: DNS
"""
args = event["args_split"][:]
parsed = _parse(value)
if parsed:
years, parsed = parsed
return _format(years, parsed)
return None
def _apostrophe(nickname):
if nickname[-1].lower() == "s":
return "%s'" % nickname
return "%s's" % nickname
@utils.export("set",
utils.FunctionSetting(_parse_setting,
"birthday",
"Set your birthday",
example="1995-09-15"))
class Module(ModuleManager.BaseModule):
@utils.hook("received.command.birthday")
def birthday(self, event):
"""
:help: Get your, or someone else's, birthday
:usage: [nickname]
:require_setting: birthday
:require_setting_unless: 1
"""
target_user = event["user"]
if event["args"]:
target_user = event["server"].get_user(event["args_split"][0])
birthday = target_user.get_setting("birthday", None)
return {"mechanism": mechanism.upper(), "args": arguments}
else:
raise utils.SettingParseException("Unknown SASL mechanism '%s'" %
mechanism)
SASL_TIMEOUT = 15 # 15 seconds
HARDFAIL = utils.BoolSetting(
"sasl-hard-fail", "Set whether a SASL failure should cause a disconnect")
@utils.export("serverset",
utils.FunctionSetting(
_parse,
"sasl",
"Set the sasl username/password for this server",
example="PLAIN BitBot:hunter2",
format=utils.sensitive_format))
@utils.export("serverset", HARDFAIL)
@utils.export("botset", HARDFAIL)
class Module(ModuleManager.BaseModule):
@utils.hook("new.server")
def new_server(self, event):
event["server"]._sasl_timeout = None
def _best_userpass_mechanism(self, mechanisms):
for potential_mechanism in USERPASS_MECHANISMS:
if potential_mechanism in mechanisms:
return potential_mechanism
@utils.hook("received.cap.new")
import urllib.parse
from src import ModuleManager, utils
def _parse(s):
parsed = urllib.parse.urlparse(s)
return urllib.parse.urljoin(s, parsed.path), parsed.query
SETTING = utils.FunctionSetting(
_parse,
"yourls",
"Set YOURLS server (and token) to use for URL shortening",
example="https://bitbot.dev/yourls-api.php?1002a612b4",
format=utils.sensitive_format)
@utils.export("botset", SETTING)
@utils.export("serverset", SETTING)
@utils.export("channelset", SETTING)
class Module(ModuleManager.BaseModule):
@utils.export("shorturl-x-yourls")
def _shorturl(self, server, context, url):
setting = server.get_setting("yourls",
self.bot.get_setting("yourls", None))
if context:
setting = context.get_setting("yourls", setting)
if not setting == None:
shortener_url, token = setting
from src import ModuleManager, utils
def _parse(value):
lines, _, seconds = value.partition(":")
if lines.isdigit() and seconds.isdigit():
return [int(lines), int(seconds)]
return None
@utils.export("serverset",
utils.FunctionSetting(
_parse,
"throttle",
"Configure lines:seconds throttle for the current server",
example="4:2"))
class Module(ModuleManager.BaseModule):
@utils.hook("received.001")
def connect(self, event):
throttle = event["server"].get_setting("throttle", None)
if throttle:
lines, seconds = throttle
event["server"].socket.set_throttle(lines, seconds)
return _format(years, parsed)
else:
raise utils.settings.SettingParseException(
"Please provide either yyyy-mm-dd or dd-mmm (e.g. %s or %s)" %
(EXAMPLE_DATE_YEAR, EXAMPLE_DATE))
def _apostrophe(nickname):
if nickname[-1].lower() == "s":
return "%s'" % nickname
return "%s's" % nickname
@utils.export("set",
utils.FunctionSetting(_parse_setting,
"birthday",
"Set your birthday",
example=EXAMPLE_DATE_YEAR))
class Module(ModuleManager.BaseModule):
@utils.hook("received.command.birthday")
def birthday(self, event):
"""
:help: Get your, or someone else's, birthday
:usage: [nickname]
:require_setting: birthday
:require_setting_unless: 1
"""
target_user = event["user"]
if event["args"]:
target_user = event["server"].get_user(event["args_split"][0])
birthday = target_user.get_setting("birthday", None)
