updatet discord to 1.7.5.2

- Fixed problems with permissions (the reason was a change of the keywords in api-v9).
- added a function to create a `styled timestamp` (in utils.py)
- changed the default value of guild_id in the interaction from `None` to `0`.

Author: mccoderpy

discord/abc.py

@@ -553,7 +553,6 @@ def permissions_for(self, member):
         if not base.read_messages:
             denied = Permissions.all_channel()
             base.value &= ~denied.value
-
         return base
 
     async def delete(self, *, reason=None):

discord/enums.py

@@ -35,6 +35,7 @@
     'ButtonStyle',
     'PermissionType',
     'InteractionCallbackType',
+    'TimestampStyle',
     'MessageType',
     'VoiceRegion',
     'SpeakingState',
@@ -267,6 +268,31 @@ def __int__(self):
         return getattr(self, 'value')
 
 
+class TimestampStyle(Enum):
+
+    """The Style to use in :meth:`discord.utils.styled_timestamp`
+
+    See Also:  `The Discord-API-Documentation <https://discord.com/developers/docs/reference#message-formating-timestamp-styles>`_
+    """
+
+    short_time  = 't'
+    long_time   = 'T'
+    short_date  = 'd'
+    long_date   = 'D'
+    short       = 'f'
+    long        = 'F'
+    relative    = 'R'
+
+    def __repr__(self):
+        return getattr(self, 'name')
+
+    def __str__(self):
+        return getattr(self, 'value')
+
+
+    @classmethod
+    def from_value(cls, value):
+        return try_enum(cls, value)
 
 
 class MessageType(Enum):

discord/interactions.py

@@ -75,11 +75,11 @@ def __init__(self, state, data):
         self._user = data.get('user', self._member.get('user', None) if self._member else None)
         self.user_id = int(self._user['id'])
         self.__interaction_id = int(data.get('id'))
-        self.guild_id = int(data.get('guild_id', None))
+        self.guild_id = int(data.get('guild_id', 0))
         self.channel_id = int(data.get('channel_id', 0))
         self.__application_id = int(data.get('application_id'))
         self.message: typing.Union[Message, EphemeralMessage] = EphemeralMessage() if self.message_is_hidden else None
-        self.member: typing.Optional[Member] = None
+        self.member: typing.Optional[Member]  = None
         self.user: typing.Optional[User] = None
         self.deferred = False
         self.deferred_hidden = False
@@ -107,8 +107,8 @@ async def defer(self, response_type: any([InteractionCallbackType.deferred_msg_w
 
         if isinstance(response_type, int):
             response_type = InteractionCallbackType.from_value(response_type)
-        if not isinstance(response_type, any(InteractionCallbackType.deferred_msg_with_source, InteractionCallbackType.deferred_update_msg)):
-            raise ValueError('response_type has to bee discord.InteractionCallbackType.deferred_msg_with_source or discord.InteractionCallbackType.deferred_update_msg, not %s.__class__.__name__' % response_type)
+        if not isinstance(response_type, (InteractionCallbackType.deferred_msg_with_source, InteractionCallbackType.deferred_update_msg)):
+            raise ValueError('response_type has to bee discord.InteractionCallbackType.deferred_msg_with_source or discord.InteractionCallbackType.deferred_update_msg (e.g. 5 or 6), not %s.__class__.__name__' % response_type)
         if self.deferred:
             return log.warning("\033[91You have already responded to this Interaction!\033[0m")
         base = {"type": response_type.value, "data": {'flags': 64 if hidden else None}}

discord/role.py

@@ -188,7 +188,7 @@ def __ge__(self, other):
 
     def _update(self, data):
         self.name = data['name']
-        self._permissions = int(data.get('permissions_new', 0))
+        self._permissions = int(data.get('permissions', 0))
         self.position = data.get('position', 0)
         self._colour = data.get('color', 0)
         self.hoist = data.get('hoist', False)

discord/utils.py

@@ -31,6 +31,8 @@
 from base64 import b64encode
 from bisect import bisect_left
 import datetime
+import typing
+from .enums import TimestampStyle
 import functools
 from inspect import isawaitable as _isawaitable, signature as _signature
 from operator import attrgetter
@@ -43,6 +45,7 @@
 DISCORD_EPOCH = 1420070400000
 MAX_ASYNCIO_SECONDS = 3456000
 
+
 class cached_property:
     def __init__(self, function):
         self.function = function
@@ -57,6 +60,7 @@ def __get__(self, instance, owner):
 
         return value
 
+
 class CachedSlotProperty:
     def __init__(self, name, function):
         self.name = name
@@ -74,11 +78,14 @@ def __get__(self, instance, owner):
             setattr(instance, self.name, value)
             return value
 
+
 def cached_slot_property(name):
     def decorator(func):
         return CachedSlotProperty(name, func)
+
     return decorator
 
+
 class SequenceProxy(collections.abc.Sequence):
     """Read-only proxy of a Sequence."""
     def __init__(self, proxied):
@@ -105,34 +112,39 @@ def index(self, value, *args, **kwargs):
     def count(self, value):
         return self.__proxied.count(value)
 
+
 def parse_time(timestamp):
     if timestamp:
+
         return datetime.datetime(*map(int, re.split(r'[^\d]', timestamp.replace('+00:00', ''))))
     return None
 
+
 def copy_doc(original):
     def decorator(overriden):
         overriden.__doc__ = original.__doc__
         overriden.__signature__ = _signature(original)
         return overriden
     return decorator
 
+
 def deprecated(instead=None):
     def actual_decorator(func):
         @functools.wraps(func)
         def decorated(*args, **kwargs):
-            warnings.simplefilter('always', DeprecationWarning) # turn off filter
+            warnings.simplefilter('always', DeprecationWarning)  # turn off filter
             if instead:
                 fmt = "{0.__name__} is deprecated, use {1} instead."
             else:
                 fmt = '{0.__name__} is deprecated.'
 
             warnings.warn(fmt.format(func, instead), stacklevel=3, category=DeprecationWarning)
-            warnings.simplefilter('default', DeprecationWarning) # reset filter
+            warnings.simplefilter('default', DeprecationWarning)  # reset filter
             return func(*args, **kwargs)
         return decorated
     return actual_decorator
 
+
 def oauth_url(client_id, permissions=None, guild=None, redirect_uri=None, scopes=None):
     """A helper function that returns the OAuth2 URL for inviting the bot
     into guilds.
@@ -183,6 +195,7 @@ def snowflake_time(id):
         The creation date in UTC of a Discord snowflake ID."""
     return datetime.datetime.utcfromtimestamp(((id >> 22) + DISCORD_EPOCH) / 1000)
 
+
 def time_snowflake(datetime_obj, high=False):
     """Returns a numeric snowflake pretending to be created at the given date.
 
@@ -201,6 +214,7 @@ def time_snowflake(datetime_obj, high=False):
 
     return (discord_millis << 22) + (2**22-1 if high else 0)
 
+
 def find(predicate, seq):
     """A helper to return the first element found in the sequence
     that meets the predicate. For example: ::
@@ -226,6 +240,7 @@ def find(predicate, seq):
             return element
     return None
 
+
 def get(iterable, **attrs):
     r"""A helper that returns the first element in the iterable that meets
     all the traits passed in ``attrs``. This is an alternative for
@@ -291,13 +306,24 @@ def get(iterable, **attrs):
     for elem in iterable:
         if _all(pred(elem) == value for pred, value in converted):
             return elem
+
     return None
 
+
+def styled_timestamp(timestamp: typing.Union[datetime.datetime, int], style: typing.Union[TimestampStyle, str] = TimestampStyle.short):
+    unix_timestamp = int(timestamp.timestamp()) if isinstance(timestamp, datetime.datetime) else timestamp
+    style = TimestampStyle.from_value(style) if isinstance(style, str) else style
+    if not isinstance(style, TimestampStyle):
+        raise AttributeError('style has to be a discord.TimestampStyle')
+    return f'<t:{unix_timestamp}:{str(style)}>'
+
+
 def _unique(iterable):
     seen = set()
     adder = seen.add
     return [x for x in iterable if not (x in seen or adder(x))]
 
+
 def _get_as_snowflake(data, key):
     try:
         value = data[key]
@@ -306,6 +332,7 @@ def _get_as_snowflake(data, key):
     else:
         return value and int(value)
 
+
 def _get_mime_type_for_image(data):
     if data.startswith(b'\x89\x50\x4E\x47\x0D\x0A\x1A\x0A'):
         return 'image/png'
@@ -318,15 +345,18 @@ def _get_mime_type_for_image(data):
     else:
         raise InvalidArgument('Unsupported image type given')
 
+
 def _bytes_to_base64_data(data):
     fmt = 'data:{mime};base64,{data}'
     mime = _get_mime_type_for_image(data)
     b64 = b64encode(data).decode('ascii')
     return fmt.format(mime=mime, data=b64)
 
+
 def to_json(obj):
     return json.dumps(obj, separators=(',', ':'), ensure_ascii=True)
 
+
 def _parse_ratelimit_header(request, *, use_clock=False):
     reset_after = request.headers.get('X-Ratelimit-Reset-After')
     if use_clock or not reset_after:
@@ -337,13 +367,15 @@ def _parse_ratelimit_header(request, *, use_clock=False):
     else:
         return float(reset_after)
 
+
 async def maybe_coroutine(f, *args, **kwargs):
     value = f(*args, **kwargs)
     if _isawaitable(value):
         return await value
     else:
         return value
 
+
 async def async_all(gen, *, check=_isawaitable):
     for elem in gen:
         if check(elem):
@@ -389,10 +421,12 @@ async def sleep_until(when, result=None):
         delta -= MAX_ASYNCIO_SECONDS
     return await asyncio.sleep(max(delta, 0), result)
 
+
 def valid_icon_size(size):
     """Icons must be power of 2 within [16, 4096]."""
     return not size & (size - 1) and size in range(16, 4097)
 
+
 class SnowflakeList(array.array):
     """Internal data storage class to efficiently store a list of snowflakes.
 
@@ -422,8 +456,10 @@ def has(self, element):
         i = bisect_left(self, element)
         return i != len(self) and self[i] == element
 
+
 _IS_ASCII = re.compile(r'^[\x00-\x7f]+$')
 
+
 def _string_width(string, *, _IS_ASCII=_IS_ASCII):
     """Returns string's width."""
     match = _IS_ASCII.match(string)
@@ -434,6 +470,7 @@ def _string_width(string, *, _IS_ASCII=_IS_ASCII):
     func = unicodedata.east_asian_width
     return sum(2 if func(char) in UNICODE_WIDE_CHAR_TYPE else 1 for char in string)
 
+
 def resolve_invite(invite):
     """
     Resolves an invite from a :class:`~discord.Invite`, URL or code.
@@ -458,6 +495,7 @@ def resolve_invite(invite):
             return m.group(1)
     return invite
 
+
 def resolve_template(code):
     """
     Resolves a template code from a :class:`~discord.Template`, URL or code.
@@ -474,7 +512,7 @@ def resolve_template(code):
     :class:`str`
         The template code.
     """
-    from .template import Template # circular import
+    from .template import Template  # circular import
     if isinstance(code, Template):
         return code.code
     else:
@@ -484,6 +522,7 @@ def resolve_template(code):
             return m.group(1)
     return code
 
+
 _MARKDOWN_ESCAPE_SUBREGEX = '|'.join(r'\{0}(?=([\s\S]*((?<!\{0})\{0})))'.format(c)
                                      for c in ('*', '`', '_', '~', '|'))
 
@@ -495,6 +534,7 @@ def resolve_template(code):
 
 _MARKDOWN_STOCK_REGEX = r'(?P<markdown>[_\\~|\*`]|%s)' % _MARKDOWN_ESCAPE_COMMON
 
+
 def remove_markdown(text, *, ignore_links=True):
     """A helper function that removes markdown characters.
 
@@ -528,6 +568,7 @@ def replacement(match):
         regex = '(?:%s|%s)' % (_URL_REGEX, regex)
     return re.sub(regex, replacement, text, 0, re.MULTILINE)
 
+
 def escape_markdown(text, *, as_needed=False, ignore_links=True):
     r"""A helper function that escapes Discord's markdown.
 
@@ -569,6 +610,7 @@ def replacement(match):
         text = re.sub(r'\\', r'\\\\', text)
         return _MARKDOWN_ESCAPE_REGEX.sub(r'\\\1', text)
 
+
 def escape_mentions(text):
     """A helper function that escapes everyone, here, role, and user mentions.