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():