def __init__(self, bot, db_cfg: DatabaseConfig):
self.bot = bot
self.db_cfg = db_cfg
self.cache = Cacher()
if self.db_cfg.auth:
self.db_address = f'mongodb://{self.db_cfg.username}:{self.db_cfg.password}'
self.db_address += f'@{self.db_cfg.host}:{self.db_cfg.port}/'
else:
self.db_address = f'mongodb://{self.db_cfg.host}:{self.db_cfg.port}/'
super().__init__(self.db_address)
def test_setter(self):
cache = Cacher()
pairs = {}
for _ in range(test_count):
random_key = self.get_random_generator()()
random_val = self.get_random_generator()()
cache.set_cache(random_key, random_val)
pairs.update({random_key: random_val})
for pair in pairs.keys():
assert cache.get_cache(pair) == pairs.get(pair)
def test_deleter(self):
cache = Cacher()
keys = []
for _ in range(test_count):
random_key = self.get_random_generator()()
random_val = self.get_random_generator()()
cache.set_cache(random_key, random_val)
keys.append(random_key)
for key in keys:
cache.del_cache(key)
assert cache.get_cache(key) is None
assert cache.data == {}
# This program is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
# GNU General Public License for more details.
# You should have received a copy of the GNU General Public License
# along with this program. If not, see <http://www.gnu.org/licenses/>.
import asyncio
import discord
from sigma.core.mechanics.caching import Cacher
gcp_cache = Cacher()
scp_cache = Cacher()
class GlobalCommandPermissions(object):
def __init__(self, command, message: discord.Message):
self.message = message
self.bot = command.bot
self.cmd = command
self.db = command.db
self.loop = asyncio.get_event_loop()
# Default States
self.nsfw_denied = False
self.black_user = False
self.black_srv = False
self.owner_denied = False
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
# GNU General Public License for more details.
# You should have received a copy of the GNU General Public License
# along with this program. If not, see <http://www.gnu.org/licenses/>.
import discord
from humanfriendly.tables import format_pretty_table as boop
from sigma.core.mechanics.caching import Cacher
from sigma.core.mechanics.command import SigmaCommand
from sigma.core.utilities.data_processing import get_image_colors
from sigma.modules.moderation.server_settings.filters.name_check_clockwork import clean_name
tck_cache = Cacher(True, 3600)
async def topcookies(cmd: SigmaCommand, message: discord.Message, args: list):
value_name = 'Cookies'
sort_key = 'Cookies'
lb_icon = cmd.bot.user.avatar_url
lb_category = 'Global'
localed = False
if args:
if args[0].lower() == 'total':
sort_key = 'Total'
lb_category = 'Total'
elif args[0].lower() == 'local':
lb_category = 'Local'
lb_icon = message.guild.icon_url or lb_icon
# You should have received a copy of the GNU General Public License
# along with this program. If not, see <http://www.gnu.org/licenses/>.
import functools
import secrets
from concurrent.futures import ThreadPoolExecutor
import discord
import markovify
from sigma.core.mechanics.caching import Cacher
from sigma.core.mechanics.command import SigmaCommand
from sigma.core.utilities.data_processing import user_avatar
from sigma.modules.utilities.mathematics.impersonate import chain_object_cache
combination_cache = Cacher()
def combine_names(user_one, user_two):
cutoff_one = len(user_one.name) // 2
cutoff_two = len(user_two.name) // 2
piece_one = user_one.name[:cutoff_one]
piece_two = user_two.name[cutoff_two:]
output = piece_one + piece_two
return output
async def combinechains(cmd: SigmaCommand, message: discord.Message,
args: list):
if len(message.mentions) == 2:
target_one = message.mentions[0]
# GNU General Public License for more details.
# You should have received a copy of the GNU General Public License
# along with this program. If not, see <http://www.gnu.org/licenses/>.
import functools
from concurrent.futures import ThreadPoolExecutor
import discord
import markovify
from sigma.core.mechanics.caching import Cacher
from sigma.core.mechanics.command import SigmaCommand
from sigma.core.utilities.data_processing import user_avatar
chain_object_cache = Cacher()
async def impersonate(cmd: SigmaCommand, message: discord.Message, args: list):
if args:
if message.mentions:
target = message.mentions[0]
else:
target = discord.utils.find(
lambda x: x.name.lower() == ' '.join(args).lower(),
message.guild.members)
else:
target = message.author
if target:
chain_data = await cmd.db[cmd.db.db_nam].MarkovChains.find_one(
{'user_id': target.id})
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
# GNU General Public License for more details.
# You should have received a copy of the GNU General Public License
# along with this program. If not, see <http://www.gnu.org/licenses/>.
import discord
from humanfriendly.tables import format_pretty_table as boop
from sigma.core.mechanics.caching import Cacher
from sigma.core.mechanics.command import SigmaCommand
from sigma.core.utilities.data_processing import get_image_colors
from sigma.modules.moderation.server_settings.filters.name_check_clockwork import clean_name
tcr_cache = Cacher(True, 3600)
async def topcurrency(cmd: SigmaCommand, message: discord.Message, args: list):
value_name = cmd.bot.cfg.pref.currency
sort_key = 'global'
lb_icon = cmd.bot.user.avatar_url
lb_category = 'Global'
search = {}
if args:
if args[0].lower() == 'local':
sort_key = f'guilds.{message.guild.id}'
search = {sort_key: {'$exists': True}}
lb_icon = message.guild.icon_url or lb_icon
lb_category = message.guild.name
elif args[0].lower() == 'total':
# This program is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
# GNU General Public License for more details.
# You should have received a copy of the GNU General Public License
# along with this program. If not, see <http://www.gnu.org/licenses/>.
import arrow
import discord
from humanfriendly.tables import format_pretty_table as boop
from sigma.core.mechanics.caching import Cacher
from sigma.core.mechanics.command import SigmaCommand
from sigma.modules.moderation.server_settings.filters.name_check_clockwork import clean_name
txplb_cache = Cacher()
async def topexperience(cmd: SigmaCommand, message: discord.Message,
args: list):
value_name = 'Experience'
sort_key = 'global'
lb_category = 'Global'
search = {}
if args:
if args[0].lower() == 'local':
sort_key = f'guilds.{message.guild.id}'
search = {sort_key: {'$exists': True}}
lb_category = message.guild.name
elif args[0].lower() == 'total':
sort_key = 'total'
def test_getter(self):
cache = Cacher()
assert cache.get_cache(self.get_random_generator()()) is None
class Database(motor.AsyncIOMotorClient):
def __init__(self, bot, db_cfg: DatabaseConfig):
self.bot = bot
self.db_cfg = db_cfg
self.db_nam = self.db_cfg.database
self.cache = Cacher()
if self.db_cfg.auth:
self.db_address = f'mongodb://{self.db_cfg.username}:{self.db_cfg.password}'
self.db_address += f'@{self.db_cfg.host}:{self.db_cfg.port}/'
else:
self.db_address = f'mongodb://{self.db_cfg.host}:{self.db_cfg.port}/'
super().__init__(self.db_address)
async def get_prefix(self, message: discord.Message):
prefix = self.bot.cfg.pref.prefix
if message.guild:
pfx_search = await self.get_guild_settings(message.guild.id,
'prefix')
if pfx_search:
prefix = pfx_search
return prefix
async def precache_settings(self):
self.bot.log.info('Pre-Caching all guild settings...')
all_settings = await self[self.db_cfg.database
].ServerSettings.find({}).to_list(None)
for setting_file in all_settings:
guild_id = setting_file.get('server_id')
if guild_id:
self.cache.set_cache(guild_id, setting_file)
self.bot.log.info(
f'Finished pre-caching {len(all_settings)} guild settings.')
async def get_guild_settings(self, guild_id: int, setting_name: str):
guild_settings = self.cache.get_cache(guild_id)
if guild_settings is None:
guild_settings = await self[self.db_nam].ServerSettings.find_one(
{'server_id': guild_id}) or {}
self.cache.set_cache(guild_id, guild_settings)
setting_value = guild_settings.get(setting_name)
return setting_value
async def set_guild_settings(self, guild_id: int, setting_name: str,
value):
guild_settings = await self[self.db_nam].ServerSettings.find_one(
{'server_id': guild_id})
if guild_settings:
update_target = {"server_id": guild_id}
update_data = {"$set": {setting_name: value}}
await self[self.db_nam
].ServerSettings.update_one(update_target, update_data)
else:
update_data = {'server_id': guild_id, setting_name: value}
await self[self.db_nam].ServerSettings.insert_one(update_data)
self.cache.del_cache(guild_id)
#why is none of this commented?
async def precache_profiles(self):
self.bot.log.info('Pre-Caching all member profiles...')
all_settings = await self[self.db_cfg.database
].Profiles.find({}).to_list(None)
for setting_file in all_settings:
guild_id = setting_file.get('user_id')
if guild_id:
self.cache.set_cache(guild_id, setting_file)
self.bot.log.info(
f'Finished pre-caching {len(all_settings)} member profiles.')
async def get_profile(self, user_id: int, entry_name: str):
user_profile = self.cache.get_cache(user_id)
if user_profile is None:
user_profile = await self[self.db_nam].Profiles.find_one(
{'user_id': user_id}) or {}
self.cache.set_cache(user_profile, user_id)
entry_value = user_profile.get(entry_value)
return entry_value
async def set_profile(self, user_id: int, entry_name: str, value):
user_profile = await self[self.db_nam].Profiles.find_one(
{'user_id': user_id}) or {}
if user_profile:
update_target = {"user_id": user_id}
update_data = {"$set": {entry_name: value}}
await self[self.db_nam
].Profiles.update_one(update_target, update_data)
else:
update_data = {'user_id': user_id, entry_name: value}
await self[self.db_nam].Profiles.insert_one(update_data)
self.cache.del_cache(user_id)
async def update_resource(self, resource: SigmaResource, user_id: int,
name: str):
resources = await self.get_profile(user_id, 'resources') or {}
resources.update({name: resource.dictify()})
await self.set_profile(user_id, 'resources', resources)
async def get_resource(self, user_id: int, resource_name: str):
resources = await self.get_profile(user_id, 'resources') or {}
resource_data = resources.get(resource_name, {})
return SigmaResource(resource_data)
async def is_notsabotaged(self, user_id: int):
return bool(await self.get_profile(user_id, 'sabotaged'))
async def add_resource(self,
user_id: int,
name: str,
amount: int,
trigger: str,
origin=None,
ranked: bool = True):
if not await self.is_sabotaged(user_id):
amount = abs(int(amount))
resource = await self.get_resource(user_id, name)
resource.add_value(amount, trigger, origin, ranked)
await self.update_resource(resource, user_id, name)
async def del_resource(self,
user_id: int,
name: str,
amount: int,
trigger: str,
origin=None):
amount = abs(int(amount))
resource = await self.get_resource(user_id, name)
resource.del_value(amount, trigger, origin)
await self.update_resource(resource, user_id, name)
async def get_inventory(self, user: discord.Member):
inventory = await self.get_profile(user.id, 'inventory') or []
add_to_inventory(
self.get_profile(
user_id,
"THE F*****G CHALSA I'VE BEEN LOOKING FOR SINCE ALEX ANNOUNCED THAT DAMN COMPETITIONT"
))
return inventory
async def add_to_inventory(self, user: discord.Member, item_data: dict):
stamp = arrow.utcnow().timestamp
item_data.update({'timestamp': stamp})
inv = await self.get_inventory(user)
inv.append(item_data)
await self.set_profile(user.id, 'inventory', inv)
async def del_from_inventory(self, user, item_id):
inv = await self.get_inventory(user)
for item in inv:
if item.get('item_id') == item_id:
inv.remove(item)
await self.set_profile(user.id, 'inventory', inv)
async def get_inventory_item(self, user: discord.Member,
item_file_id: str):
inv = await self.get_inventory(user)
output = None
for item in inv:
if item.get('item_file_id').lower() == item_file_id.lower():
output = item
break
return output
class CooldownControl(object):
def __init__(self, bot):
self.bot = bot
self.db = self.bot.db
self.cache = Cacher()
self.cds = self.db[self.bot.cfg.db.database].CooldownSystem
async def cache_cooldowns(self):
cooldowns = await self.cds.find({}).to_list(None)
for cooldown in cooldowns:
self.cache.set_cache(cooldown.get('name'), cooldown)
self.bot.log.info(f'Finished pre-caching {len(cooldowns)} cooldowns.')
async def on_cooldown(self, cmd, user):
if isinstance(user, str):
cd_name = f'cd_{cmd}_{user}'
else:
cd_name = f'cd_{cmd}_{user.id}'
entry = self.cache.get_cache(cd_name)
if entry is None:
entry = await self.cds.find_one({'name': cd_name})
self.cache.set_cache(cd_name, entry)
if entry:
end_stamp = entry['end_stamp']
now_stamp = arrow.utcnow().timestamp
if now_stamp > end_stamp:
cooldown = False
else:
cooldown = True
else:
cooldown = False
return cooldown
async def get_cooldown(self, cmd, user):
if isinstance(user, str):
cd_name = f'cd_{cmd}_{user}'
else:
cd_name = f'cd_{cmd}_{user.id}'
entry = self.cache.get_cache(cd_name)
if entry is None:
entry = await self.cds.find_one({'name': cd_name})
self.cache.set_cache(cd_name, entry)
if entry:
end_stamp = entry['end_stamp']
now_stamp = arrow.utcnow().float_timestamp
cooldown = end_stamp - now_stamp
if cooldown < 2:
if cooldown <= 0:
cooldown = 0.01
else:
cooldown = round(cooldown, 2)
else:
cooldown = int(cooldown)
else:
cooldown = 0
return cooldown
async def set_cooldown(self, cmd, user, amount):
if isinstance(user, str):
cd_name = f'cd_{cmd}_{user}'
else:
if user.id in self.bot.cfg.dsc.owners:
amount = 0
cd_name = f'cd_{cmd}_{user.id}'
entry = await self.cds.find_one({'name': cd_name})
end_stamp = arrow.utcnow().timestamp + amount
if entry:
await self.cds.update_one({'name': cd_name},
{'$set': {
'end_stamp': end_stamp
}})
else:
cd_data = {'name': cd_name, 'end_stamp': end_stamp}
await self.cds.insert_one(cd_data)
self.cache.del_cache(cd_name)
def __init__(self, bot):
self.bot = bot
self.db = self.bot.db
self.cache = Cacher()
self.cds = self.db[self.db.db_nam].CooldownSystem
# GNU General Public License for more details.
# You should have received a copy of the GNU General Public License
# along with this program. If not, see <http://www.gnu.org/licenses/>.
import functools
from concurrent.futures import ThreadPoolExecutor
import discord
import markovify
from sigma.core.mechanics.caching import Cacher
from sigma.core.mechanics.command import SigmaCommand
from sigma.core.utilities.data_processing import user_avatar
chain_object_cache = Cacher(True, 300)
async def impersonate(cmd: SigmaCommand, message: discord.Message, args: list):
if args:
if message.mentions:
target = message.mentions[0]
else:
target = discord.utils.find(
lambda x: x.name.lower() == ' '.join(args).lower(),
message.guild.members)
else:
target = message.author
if target:
chain_data = await cmd.db[cmd.db.db_cfg.database
]['MarkovChains'].find_one(
class CooldownControl(object):
def __init__(self, bot):
self.bot = bot
self.cmd = CommandCooldown()
self.db = self.bot.db
self.cache = Cacher()
self.cds = self.db[self.bot.cfg.db.database].CooldownSystem
async def on_cooldown(self, cmd, user):
if isinstance(user, str):
cd_name = f'cd_{cmd}_{user}'
else:
cd_name = f'cd_{cmd}_{user.id}'
entry = self.cache.get_cache(cd_name)
if entry is None:
entry = await self.cds.find_one({'name': cd_name})
if entry:
end_stamp = entry['end_stamp']
now_stamp = arrow.utcnow().timestamp
if now_stamp > end_stamp:
cooldown = False
else:
cooldown = True
else:
cooldown = False
return cooldown
async def get_cooldown(self, cmd, user):
if isinstance(user, str):
cd_name = f'cd_{cmd}_{user}'
else:
cd_name = f'cd_{cmd}_{user.id}'
entry = self.cache.get_cache(cd_name)
if entry is None:
entry = await self.cds.find_one({'name': cd_name})
if entry:
end_stamp = entry['end_stamp']
now_stamp = arrow.utcnow().float_timestamp
cooldown = end_stamp - now_stamp
if cooldown < 2:
if cooldown <= 0:
cooldown = 0.01
else:
cooldown = round(cooldown, 2)
else:
cooldown = int(cooldown)
else:
cooldown = 0
return cooldown
async def set_cooldown(self, cmd, user, amount):
if isinstance(user, str):
cd_name = f'cd_{cmd}_{user}'
else:
cd_name = f'cd_{cmd}_{user.id}'
entry = self.cache.get_cache(cd_name)
if entry:
self.cache.del_cache(cd_name)
else:
entry = await self.cds.find_one({'name': cd_name})
end_stamp = arrow.utcnow().timestamp + amount
if entry:
await self.cds.update_one({'name': cd_name},
{'$set': {
'end_stamp': end_stamp
}})
else:
cd_data = {'name': cd_name, 'end_stamp': end_stamp}
await self.cds.insert_one(cd_data)
# This program is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
# GNU General Public License for more details.
# You should have received a copy of the GNU General Public License
# along with this program. If not, see <http://www.gnu.org/licenses/>.
import arrow
import discord
from sigma.core.mechanics.caching import Cacher
from sigma.core.mechanics.command import SigmaCommand
afk_cache = Cacher()
async def afk(cmd: SigmaCommand, message: discord.Message, args: list):
afk_data = afk_cache.get_cache(message.author.id)
if not afk_data:
afk_data = await cmd.db[cmd.db.db_nam].AwayUsers.find_one(
{'user_id': message.author.id})
if args:
afk_reason = ' '.join(args)
else:
afk_reason = 'No reason stated.'
in_data = {
'user_id': message.author.id,
'timestamp': arrow.utcnow().timestamp,
'reason': afk_reason
class Database(motor.AsyncIOMotorClient):
def __init__(self, bot, db_cfg):
self.bot = bot
self.db_cfg = db_cfg
self.cache = Cacher()
if self.db_cfg.auth:
self.db_address = f'mongodb://{self.db_cfg.username}:{self.db_cfg.password}'
self.db_address += f'@{self.db_cfg.host}:{self.db_cfg.port}/'
else:
self.db_address = f'mongodb://{self.db_cfg.host}:{self.db_cfg.port}/'
super().__init__(self.db_address)
async def get_guild_settings(self, guild_id, setting_name):
guild_settings = self.cache.get_cache(guild_id)
if guild_settings is None:
guild_settings = await self[self.bot.cfg.db.database
].ServerSettings.find_one(
{'ServerID': guild_id})
self.cache.set_cache(guild_id, guild_settings)
if not guild_settings:
await self[self.bot.cfg.db.database
].ServerSettings.insert_one({'ServerID': guild_id})
setting_value = None
else:
setting_value = guild_settings.get(setting_name)
return setting_value
async def set_guild_settings(self, guild_id, setting_name, value):
guild_settings = await self[self.bot.cfg.db.database
].ServerSettings.find_one(
{'ServerID': guild_id})
if guild_settings:
update_target = {"ServerID": guild_id}
update_data = {"$set": {setting_name: value}}
await self[self.bot.cfg.db.database
].ServerSettings.update_one(update_target, update_data)
else:
update_data = {'ServerID': guild_id, setting_name: value}
await self[self.bot.cfg.db.database
].ServerSettings.insert_one(update_data)
self.cache.del_cache(guild_id)
async def get_experience(self, user, guild):
database = self[self.bot.cfg.db.database]
collection = database['ExperienceSystem']
entry = await collection.find_one({'UserID': user.id})
if entry:
global_xp = entry.get('global') or 0
guild_id = str(guild.id)
guilds = entry.get('guilds') or {}
guild_xp = guilds.get(guild_id) or 0
else:
global_xp = 0
guild_xp = 0
output = {'global': global_xp, 'guild': guild_xp}
return output
async def add_experience(self, user, guild, points, additive=True):
sabotage_file = await self[
self.db_cfg.database].SabotagedUsers.find_one({'UserID': user.id})
if not sabotage_file:
database = self[self.bot.cfg.db.database]
collection = database['ExperienceSystem']
entry = await collection.find_one({'UserID': user.id})
if entry:
global_xp = entry.get('global') or 0
guilds = entry.get('guilds') or {}
else:
await collection.insert_one({'UserID': user.id})
global_xp = 0
guilds = {}
guild_id = str(guild.id)
guild_points = guilds.get(guild_id) or 0
if additive:
global_xp += points
guild_points += points
guild_data = {guild_id: guild_points}
guilds.update(guild_data)
xp_data = {'global': global_xp, 'guilds': guilds}
update_target = {'UserID': user.id}
update_data = {'$set': xp_data}
await collection.update_one(update_target, update_data)
async def get_currency(self, user, guild):
database = self[self.bot.cfg.db.database]
collection = database['CurrencySystem']
entry = await collection.find_one({'UserID': user.id})
if entry:
global_amount = entry.get('global') or 0
current_amount = entry.get('current') or 0
guild_id = str(guild.id)
guilds = entry.get('guilds') or {}
guild_amount = guilds.get(guild_id) or 0
else:
current_amount = 0
global_amount = 0
guild_amount = 0
output = {
'current': current_amount,
'global': global_amount,
'guild': guild_amount
}
return output
async def add_currency(self, user, guild, points, additive=True):
sabotage_file = await self[
self.db_cfg.database].SabotagedUsers.find_one({'UserID': user.id})
if not sabotage_file:
database = self[self.bot.cfg.db.database]
collection = database['CurrencySystem']
entry = await collection.find_one({'UserID': user.id})
points = abs(points)
if entry:
current_amount = entry.get('current') or 0
global_amount = entry.get('global') or 0
guilds = entry.get('guilds') or {}
else:
await collection.insert_one({'UserID': user.id})
global_amount = 0
current_amount = 0
guilds = {}
guild_id = str(guild.id)
guild_points = guilds.get(guild_id) or 0
if additive:
global_amount += points
guild_points += points
current_amount += points
guild_data = {guild_id: guild_points}
guilds.update(guild_data)
xp_data = {
'current': current_amount,
'global': int(global_amount),
'guilds': guilds
}
update_target = {'UserID': user.id}
update_data = {'$set': xp_data}
await collection.update_one(update_target, update_data)
async def rmv_currency(self, user, points):
database = self[self.bot.cfg.db.database]
collection = database['CurrencySystem']
entry = await collection.find_one({'UserID': user.id})
points = abs(points)
if entry:
current_amount = entry.get('current') or 0
else:
await collection.insert_one({'UserID': user.id})
current_amount = 0
current_amount -= points
xp_data = {'current': current_amount}
update_target = {'UserID': user.id}
update_data = {'$set': xp_data}
await collection.update_one(update_target, update_data)
async def get_inventory(self, user):
inventory = await self[self.db_cfg.database
]['Inventory'].find_one({'UserID': user.id})
if not inventory:
await self[self.db_cfg.database]['Inventory'].insert_one({
'UserID':
user.id,
'Items': []
})
inventory = []
else:
inventory = inventory.get('Items')
return inventory
async def update_inv(self, user, inv):
await self[self.db_cfg.database
]['Inventory'].update_one({'UserID': user.id},
{'$set': {
'Items': inv
}})
async def add_to_inventory(self, user, item_data):
sabotage_file = await self[
self.db_cfg.database].SabotagedUsers.find_one({'UserID': user.id})
if not sabotage_file:
stamp = arrow.utcnow().timestamp
item_data.update({'Timestamp': stamp})
inv = await self.get_inventory(user)
inv.append(item_data)
await self.update_inv(user, inv)
async def del_from_inventory(self, user, item_id):
inv = await self.get_inventory(user)
for item in inv:
if item['item_id'] == item_id:
inv.remove(item)
await self.update_inv(user, inv)
async def get_inventory_item(self, user, item_file_id):
inv = await self.get_inventory(user)
output = None
for item in inv:
if item['item_file_id'].lower() == item_file_id.lower():
output = item
break
return output
def __init__(self, bot):
self.bot = bot
self.db = self.bot.db
self.cache = Cacher()
self.cds = self.db[self.bot.cfg.db.database].CooldownSystem
class ApexSigma(client_class):
def __init__(self):
super().__init__()
self.ready = False
# State attributes before initialization.
self.log = None
self.cfg = None
self.db = None
self.cool_down = None
self.music = None
self.modules = None
self.queue = ExecutionClockwork(self)
self.cache = Cacher()
# Initialize startup methods and attributes.
self.create_cache()
self.init_logger()
self.log.info('---------------------------------')
self.init_config()
self.log.info('---------------------------------')
self.loop.run_until_complete(self.init_database())
self.log.info('---------------------------------')
self.init_cool_down()
self.log.info('---------------------------------')
self.init_music()
self.log.info('---------------------------------')
self.info = Information()
self.init_modules(init=True)
self.start_time = arrow.utcnow()
self.message_count = 0
self.command_count = 0
@staticmethod
def create_cache():
if os.path.exists('cache'):
shutil.rmtree('cache')
os.makedirs('cache')
def init_logger(self):
self.log = create_logger('Sigma')
self.log.info('Logger Created')
def init_config(self):
self.log.info('Loading Configuration...')
self.cfg = init_cfg
self.log.info(f'Running as a Bot: {self.cfg.dsc.bot}')
self.log.info(f'Default Bot Prefix: {self.cfg.pref.prefix}')
self.log.info('Core Configuration Data Loaded')
async def init_database(self):
self.log.info('Connecting to Database...')
self.db = Database(self, self.cfg.db)
try:
await self.db[self.db.db_nam].collection.find_one({})
await self.db.precache_settings()
set_color_cache_coll(self.db[self.db.db_nam].ColorCache)
except ServerSelectionTimeoutError:
self.log.error('A Connection To The Database Host Failed!')
exit(errno.ETIMEDOUT)
except OperationFailure:
self.log.error('Database Access Operation Failed!')
exit(errno.EACCES)
self.log.info('Successfully Connected to Database')
def init_cool_down(self):
self.log.info('Loading Cool-down Controls...')
self.cool_down = CooldownControl(self)
self.loop.run_until_complete(self.cool_down.clean_cooldowns())
self.loop.run_until_complete(self.cool_down.cache_cooldowns())
self.log.info('Cool-down Controls Successfully Enabled')
def init_music(self):
self.log.info('Loading Music Controller...')
self.music = MusicCore(self)
self.log.info('Music Controller Initialized and Ready')
def init_modules(self, init: bool = False):
if init:
self.log.info('Loading Sigma Modules')
self.modules = PluginManager(self, init)
def is_ready(self):
try:
ready = super().is_ready()
except Exception:
ready = False
return ready
def get_all_members(self):
now = arrow.utcnow().timestamp
timestamp = self.cache.get_cache('all_members_stamp') or 0
if now > timestamp + 60:
members = list(super().get_all_members())
self.cache.set_cache('all_members', members)
self.cache.set_cache('all_members_stamp', now)
else:
members = self.cache.get_cache('all_members')
return members
def get_all_channels(self):
now = arrow.utcnow().timestamp
timestamp = self.cache.get_cache('all_channels_stamp') or 0
if now > timestamp + 60:
channels = list(super().get_all_channels())
self.cache.set_cache('all_channels', channels)
self.cache.set_cache('all_channels_stamp', now)
else:
channels = self.cache.get_cache('all_channels')
return channels
def run(self):
try:
self.log.info('Connecting to Discord Gateway...')
super().run(self.cfg.dsc.token, bot=self.cfg.dsc.bot)
except discord.LoginFailure:
self.log.error('Invalid Token!')
exit(errno.EPERM)
async def on_connect(self):
event_name = 'connect'
if event_name in self.modules.events:
for event in self.modules.events[event_name]:
self.loop.create_task(event.execute())
async def on_shard_ready(self, shard_id: int):
self.log.info(f'Connection to Discord Shard #{shard_id} Established')
event_name = 'shard_ready'
self.loop.create_task(self.queue.event_runner(event_name, shard_id))
async def on_ready(self):
self.ready = True
self.log.info('---------------------------------')
self.log.info('Apex Sigma Fully Loaded and Ready')
self.log.info('---------------------------------')
self.log.info(f'User Account: {self.user.name}#{self.user.discriminator}')
self.log.info(f'User Snowflake: {self.user.id}')
self.log.info('---------------------------------')
self.log.info('Launching On-Ready Modules...')
self.loop.create_task(self.queue.event_runner('ready'))
self.log.info('Launching DB-Init Modules...')
self.loop.create_task(self.queue.event_runner('dbinit'))
self.log.info('All On-Ready Module Loops Created')
self.log.info('---------------------------------')
async def on_message(self, message: discord.Message):
self.message_count += 1
if not message.author.bot:
self.loop.create_task(self.queue.event_runner('message', message))
if self.user.mentioned_in(message):
self.loop.create_task(self.queue.event_runner('mention', message))
await self.queue.command_runner(message)
async def on_message_edit(self, before: discord.Message, after: discord.Message):
if not before.author.bot:
self.loop.create_task(self.queue.event_runner('message_edit', before, after))
async def on_message_delete(self, message: discord.Message):
if not message.author.bot:
self.loop.create_task(self.queue.event_runner('message_delete', message))
async def on_member_join(self, member: discord.Member):
if not member.bot:
self.loop.create_task(self.queue.event_runner('member_join', member))
async def on_member_remove(self, member: discord.Member):
if not member.bot:
self.loop.create_task(self.queue.event_runner('member_remove', member))
async def on_member_update(self, before: discord.Member, after: discord.Member):
if not before.bot:
self.loop.create_task(self.queue.event_runner('member_update', before, after))
async def on_guild_join(self, guild: discord.Guild):
self.loop.create_task(self.queue.event_runner('guild_join', guild))
async def on_guild_remove(self, guild: discord.Guild):
self.loop.create_task(self.queue.event_runner('guild_remove', guild))
async def on_guild_update(self, before: discord.Guild, after: discord.Guild):
self.loop.create_task(self.queue.event_runner('guild_update', before, after))
async def on_voice_state_update(self, member: discord.Member, b: discord.VoiceState, a: discord.VoiceState):
if not member.bot:
self.loop.create_task(self.queue.event_runner('voice_state_update', member, b, a))
async def on_reaction_add(self, reaction: discord.Reaction, user: discord.User):
if not user.bot:
self.loop.create_task(self.queue.event_runner('reaction_add', reaction, user))
async def on_reaction_remove(self, reaction: discord.Reaction, user: discord.User):
if not user.bot:
self.loop.create_task(self.queue.event_runner('reaction_remove', reaction, user))
async def on_raw_reaction_add(self, payload: RawReactionActionEvent):
self.loop.create_task(self.queue.event_runner('raw_reaction_add', payload))
async def on_raw_reaction_remove(self, payload: RawReactionActionEvent):
self.loop.create_task(self.queue.event_runner('raw_reaction_remove', payload))
# This program is free software: you can redistribute it and/or modify
# it under the terms of the GNU General Public License as published by
# the Free Software Foundation, either version 3 of the License, or
# (at your option) any later version.
# This program is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
# GNU General Public License for more details.
# You should have received a copy of the GNU General Public License
# along with this program. If not, see <http://www.gnu.org/licenses/>.
from sigma.core.mechanics.caching import Cacher
perm_cache = Cacher()
def generate_default_data(message):
return {
'server_id': message.guild.id,
'disabled_commands': [],
'disabled_modules': [],
'command_exceptions': {},
'module_exceptions': {},
}
def generate_cmd_data(cmd_name):
return {cmd_name: {'users': [], 'channels': [], 'roles': []}}
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
# GNU General Public License for more details.
# You should have received a copy of the GNU General Public License
# along with this program. If not, see <http://www.gnu.org/licenses/>.
import asyncio
import arrow
import discord
from sigma.core.mechanics.caching import Cacher
from sigma.core.mechanics.event import SigmaEvent
decay_clock_running = False
decay_cache = Cacher()
async def decay_checker(ev: SigmaEvent):
global decay_clock_running
if not decay_clock_running:
decay_clock_running = True
ev.bot.loop.create_task(decay_checker_clock(ev))
async def decay_checker_clock(ev: SigmaEvent):
while True:
if ev.bot.is_ready():
try:
now = arrow.utcnow().timestamp
dmsgs = decay_cache.get_cache('all')
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
# GNU General Public License for more details.
# You should have received a copy of the GNU General Public License
# along with this program. If not, see <http://www.gnu.org/licenses/>.
import arrow
import discord
from humanfriendly.tables import format_pretty_table as boop
from sigma.core.mechanics.caching import Cacher
from sigma.core.mechanics.command import SigmaCommand
from sigma.modules.moderation.server_settings.filters.edit_name_check import clean_name
tcrlb_cache = Cacher()
async def topcurrency(cmd: SigmaCommand, message: discord.Message, args: list):
value_name = cmd.bot.cfg.pref.currency
sort_key = 'global'
lb_category = 'Global'
search = {}
if args:
if args[0].lower() == 'local':
sort_key = f'guilds.{message.guild.id}'
search = {sort_key: {'$exists': True}}
lb_category = message.guild.name
elif args[0].lower() == 'total':
sort_key = 'total'
lb_category = 'Total'
class Database(motor.AsyncIOMotorClient):
def __init__(self, bot, db_cfg: DatabaseConfig):
self.bot = bot
self.db_cfg = db_cfg
self.db_nam = self.db_cfg.database
self.cache = Cacher()
if self.db_cfg.auth:
self.db_address = f'mongodb://{self.db_cfg.username}:{self.db_cfg.password}'
self.db_address += f'@{self.db_cfg.host}:{self.db_cfg.port}/'
else:
self.db_address = f'mongodb://{self.db_cfg.host}:{self.db_cfg.port}/'
super().__init__(self.db_address)
async def get_prefix(self, message: discord.Message):
prefix = self.bot.cfg.pref.prefix
if message.guild:
pfx_search = await self.get_guild_settings(message.guild.id, 'prefix')
if pfx_search:
prefix = pfx_search
return prefix
async def precache_settings(self):
self.bot.log.info('Pre-Caching all guild settings...')
all_settings = await self[self.db_cfg.database].ServerSettings.find({}).to_list(None)
for setting_file in all_settings:
guild_id = setting_file.get('server_id')
if guild_id:
self.cache.set_cache(guild_id, setting_file)
self.bot.log.info(f'Finished pre-caching {len(all_settings)} guild settings.')
async def get_guild_settings(self, guild_id, setting_name):
guild_settings = self.cache.get_cache(guild_id)
if guild_settings is None:
guild_settings = await self[self.bot.cfg.db.database].ServerSettings.find_one({'server_id': guild_id}) or {}
self.cache.set_cache(guild_id, guild_settings)
if not guild_settings:
setting_value = None
else:
setting_value = guild_settings.get(setting_name)
return setting_value
async def set_guild_settings(self, guild_id, setting_name, value):
guild_settings = await self[self.bot.cfg.db.database].ServerSettings.find_one({'server_id': guild_id})
if guild_settings:
update_target = {"server_id": guild_id}
update_data = {"$set": {setting_name: value}}
await self[self.bot.cfg.db.database].ServerSettings.update_one(update_target, update_data)
else:
update_data = {'server_id': guild_id, setting_name: value}
await self[self.bot.cfg.db.database].ServerSettings.insert_one(update_data)
self.cache.del_cache(guild_id)
async def get_experience(self, user, guild):
collection = self[self.bot.cfg.db.database].ExperienceSystem
entry = await collection.find_one({'user_id': user.id}) or {}
global_xp = entry.get('global', 0)
guild_id = str(guild.id)
guilds = entry.get('guilds', {})
guild_xp = guilds.get(guild_id, 0)
total_xp = entry.get('total', 0)
output = {'global': global_xp, 'guild': guild_xp, 'total': total_xp}
return output
async def add_experience(self, user, guild, points, additive=True):
sabotage_file = await self[self.db_cfg.database].SabotagedUsers.find_one({'user_id': user.id})
if not sabotage_file:
collection = self[self.bot.cfg.db.database].ExperienceSystem
entry = await collection.find_one({'user_id': user.id}) or {}
if not entry:
await collection.insert_one({'user_id': user.id})
total_xp = entry.get('total', 0)
global_xp = entry.get('global', 0)
guilds = entry.get('guilds', {})
guild_id = str(guild.id)
guild_points = guilds.get(guild_id, 0)
if additive:
global_xp += points
guild_points += points
total_xp += points
guild_data = {guild_id: guild_points}
guilds.update(guild_data)
xp_data = {'global': global_xp, 'guilds': guilds, 'total': total_xp}
update_target = {'user_id': user.id}
update_data = {'$set': xp_data}
await collection.update_one(update_target, update_data)
async def get_currency(self, user, guild):
collection = self[self.bot.cfg.db.database].CurrencySystem
entry = await collection.find_one({'user_id': user.id}) or {}
global_amount = entry.get('global', 0)
current_amount = entry.get('current', 0)
guild_id = str(guild.id)
guilds = entry.get('guilds', {})
guild_amount = guilds.get(guild_id, 0)
total_amount = entry.get('total', 0)
output = {'current': current_amount, 'global': global_amount, 'guild': guild_amount, 'total': total_amount}
return output
async def add_currency(self, user, guild, points, additive=True):
sabotage_file = await self[self.db_cfg.database].SabotagedUsers.find_one({'user_id': user.id})
if not sabotage_file:
collection = self[self.bot.cfg.db.database].CurrencySystem
points = abs(points)
entry = await collection.find_one({'user_id': user.id}) or {}
if not entry:
await collection.insert_one({'user_id': user.id})
current_amount = entry.get('current', 0)
global_amount = entry.get('global', 0)
total_amount = entry.get('total', 0)
guilds = entry.get('guilds', {})
guild_id = str(guild.id)
guild_points = guilds.get(guild_id, 0)
if additive:
global_amount += points
guild_points += points
total_amount += points
current_amount += points
guild_data = {guild_id: guild_points}
guilds.update(guild_data)
xp_data = {'current': current_amount, 'global': int(global_amount), 'guilds': guilds, 'total': total_amount}
update_target = {'user_id': user.id}
update_data = {'$set': xp_data}
await collection.update_one(update_target, update_data)
async def rmv_currency(self, user, points):
collection = self[self.bot.cfg.db.database].CurrencySystem
points = abs(points)
entry = await collection.find_one({'user_id': user.id}) or {}
if not entry:
await collection.insert_one({'user_id': user.id})
current_amount = entry.get('current', 0)
current_amount -= points
xp_data = {'current': current_amount}
update_target = {'user_id': user.id}
update_data = {'$set': xp_data}
await collection.update_one(update_target, update_data)
async def get_inventory(self, user):
inventory = await self[self.db_cfg.database].Inventory.find_one({'user_id': user.id}) or {}
if not inventory:
await self[self.db_cfg.database].Inventory.insert_one({'user_id': user.id, 'items': []})
inventory = inventory.get('items', [])
return inventory
async def update_inv(self, user, inv):
await self[self.db_cfg.database].Inventory.update_one({'user_id': user.id}, {'$set': {'items': inv}})
async def add_to_inventory(self, user, item_data):
sabotage_file = await self[self.db_cfg.database].SabotagedUsers.find_one({'user_id': user.id})
if not sabotage_file:
stamp = arrow.utcnow().timestamp
item_data.update({'timestamp': stamp})
inv = await self.get_inventory(user)
inv.append(item_data)
await self.update_inv(user, inv)
async def del_from_inventory(self, user, item_id):
inv = await self.get_inventory(user)
for item in inv:
if item.get('item_id') == item_id:
inv.remove(item)
await self.update_inv(user, inv)
async def get_inventory_item(self, user, item_file_id):
inv = await self.get_inventory(user)
output = None
for item in inv:
if item.get('item_file_id').lower() == item_file_id.lower():
output = item
break
return output
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
# GNU General Public License for more details.
# You should have received a copy of the GNU General Public License
# along with this program. If not, see <http://www.gnu.org/licenses/>.
import arrow
import discord
from humanfriendly.tables import format_pretty_table as boop
from sigma.core.mechanics.caching import Cacher
from sigma.core.mechanics.command import SigmaCommand
from sigma.modules.moderation.server_settings.filters.name_check_clockwork import clean_name
tcklb_cache = Cacher()
async def topcookies(cmd: SigmaCommand, message: discord.Message, args: list):
value_name = 'Cookies'
sort_key = 'Cookies'
lb_category = 'Global'
localed = False
if args:
if args[0].lower() == 'total':
sort_key = 'Total'
lb_category = 'Total'
elif args[0].lower() == 'local':
lb_category = 'Local'
localed = True
cache_key = message.guild.id if localed else sort_key
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
# GNU General Public License for more details.
# You should have received a copy of the GNU General Public License
# along with this program. If not, see <http://www.gnu.org/licenses/>.
import discord
from humanfriendly.tables import format_pretty_table as boop
from sigma.core.mechanics.caching import Cacher
from sigma.core.mechanics.command import SigmaCommand
from sigma.core.utilities.data_processing import get_image_colors
from sigma.modules.moderation.server_settings.filters.name_check_clockwork import clean_name
txp_cache = Cacher(True, 3600)
async def topexperience(cmd: SigmaCommand, message: discord.Message,
args: list):
value_name = 'Experience'
sort_key = 'global'
lb_icon = cmd.bot.user.avatar_url
lb_category = 'Global'
search = {}
if args:
if args[0].lower() == 'local':
sort_key = f'guilds.{message.guild.id}'
search = {sort_key: {'$exists': True}}
lb_icon = message.guild.icon_url or lb_icon
lb_category = message.guild.name
