def __init__(self, payload: dict, client: discord.Client):
self.client = client
self.id: int = getattr(discord.utils, "_get_as_snowflake")(payload, "id")
self.version = payload.get("version")
self.type = payload.get("type")
self.token = payload.get("token")
self.application = getattr(discord.utils, "_get_as_snowflake")(payload, "application_id")
self._state: ConnectionState = getattr(client, "_connection")
self.guild_id = payload.get("guild_id")
self.channel_id = payload.get("channel_id")
if self.guild_id is not None:
self.guild: Optional[discord.Guild] = self.client.get_guild(int(self.guild_id))
else:
self.guild: Optional[discord.Guild] = None
self.channel = self._state.get_channel(int(self.channel_id))
if self.guild is not None:
member = payload.get("member")
self.author = discord.Member(data=member, state=self._state, guild=self.guild)
else:
user = payload.get("user")
self.author = discord.User(data=user, state=self._state)
self.created_at = discord.utils.snowflake_time(self.id)
self.deferred = False
self.responded = False
data = InteractionData(interaction_token=self.token, interaction_id=self.id, application_id=self.application)
self.http = HttpClient(http=self.client.http, data=data)
def __init__(self, _http: http.SlashCommandRequest, _json: dict,
_discord: typing.Union[discord.Client, commands.Bot], logger):
self.__token = _json["token"]
self.message = None # Should be set later.
self.name = self.command = self.invoked_with = _json["data"]["name"]
self.args = []
self.kwargs = {}
self.subcommand_name = self.invoked_subcommand = self.subcommand_passed = None
self.subcommand_group = self.invoked_subcommand_group = self.subcommand_group_passed = None
self.interaction_id = _json["id"]
self.command_id = _json["data"]["id"]
self._http = _http
self.bot = _discord
self._logger = logger
self.deferred = False
self.responded = False
self._deferred_hidden = False # To check if the patch to the deferred response matches
self.guild_id = int(
_json["guild_id"]) if "guild_id" in _json.keys() else None
self.author_id = int(_json["member"]["user"]["id"] if "member" in
_json.keys() else _json["user"]["id"])
self.channel_id = int(_json["channel_id"])
if self.guild:
self.author = discord.Member(data=_json["member"],
state=self.bot._connection,
guild=self.guild)
elif self.guild_id:
self.author = discord.User(data=_json["member"]["user"],
state=self.bot._connection)
else:
self.author = discord.User(data=_json["user"],
state=self.bot._connection)
def __init__(self, *, cog, data: dict):
self.cog = cog
self.bot = cog.bot
self.http: SlashHTTP = cog.http
self._state: discord.state.AutoShardedConnectionState = self.bot._connection
self.id = int(data["id"])
self.version = data["version"]
self._token = data["token"]
self._original_data = data
self.guild_id = guild_id = discord.utils._get_as_snowflake(
data, "guild_id")
self.channel_id = discord.utils._get_as_snowflake(data, "channel_id")
self.application_id = discord.utils._get_as_snowflake(
data, "application_id")
if guild_id:
member_data = data["member"]
self.author_id = int(member_data["user"]["id"])
self.author = discord.Member(data=member_data,
state=self._state,
guild=self.guild)
else:
member_data = data["user"]
self.author_id = int(member_data["id"])
self.author = discord.User(data=member_data, state=self._state)
self.interaction_data = data["data"]
self.sent = False
self.deferred = False
self.completed = False
def __init__(self, *, cog, data: dict):
self.cog = cog
self.bot = cog.bot
self.http: SlashHTTP = cog.http
self._state: discord.state.AutoShardedConnectionState = self.bot._connection
self.id = int(data["id"])
self.version = data["version"]
self.__token = data["token"]
self._original_data = data
self.guild_id = guild_id = discord.utils._get_as_snowflake(data, "guild_id")
self.channel_id = discord.utils._get_as_snowflake(data, "channel_id")
if guild_id:
member_data = data["member"]
self.author_id = int(member_data["user"]["id"])
self.author = discord.Member(data=member_data, state=self._state, guild=self.guild)
else:
member_data = data["user"]
self.author_id = int(member_data["id"])
self.author = discord.User(data=member_data, state=self._state)
self.sent = False
self.interaction_data = interaction_data = data["data"]
self.command_name = interaction_data["name"]
self.command_id = int(interaction_data["id"])
self.options: List[ResponseOption] = []
self._parse_options(
interaction_data.get("options", []), interaction_data.get("resolved", {})
)
async def on_guild_join(self, guild):
await self.database.update_guild(guild)
for member in guild.members:
await self.database.update_guild_member(member, True, False)
if guild.me.guild_permissions.ban_members:
banned = await guild.bans()
for ban in banned:
member = discord.Member(user={
"username": ban.name,
"id": ban.id,
"discriminator": ban.discriminator,
"avatar": ban.avatar,
"bot": ban.bot
})
await self.database.update_guild_member(member, False, True)
for channel in list(guild.channels):
chanperm = channel.permissions_for(channel.guild.me)
if not chanperm.read_messages or not chanperm.read_message_history or not isinstance(channel, discord.channel.TextChannel):
continue
async for message in channel.history(limit=50, reverse=True):
try:
await self.database.push_message(message)
except:
pass
await self.postStats()
async def setpermlevel(ctx, player, level, **_):
member = discord.Member(user={"id": player.id})
permission_index = level - 1
permission_list = dueutil.permissions.permissions
if permission_index < len(permission_list):
permission = permission_list[permission_index]
dueutil.permissions.give_permission(member, permission)
await util.say(
ctx.channel, "**" + player.name_clean +
"** permission level set to ``" + permission.value[1] + "``.")
if permission == Permission.DUEUTIL_MOD:
await awards.give_award(ctx.channel, player, "Mod",
"Become an mod!")
await util.duelogger.info("**%s** is now a DueUtil mod!" %
player.name_clean)
elif "Mod" in player.awards:
player.awards.remove("Mod")
if permission == Permission.DUEUTIL_ADMIN:
await awards.give_award(ctx.channel, player, "Admin",
"Become an admin!")
await util.duelogger.info("**%s** is now a DueUtil admin!" %
player.name_clean)
elif "Admin" in player.awards:
player.awards.remove("Admin")
else:
raise util.DueUtilException(ctx.channel, "Permission not found")
async def reminder_bot(channel, remindermessage, time, timerauthor):
try:
await asyncio.sleep(time)
remindermessage = "Reminder:" + remindermessage.content
userid = "<" + timerauthor.id + ">"
await client.send_message(channel,
'%s I have a reminder for you ' % userid)
await client.send_message(channel, remindermessage)
await client.send_message(channel,
"Did you finish? in y/n BE TRUTHFUL")
msg = await client.wait_for_message(author=timerauthor)
if msg.content == "y":
await client.send_message(channel, "Good Job")
elif msg.content == "n":
await client.send_message(
channel,
"You will be banned, contact an admin+ to rejoin once you finish your work"
)
await client.ban(discord.Member(id=timerauthor.id), 1)
else:
await client.send_message(
channel,
"You did not answer y/n, please call the function again")
except:
print("Unexpected error:", sys.exc_info()[0])
client.send_message(
channel, "Your rank is probably higher than me so I cant ban you")
def parse_member_update(self, data):
"""Replacement for hacky https://github.com/Rapptz/discord.py/blob/master/discord/state.py#L547"""
guild_id = utils._get_as_snowflake(data, "guild_id")
guild = self.bot._connection._get_guild(guild_id)
user_data = data["user"]
member_id = int(user_data["id"])
user = self.bot.get_user(member_id)
if guild is None and user is None:
return
elif guild is None and user is not None:
user.name = user_data["username"]
user.discriminator = user_data["discriminator"]
user.avatar = user_data["avatar"]
else:
member = guild.get_member(member_id)
if member is None:
if "username" not in user_data:
# sometimes we receive 'incomplete' member data post-removal.
# skip these useless cases.
return
# https://github.com/Rapptz/discord.py/blob/master/discord/member.py#L214
member = discord.Member(data=data,
guild=guild,
state=self.bot._connection)
guild._add_member(member)
member._user.name = user_data["username"]
member._user.discriminator = user_data["discriminator"]
member._user.avatar = user_data["avatar"]
def banner_restricted(self, player):
member = discord.Member(user={"id": player.id})
return (
(not self.admin_only or self.admin_only
and permissions.has_permission(member, Permission.DUEUTIL_ADMIN))
and
(not self.mod_only or self.mod_only
and permissions.has_permission(member, Permission.DUEUTIL_MOD)))
def to_member(self):
"""
Returns a fake discord member.
This is to cheat the perms system.
Will not work with perms that check for roles.
"""
return discord.Member(user={'id': self.id,
'username': self.name,
'discriminator': 0000})
async def answerreport(ctx, player, message, **details):
"""
[CMD_KEY]answerreport (player) (message)
Lets bot owners answer bug reports and suggestions.
[PERM]
"""
ctx.author = discord.Member(user={"id": player.id})
ctx.author.server = ctx.server
await util.say(ctx.author, "%s" % (message))
await util.say(ctx.channel, "Sent!")
def _handle_option_user(
self, data: dict, option: ResponseOption, resolved: Dict[str, Dict[str, dict]]
):
user_id = int(data["value"])
resolved_user = resolved["users"][data["value"]]
if self.guild_id:
if user := self.guild.get_member(user_id):
pass
else:
user = discord.Member(guild=self.guild, data=resolved_user, state=self._state)
self.guild._add_member(user)
def __init__(self, _http: http.SlashCommandRequest, _json: dict,
_discord: typing.Union[discord.Client, commands.Bot], logger):
"""
Context of a component interaction.\n
Similar to :class:`.SlashContext`
.. warning::
Do not manually init this model.
:ivar message_id: Message ID that the component is attached to.
:ivar custom_id: The custom ID of the component.
:ivar interaction_id: Interaction ID of the component message.
:ivar bot: discord.py client.
:ivar _http: :class:`.http.SlashCommandRequest` of the client.
:ivar _logger: Logger instance.
:ivar deferred: Whether the interaction is currently deferred (loading state)
:ivar _deferred_hidden: Internal var to check that state stays the same
:ivar responded: Whether you have responded with a message to the interaction.
:ivar guild_id: Guild ID of the command message. If the command was invoked in DM, then it is ``None``
:ivar author_id: User ID representing author of the command message.
:ivar channel_id: Channel ID representing channel of the command message.
:ivar author: User or Member instance of the command invoke.
"""
self.__token = _json["token"]
self.message_id = int(_json["message"]["id"])
self.custom_id = self.name = self.command = self.invoked_with = _json[
"data"]["custom_id"]
self.interaction_id = _json["id"]
self._http = _http
self.bot = _discord
self._logger = logger
self.deferred = False
self.responded = False
self._deferred_hidden = False # To check if the patch to the deferred response matches
self.guild_id = int(
_json["guild_id"]) if "guild_id" in _json.keys() else None
self.author_id = int(_json["member"]["user"]["id"] if "member" in
_json.keys() else _json["user"]["id"])
self.channel_id = int(_json["channel_id"])
if self.guild:
self.author = discord.Member(data=_json["member"],
state=self.bot._connection,
guild=self.guild)
elif self.guild_id:
self.author = discord.User(data=_json["member"]["user"],
state=self.bot._connection)
else:
self.author = discord.User(data=_json["user"],
state=self.bot._connection)
def target(self, target_type, target_id: int = None):
if target_id is None:
target_id = self.target_id
if target_type == "message" and "messages" in self._resolved:
resolved = self._resolved.get("messages", {})
data = Message(state=self._state, channel=self.channel, data=resolved.get(target_id))
return data
elif target_type == "members" and "members" in self._resolved and self.guild_id is not None:
resolved = self._resolved.get("members", {})
data = discord.Member(data=resolved.get(target_id), state=self._state, guild=self.guild)
return data
elif target_type == "users" and "users" in self._resolved:
resolved = self._resolved.get("users", {})
data = discord.User(data=resolved.get(target_id), state=self._state)
return data
def __init__(self, *, data, guild, state):
self.members: Dict[int, discord.Member] = {}
self.users: Dict[int, discord.User] = {}
self.roles: Dict[int, discord.Role] = {}
self.channels: Dict[int, discord.abc.GuildChannel] = {}
self.messages: Dict[int, discord.Message] = {}
users = data.get("users", {})
members = data.get("members", {})
roles = data.get("roles", {})
channels = data.get("channels", {})
messages = data.get("messages", {})
for ID, data in users.items():
user_id = int(ID)
if ID in members:
self.members[user_id] = discord.Member(
data={
**members[ID], "user": data
},
guild=guild,
state=state # type: ignore
)
else:
self.users[user_id] = discord.User(state=state, data=data)
for ID, data in roles.items():
self.roles[int(ID)] = discord.Role(guild=guild,
state=state,
data=data)
for ID, data in channels.items():
data["position"] = 0
factory, ch_type = discord.channel._channel_factory(data["type"])
if factory:
self.channels[int(ID)] = factory(guild=guild,
data=data,
state=state)
for ID, data in messages.items():
channel_id = int(data["channel_id"])
channel = guild.get_channel(channel_id) if guild else None
if channel is None:
channel = state.get_channel(channel_id)
self.messages[int(ID)] = discord.Message(state=state,
channel=channel,
data=data)
def make_member(user, guild, nick=None, roles=None):
if roles is None:
roles = []
roles = list(map(lambda x: x.id, roles))
data = facts.make_member_dict(guild, user, roles, nick=nick)
state = get_state()
parse_guild_member_add(state, data)
#my_object = DefaultMunch.fromDict(data, discord.User(data = data["user"], state = state))
#my_user = {discord.User(data = data["user"], state = state)
#guild.member_count+=1
guild.members.append("test")
my_object = discord.Member(data=data, state=state, guild=guild)
# print("my_object.user.id", my_object.user.id)
return my_object #guild.get_member(user.id)
def parse_guild_member_add(state, data):
# print("parse_guild_member_add called")
guild = state._get_guild(int(data['guild_id']))
if guild is None:
log.debug(
'GUILD_MEMBER_ADD referencing an unknown guild ID: %s. Discarding.',
data['guild_id'])
return
member = discord.Member(guild=guild, data=data, state=state)
if state._member_cache_flags.joined:
guild._add_member(member)
guild._add_member(member)
try:
guild._member_count += 1
except AttributeError:
pass
state.dispatch('member_join', member)
async def __init__(self, client: SlashBot, cmd: Command, event: dict):
self.client = client
self.command = cmd
self.id = int(event['id'])
try:
self.guild = await self.client.fetch_guild(int(event['guild_id']))
except discord.HTTPException:
self.guild = discord.Object(event['guild_id'])
logger.debug('Fetching guild %s for interaction %s failed',
self.guild.id, self.id)
try:
self.channel = await self.client.fetch_channel(
int(event['channel_id']))
except discord.HTTPException:
self.channel = discord.Object(event['channel_id'])
logger.debug('Fetching channel %s for interaction %s failed',
self.channel.id, self.id)
try:
self.author = await self.guild.fetch_member(
int(event['member']['user']['id']))
except (discord.HTTPException, AttributeError):
self.author = discord.Member(data=event['member'],
guild=self.guild,
state=self.client._connection)
logger.debug('Fetching member for interaction %s failed', self.id)
self.token = event['token']
# construct options into function-friendly form
await self._kwargs_from_options(event['data'].get('options', []))
try:
self.me = await self.guild.fetch_member(self.client.user.id)
except (discord.HTTPException, AttributeError):
self.me = None
logger.debug(
'Fetching member %s (me) in guild %s '
'for interaction %s failed', self.client.user.id,
self.guild.id, self.id)
self.webhook = None
self.mention = f'&{self.name}'
def __lt__(self, other):
"""Simplified position-based comparisons similar to those of `discord.Role`."""
return self.position < other.position
def __ge__(self, other):
"""Simplified position-based comparisons similar to those of `discord.Role`."""
return self.position >= other.position
# Create a Member instance to get a realistic Mock of `discord.Member`
member_data = {'user': '******', 'roles': [1]}
state_mock = unittest.mock.MagicMock()
member_instance = discord.Member(data=member_data,
guild=guild_instance,
state=state_mock)
class MockMember(CustomMockMixin, unittest.mock.Mock, ColourMixin,
HashableMixin):
"""
A Mock subclass to mock Member objects.
Instances of this class will follow the specifications of `discord.Member` instances. For more
information, see the `MockGuild` docstring.
"""
spec_set = member_instance
def __init__(self,
roles: Optional[Iterable[MockRole]] = None,
async def count(ctx, number=0, send="", **details):
"""
[CMD_KEY]count (optional: number) (optional: message for owner)
Lets you add to the DueUtil count! You can only do so 25 times per day.
Each time you successfully count, you will gain a bonus for atk, strg, and accy based on how many times you've counted correctly.
You can view the number that you should count with the basic ``!count``.
If you want, you can have the bot DM the owner with a message, such as "Great job updating Due!", or "We love your new updates!"
[PERM]
"""
player = details["author"]
theel = players.find_player("376166105917554701")
if not hasattr(player, "counts"):
player.counts = 0
if not hasattr(player, "count"):
player.count = 0
if not hasattr(theel, "count"):
theel.count = 0
x = int(theel.count + 1)
if number == 0:
await util.say(ctx.channel, "The current number that count is at is %s." % (x))
return
elif number == x:
if player.count <= 25:
theel.count += 1
if player.id != "376166105917554701":
player.count += 1
player.counts += 1
try:
y = (player.counts / math.log(player.counts, 1.05))
except ZeroDivisionError:
y = .1
except ValueError:
y = .1
a = y * 1.2
try:
z = random.uniform(y, a) * math.log(player.level, 1.5)
except ValueError:
z = random.uniform(y, a)
player.attack += z
player.strg += z
player.accy += z
player.exp += (z * 300)
await game.check_for_level_up(ctx, player)
theel.save()
player.save()
b = round(z, 2)
message = "You gained " + str(b) + " of each of Attack, Strength, and Accuracy!"
language = player.language
if language != "en":
message = util.translate(message, language)
await util.say(ctx.channel, "%s" % (message))
if send != "":
theelid = 376166105917554701
ctx.author = discord.Member(user={"id": theelid})
ctx.author.server = ctx.server
await util.say(ctx.author, "%s - from %s" % (send, player.id))
else:
message = "You have counted 25 times today!"
language = player.language
if language != "en":
message = util.translate(message, language)
await util.say(ctx.channel, "%s" % (message))
else:
message = "Your count was incorrect! You should have written"
message2 = "(Sometimes people from other servers may steal your count)"
language = player.language
if language != "en":
message = util.translate(message, language)
message2 = util.translate(message2, language)
await util.say(ctx.channel, "%s %s %s" % (message, x, message2))
def __init__(self, **kwargs) -> None:
default_kwargs = {
'id': next(self.discord_id),
'name': 'role',
'position': 1,
'colour': discord.Colour(0xdeadbf),
'permissions': discord.Permissions(),
}
super().__init__(**collections.ChainMap(kwargs, default_kwargs))
# Create a `discord.Member` instance
member_data = {'user': '******', 'roles': [1]}
member_instance = discord.Member(data=member_data,
guild=guild_instance,
state=unittest.mock.MagicMock())
class MockMember(CustomMock, unittest.mock.Mock):
"""A mock subclass to mock `discord.Member` objects."""
def __init__(self, roles=None, **kwargs) -> None:
default_kwargs = {
'name': 'member',
'display_name': 'user',
'id': next(self.discord_id),
'bot': False
}
super().__init__(**collections.ChainMap(kwargs, default_kwargs))
self.roles = [MockRole(name="@everyone", position=1, id=0)]
while len(shard_clients) <= loaded_clients:
pass
while not loaded():
pass
loader.load_modules(packages=loader.COMMANDS)
util.logger.info("Ready after %ds", time.time() - start_time)
### Tasks
loop = asyncio.get_event_loop()
from dueutil import tasks
for task in tasks.tasks:
asyncio.ensure_future(task(), loop=loop)
loop.run_forever()
def loaded():
return len(shard_clients) == shard_count and all(
client.loaded for client in shard_clients)
if __name__ == "__main__":
util.logger.info("Starting DueUtil!")
config = gconf.other_configs
bot_key = config["botToken"]
shard_count = config["shardCount"]
shard_names = config["shardNames"]
owner = discord.Member(user={"id": config["owner"]})
if not permissions.has_permission(owner, Permission.DUEUTIL_ADMIN):
permissions.give_permission(owner, Permission.DUEUTIL_ADMIN)
util.load(shard_clients)
run_due()
import discord
"""
MUMMY MUMMY LOOK AT ME!!!!
I'm UNIT TESTING
Mum: That's nice dear
"""
test_player = Player(discord.Member(user={"id":"000TEST","name":"Testy Mc Test Face"}),no_save=True)
def test(expect=None):
def tester(test_func):
output = test_func()
if output != expect:
print("TEST FAILED!")
print("EXPECTED")
print(expect)
print("GOT")
print(output)
else:
print("Test passed")
return tester
@test(expect="Testy Mc Test Face")
def name_test():
