pincer.objects.application_command.ApplicationCommand.add_option() - Code Metrics - Inspection of ":sparkles: Further command implementation" - Pincer-org/Pincer - Measure and Improve Code Quality continuously with Scrutinizer

Passed

Push — main ( 7e73ba...03e5c6 )

unknown

created 2021-09-08 13:20 UTC

ApplicationCommand.add_option() A

↳ Parent: pincer.objects.application_command

Complexity

Conditions

Size

Total Lines	10
Code Lines	4

Duplication

Lines	0
Ratio	0 %

Importance

Changes

Metric	Value
eloc	4
dl	0
loc	10
rs	10
c	0
b	0
f	0
cc	2
nop	2

# -*- coding: utf-8 -*-

# MIT License
#
# Copyright (c) 2021 Pincer
#
# Permission is hereby granted, free of charge, to any person obtaining
# a copy of this software and associated documentation files
# (the "Software"), to deal in the Software without restriction,
# including without limitation the rights to use, copy, modify, merge,
# publish, distribute, sublicense, and/or sell copies of the Software,
# and to permit persons to whom the Software is furnished to do so,
# subject to the following conditions:
#
# The above copyright notice and this permission notice shall be
# included in all copies or substantial portions of the Software.
#
# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
# EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
# MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
# IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
# CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
# TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
# SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

from __future__ import annotations

from dataclasses import dataclass
from enum import Enum
from typing import List, Union

from pincer.utils.api_object import APIObject
from pincer.utils.conversion import convert
from pincer.utils.snowflake import Snowflake
from pincer.utils.types import MISSING, APINullable, Coro


class ApplicationCommandType(Enum):
    """
    Defines the different types of application commands.

    :param CHAT_INPUT:
        Slash commands; a text-based command that shows up when a user
        types /

    :param USER:
        A UI-based command that shows up when you right click or tap on
        a user

    :param MESSAGE:
        A UI-based command that shows up when you right click or tap on
        a message
    """
    CHAT_INPUT = 1
    USER = 2
    MESSAGE = 3


class ApplicationCommandOptionType(Enum):
    """
    Represents a parameter type.

    :param SUB_COMMAND:
        The parameter will be a subcommand.

    :param SUB_COMMAND_GROUP:
        The parameter will be a group of subcommands.

    :param STRING:
        The parameter will be a string.

    :param INTEGER:
        The parameter will be an integer/number. (-2^53 and 2^53)

    :param BOOLEAN:
        The parameter will be a boolean.

    :param USER:
        The parameter will be a Discord user object.

    :param CHANNEL:
        The parameter will be a Discord channel object.

    :param ROLE:
        The parameter will be a Discord role object.

    :param MENTIONABLE:
        The parameter will be mentionable.

    :param NUMBER:
        The parameter will be a float. (-2^53 and 2^53)
    """
    SUB_COMMAND = 1
    SUB_COMMAND_GROUP = 2
    STRING = 3
    INTEGER = 4  # 54-bit
    BOOLEAN = 5
    USER = 6
    CHANNEL = 7
    ROLE = 8
    MENTIONABLE = 9
    NUMBER = 10  # 54-bit


@dataclass
class ApplicationCommandInteractionDataOption(APIObject):
    """
    Represents a Discord Application Command Interaction Data Option

    :param name:
        the name of the parameter

    :param type:
        value of application command option type

    :param value:
        the value of the pair

    :param options:
        present if this option is a group or subcommand
    """
    name: str
    type: int
    value: APINullable[ApplicationCommandOptionType] = MISSING
    options: APINullable[
        List[ApplicationCommandInteractionDataOption]] = MISSING

    def __post_init__(self):
        self.value = convert(self.value, ApplicationCommandOptionType)
        self.options = convert(
            self.options,
            ApplicationCommandInteractionDataOption.from_dict,
            ApplicationCommandInteractionDataOption
        )


@dataclass
class ApplicationCommandOptionChoice(APIObject):
    """
    Represents a Discord Application Command Option Choice object

    :param name:
        1-100 character choice name

    :param value:
        value of the choice, up to 100 characters if string
    """
    name: str
    value: Union[str, int, float]


@dataclass
class ApplicationCommandOption(APIObject):
    """

    Represents a Discord Application Command Option object

    :param type:
        the type of option

    :param name:
        1-32 lowercase character name matching `^[\w-]{1,32}$`

    :param description:
        1-100 character description

    :param required:
        if the parameter is required or optional--default `False`

    :param choices:
        choices for `STRING`, `INTEGER`, and `NUMBER`
        types for the user to pick from, max 25

    :param options:
        if the option is a subcommand or subcommand group type,
        this nested options will be the parameters
    """
    type: ApplicationCommandOptionType
    name: str
    description: str

    required: APINullable[bool] = False
    choices: APINullable[List[ApplicationCommandOptionChoice]] = MISSING
    options: APINullable[List[ApplicationCommandOption]] = MISSING

    def __post_init__(self):
        self.choices = convert(
            self.choices,
            ApplicationCommandOptionChoice.from_dict,
            ApplicationCommandOptionChoice
        )
        self.options = convert(
            self.options,
            ApplicationCommandOption.from_dict,
            ApplicationCommandOption
        )


@dataclass

class ApplicationCommand(APIObject):
    """
    Represents a Discord Application Command object

    :param id:
        unique id of the command

    :param type:
        the type of command, defaults `1` if not set

    :param application_id:
        unique id of the parent application

    :param guild_id:
        guild id of the command, if not global

    :param name:
        1-32 character name

    :param description:
        1-100 character description for `CHAT_INPUT` commands,
        empty string for `USER` and `MESSAGE` commands

    :param options:
        the parameters for the command, max 25

    :param default_permission:
        whether the command is enabled by default
        when the app is added to a guild

    :param version:
        autoincrementing version identifier updated during substantial
        record changes
    """
    type: ApplicationCommandType
    name: str
    description: str

    id: APINullable[Snowflake] = MISSING

    version: APINullable[Snowflake] = MISSING
    application_id: APINullable[Snowflake] = MISSING
    options: APINullable[List[ApplicationCommandOption]] = MISSING
    guild_id: APINullable[Snowflake] = MISSING
    default_permission: APINullable[bool] = True

    _eq_props = ["type", "name", "description", "application_id", "options",
                 "guild_id", "default_permission"]

    # def __post_init__(self):
    #     self.id = convert(self.id, Snowflake.from_string)
    #     self.version = convert(self.version, Snowflake.from_string)
    #     self.application_id = convert(self.application_id,
    #                                   Snowflake.from_string)
    #     self.options = convert(
    #         self.options,
    #         ApplicationCommandOption.from_dict,
    #         ApplicationCommandOption
    #     )
    #     self.guild_id = convert(self.guild_id, Snowflake.from_string)

    def __eq__(self, other: ApplicationCommand):
        return all(
            self.__getattribute__(prop) == other.__getattribute__(prop)
            for prop in self._eq_props
        )

    def add_option(self, option: ApplicationCommandOption):
        """
        Add a new option field to the current application command.

        :param option: The option which will be appended.
        """
        if self.options:
            self.options.append(option)
        else:
            self.options = [option]


@dataclass
class ClientCommandStructure:
    """
    Represents the structure of how the client saves the existing
    commands in the register.

    :param app:
        The command application.

    :param call:
        The coroutine which should be called when the command gets
        executed.
    """
    app: ApplicationCommand
    call: Coro


1			# -- coding: utf-8 --
			0 ignored issues – show introduced 2021-09-06 08:54 UTC by Report Bug Copy Issue Report Missing module docstring Loading history...
2			# MIT License
3			#
4			# Copyright (c) 2021 Pincer
5			#
6			# Permission is hereby granted, free of charge, to any person obtaining
7			# a copy of this software and associated documentation files
8			# (the "Software"), to deal in the Software without restriction,
9			# including without limitation the rights to use, copy, modify, merge,
10			# publish, distribute, sublicense, and/or sell copies of the Software,
11			# and to permit persons to whom the Software is furnished to do so,
12			# subject to the following conditions:
13			#
14			# The above copyright notice and this permission notice shall be
15			# included in all copies or substantial portions of the Software.
16			#
17			# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
18			# EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
19			# MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
20			# IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
21			# CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
22			# TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
23			# SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
24
25			from __future__ import annotations
26
27			from dataclasses import dataclass
28			from enum import Enum
29			from typing import List, Union
30
31			from pincer.utils.api_object import APIObject
32			from pincer.utils.conversion import convert
33			from pincer.utils.snowflake import Snowflake
34			from pincer.utils.types import MISSING, APINullable, Coro
35
36
37			class ApplicationCommandType(Enum):
38			"""
39			Defines the different types of application commands.
40
41			:param CHAT_INPUT:
42			Slash commands; a text-based command that shows up when a user
43			types /
44
45			:param USER:
46			A UI-based command that shows up when you right click or tap on
47			a user
48
49			:param MESSAGE:
50			A UI-based command that shows up when you right click or tap on
51			a message
52			"""
53			CHAT_INPUT = 1
54			USER = 2
55			MESSAGE = 3
56
57
58			class ApplicationCommandOptionType(Enum):
59			"""
60			Represents a parameter type.
61
62			:param SUB_COMMAND:
63			The parameter will be a subcommand.
64
65			:param SUB_COMMAND_GROUP:
66			The parameter will be a group of subcommands.
67
68			:param STRING:
69			The parameter will be a string.
70
71			:param INTEGER:
72			The parameter will be an integer/number. (-2^53 and 2^53)
73
74			:param BOOLEAN:
75			The parameter will be a boolean.
76
77			:param USER:
78			The parameter will be a Discord user object.
79
80			:param CHANNEL:
81			The parameter will be a Discord channel object.
82
83			:param ROLE:
84			The parameter will be a Discord role object.
85
86			:param MENTIONABLE:
87			The parameter will be mentionable.
88
89			:param NUMBER:
90			The parameter will be a float. (-2^53 and 2^53)
91			"""
92			SUB_COMMAND = 1
93			SUB_COMMAND_GROUP = 2
94			STRING = 3
95			INTEGER = 4 # 54-bit
96			BOOLEAN = 5
97			USER = 6
98			CHANNEL = 7
99			ROLE = 8
100			MENTIONABLE = 9
101			NUMBER = 10 # 54-bit
102
103
104			@dataclass
105			class ApplicationCommandInteractionDataOption(APIObject):
106			"""
107			Represents a Discord Application Command Interaction Data Option
108
109			:param name:
110			the name of the parameter
111
112			:param type:
113			value of application command option type
114
115			:param value:
116			the value of the pair
117
118			:param options:
119			present if this option is a group or subcommand
120			"""
121			name: str
122			type: int
123			value: APINullable[ApplicationCommandOptionType] = MISSING
124			options: APINullable[
125			List[ApplicationCommandInteractionDataOption]] = MISSING
126
127			def __post_init__(self):
128			self.value = convert(self.value, ApplicationCommandOptionType)
129			self.options = convert(
130			self.options,
131			ApplicationCommandInteractionDataOption.from_dict,
132			ApplicationCommandInteractionDataOption
133			)
134
135
136			@dataclass
137			class ApplicationCommandOptionChoice(APIObject):
138			"""
139			Represents a Discord Application Command Option Choice object
140
141			:param name:
142			1-100 character choice name
143
144			:param value:
145			value of the choice, up to 100 characters if string
146			"""
147			name: str
148			value: Union[str, int, float]
149
150
151			@dataclass
152			class ApplicationCommandOption(APIObject):
153			"""
			1 ignored issue – show Bug introduced 2021-09-06 08:54 UTC by Report Bug Copy Issue Report A suspicious escape sequence `\w` was found. Did you maybe forget to add an `r` prefix? Escape sequences in Python are generally interpreted according to rules similar to standard C. Only if strings are prefixed with `r` or `R` are they interpreted as regular expressions. The escape sequence that was used indicates that you might have intended to write a regular expression. Learn more about the available escape sequences. in the Python documentation. Loading history...
154			Represents a Discord Application Command Option object
155
156			:param type:
157			the type of option
158
159			:param name:
160			1-32 lowercase character name matching `^[\w-]{1,32}$`
161
162			:param description:
163			1-100 character description
164
165			:param required:
166			if the parameter is required or optional--default `False`
167
168			:param choices:
169			choices for `STRING`, `INTEGER`, and `NUMBER`
170			types for the user to pick from, max 25
171
172			:param options:
173			if the option is a subcommand or subcommand group type,
174			this nested options will be the parameters
175			"""
176			type: ApplicationCommandOptionType
177			name: str
178			description: str
179
180			required: APINullable[bool] = False
181			choices: APINullable[List[ApplicationCommandOptionChoice]] = MISSING
182			options: APINullable[List[ApplicationCommandOption]] = MISSING
183
184			def __post_init__(self):
185			self.choices = convert(
186			self.choices,
187			ApplicationCommandOptionChoice.from_dict,
188			ApplicationCommandOptionChoice
189			)
190			self.options = convert(
191			self.options,
192			ApplicationCommandOption.from_dict,
193			ApplicationCommandOption
194			)
195
196
197			@dataclass
			0 ignored issues – show best-practice introduced 2021-09-07 19:46 UTC by Report Bug Copy Issue Report Too many instance attributes (10/7) Loading history...
198			class ApplicationCommand(APIObject):
199			"""
200			Represents a Discord Application Command object
201
202			:param id:
203			unique id of the command
204
205			:param type:
206			the type of command, defaults `1` if not set
207
208			:param application_id:
209			unique id of the parent application
210
211			:param guild_id:
212			guild id of the command, if not global
213
214			:param name:
215			1-32 character name
216
217			:param description:
218			1-100 character description for `CHAT_INPUT` commands,
219			empty string for `USER` and `MESSAGE` commands
220
221			:param options:
222			the parameters for the command, max 25
223
224			:param default_permission:
225			whether the command is enabled by default
226			when the app is added to a guild
227
228			:param version:
229			autoincrementing version identifier updated during substantial
230			record changes
231			"""
232			type: ApplicationCommandType
233			name: str
234			description: str
235
236			id: APINullable[Snowflake] = MISSING
			1 ignored issue – show Coding Style Naming introduced 2021-09-06 08:54 UTC by Report Bug Copy Issue Report Attribute name "id" doesn't conform to snake_case naming style ('([^\\W\\dA-Z][^\\WA-Z]2,\|_[^\\WA-Z]*\|__[^\\WA-Z\\d_][^\\WA-Z]+__)$' pattern) This check looks for invalid names for a range of different identifiers. You can set regular expressions to which the identifiers must conform if the defaults do not match your requirements. If your project includes a Pylint configuration file, the settings contained in that file take precedence. To find out more about Pylint, please refer to their site. Loading history...
237			version: APINullable[Snowflake] = MISSING
238			application_id: APINullable[Snowflake] = MISSING
239			options: APINullable[List[ApplicationCommandOption]] = MISSING
240			guild_id: APINullable[Snowflake] = MISSING
241			default_permission: APINullable[bool] = True
242
243			_eq_props = ["type", "name", "description", "application_id", "options",
244			"guild_id", "default_permission"]
245
246			# def __post_init__(self):
247			# self.id = convert(self.id, Snowflake.from_string)
248			# self.version = convert(self.version, Snowflake.from_string)
249			# self.application_id = convert(self.application_id,
250			# Snowflake.from_string)
251			# self.options = convert(
252			# self.options,
253			# ApplicationCommandOption.from_dict,
254			# ApplicationCommandOption
255			# )
256			# self.guild_id = convert(self.guild_id, Snowflake.from_string)
257
258			def __eq__(self, other: ApplicationCommand):
259			return all(
260			self.__getattribute__(prop) == other.__getattribute__(prop)
261			for prop in self._eq_props
262			)
263
264			def add_option(self, option: ApplicationCommandOption):
265			"""
266			Add a new option field to the current application command.
267
268			:param option: The option which will be appended.
269			"""
270			if self.options:
271			self.options.append(option)
272			else:
273			self.options = [option]
274
275
276			@dataclass
277			class ClientCommandStructure:
278			"""
279			Represents the structure of how the client saves the existing
280			commands in the register.
281
282			:param app:
283			The command application.
284
285			:param call:
286			The coroutine which should be called when the command gets
287			executed.
288			"""
289			app: ApplicationCommand
290			call: Coro
291

Pincer-org / Pincer

Push — main ( 7e73ba...03e5c6 )

ApplicationCommand.add_option() A

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like