class ChannelConfig(SlottedModel):
# If specified, the only channels to allow stars from
sources = ListField(ChannelField, default=[])
# Channels to ignore
ignored_channels = ListField(ChannelField, default=[])
# Delete the star when the message is deleted
clear_on_delete = Field(bool, default=True)
# Min number of stars to post on the board
min_stars = Field(int, default=1)
min_stars_pin = Field(int, default=15)
# The number which represents the "max" star level
star_color_max = Field(int, default=15)
# Prevent users from starring their own posts
prevent_self_star = Field(bool, default=False)
# Max age for starred messages
max_age = Field(int, default=32)
def get_color(self, count):
ratio = min(count / float(self.star_color_max), 1.0)
return ((255 << 16) + (int((194 * ratio) + (253 * (1 - ratio))) << 8) +
int((12 * ratio) + (247 * (1 - ratio))))
class CensorSubConfig(SlottedModel):
filter_zalgo = Field(bool, default=True)
filter_invites = Field(bool, default=True)
invites_guild_whitelist = ListField(snowflake, default=[])
invites_whitelist = ListField(lower, default=[])
invites_blacklist = ListField(lower, default=[])
filter_domains = Field(bool, default=True)
domains_whitelist = ListField(lower, default=[])
domains_blacklist = ListField(lower, default=[])
blocked_words = ListField(lower, default=[])
blocked_tokens = ListField(lower, default=[])
blocked_regex = ListField(lower, default=[])
filter_level = Field(int, default=1000)
included_channels = ListField(snowflake, default=[])
excluded_channels = ListField(snowflake, default=[])
always_ban = Field(bool, default=False)
filter_zero = Field(bool, default=False)
@cached_property
def blocked_re(self):
return re.compile(u'({})'.format(u'|'.join(
map(re.escape, self.blocked_tokens) +
map(lambda k: u'\\b{}\\b'.format(re.escape(k)), self.blocked_words) +
self.blocked_regex
)), re.I | re.M | re.S)
class CensorSubConfig(SlottedModel):
filter_zalgo = Field(bool, default=True)
filter_invites = Field(bool, default=True)
invites_guild_whitelist = ListField(snowflake, default=[])
invites_whitelist = ListField(lower, default=[])
invites_blacklist = ListField(lower, default=[])
filter_domains = Field(bool, default=True)
domains_whitelist = ListField(lower, default=[])
domains_blacklist = ListField(lower, default=[])
blocked_words = ListField(lower, default=[])
blocked_tokens = ListField(lower, default=[])
blocked_nicknames = ListField(lower, default=[])
blocked_nickname_tokens = ListField(lower, default=[])
blocked_nickname_rename = Field(str, default='')
@cached_property
def blocked_re(self):
return re.compile(
u'({})'.format(u'|'.join(
map(re.escape, self.blocked_tokens) +
map(lambda k: u'\\b{}\\b'.format(re.escape(k)),
self.blocked_words))), re.I)
class PersistConfig(SlottedModel):
roles = Field(bool, default=False)
nickname = Field(bool, default=False)
voice = Field(bool, default=False)
role_ids = ListField(snowflake, default=[])
all_roles = Field(bool, default=False)
class ModLogConfig(PluginConfig):
resolved = Field(bool, default=False, private=True)
ignored_users = ListField(snowflake)
ignored_channels = ListField(snowflake)
custom = DictField(str, CustomFormat)
channels = DictField(ChannelField, ChannelConfig)
new_member_threshold = Field(int, default=(15 * 60))
_custom = DictField(dict, private=True)
_channels = DictField(ChannelConfig, private=True)
@cached_property
def subscribed(self):
return reduce(operator.or_, (i.subscribed for i in self.channels.values())) if self.channels else set()
class CensorSubConfig(SlottedModel):
filter_zalgo = Field(bool, default=True)
filter_invites = Field(bool, default=True)
invites_guild_whitelist = ListField(snowflake, default=[])
invites_whitelist = ListField(lower, default=[])
invites_blacklist = ListField(lower, default=[])
filter_domains = Field(bool, default=True)
domains_whitelist = ListField(lower, default=[])
domains_blacklist = ListField(lower, default=[])
blocked_words = ListField(lower, default=[])
blocked_tokens = ListField(lower, default=[])
unidecode_tokens = Field(bool, default=False)
channel = Field(snowflake, default=None)
bypass_channel = Field(snowflake, default=None)
@cached_property
def blocked_re(self):
return re.compile('({})'.format('|'.join(
list(map(re.escape, self.blocked_tokens)) +
list(map(lambda k: '\\b{}\\b'.format(re.escape(k)), self.blocked_words))
)), re.I)
class ChannelConfig(SlottedModel):
compact = Field(bool, default=True)
include = ListField(Actions)
exclude = ListField(Actions)
rich = ListField(Actions)
timestamps = Field(bool, default=False)
timezone = Field(str, default='US/Eastern')
@cached_property
def tz(self):
return pytz.timezone(self.timezone)
@cached_property
def subscribed(self):
include = set(self.include if self.include else Actions.attrs)
exclude = set(self.exclude if self.exclude else [])
return include - exclude
class AdminConfig(PluginConfig):
confirm_actions = Field(bool, default=True)
# Role saving information
persist = Field(PersistConfig, default=None)
# Aliases to roles, can be used in place of IDs in commands
role_aliases = DictField(unicode, snowflake)
# Group roles can be joined/left by any user
group_roles = DictField(lambda value: unicode(value).lower(), snowflake)
group_confirm_reactions = Field(bool, default=False)
# Locked roles cannot be changed unless they are unlocked w/ command
locked_roles = ListField(snowflake)
class CensorSubConfig(SlottedModel):
filter_zalgo = Field(bool, default=True)
filter_invites = Field(bool, default=True)
invite_filter_ignored_channels = ListField(lower, default=[])
invites_guild_whitelist = ListField(snowflake, default=[])
invites_whitelist = ListField(lower, default=[])
invites_blacklist = ListField(lower, default=[])
filter_domains = Field(bool, default=True)
domain_filter_ignored_channels = ListField(lower, default=[])
domains_whitelist = ListField(lower, default=[])
domains_blacklist = ListField(lower, default=[])
blocked_words = ListField(lower, default=[])
blocked_tokens = ListField(lower, default=[])
@cached_property
def blocked_re(self):
return re.compile('({})'.format('|'.join(
list(map(re.escape, self.blocked_tokens)) +
['\\b{}\\b'.format(re.escape(k)) for k in self.blocked_words]
)), re.I)
class SpamConfig(PluginConfig):
roles = DictField(str, SubConfig)
levels = DictField(int, SubConfig)
ignored_channels = ListField(snowflake, default=[])
def compute_relevant_rules(self, member, level):
if self.roles:
if '*' in self.roles:
yield self.roles['*']
for rid in member.roles:
if rid in self.roles:
yield self.roles[rid]
rname = member.guild.roles.get(rid)
if rname and rname.name in self.roles:
yield self.roles[rname.name]
if self.levels:
for lvl in self.levels.keys():
if level <= lvl:
yield self.levels[lvl]
class CensorConfig(PluginConfig):
levels = DictField(int, CensorSubConfig)
channels = DictField(ChannelField, CensorSubConfig)
ignored_users = ListField(snowflake, default=[])
class TwitchConfig(PluginConfig):
streams = ListField(str)
config = DictField(str, StreamConfig)
class CensorConfig(PluginConfig):
levels = DictField(int, CensorSubConfig)
filters = ListField(CensorSubConfig, default=[])
