Package Concepts with code snippets

[Sigmanificient]

This discussion is meant to allow everyone to propose and share their idea on what some features could looks like (and why) using code snippets.

[Sigmanificient]

Simplest command

The command syntax will be very similar to the original discordpy one.
However, indeed of await ctx.send, the command will return an object.
When the return type is a string, this will send be a simple message.

@command('my_command')
async def ping() -> str:
    return 'pong'

[Sly-Little-Test]

What if I don't want to send anything?

[Sigmanificient]

Then you'd simply have no return, since python will by default return a None value
Seems like a case that would happens really rarely tho, as any user would except a command to have some kind of ouput

[Sly-Little-Test]

OK

[Arthurdw]

This is possible since v0.6.1-dev :D

[Sigmanificient]

A Message object could also be return for further customization:

@command('my_command')
async def ping(ctx: Context) -> Message:
    return Message(
        'pong',
        replied_from=ctx.message
    )

[Lunarmagpie]

I think the ctx.send() system works better. With return system you cant send a message then do something else.
I like the idea of the message object. I think it'll lead to more organized code than adding params to ctx.send().

[Sigmanificient]

the idea would be to have a watcher to continue the command, so you can have better dispatching.
Let's see what people like the most

[Arthurdw]

I think the ctx.send() system works better. With return system you cant send a message then do something else.
I like the idea of the message object. I think it'll lead to more organized code than adding params to ctx.send().

We'll most likely implement both methods because of that restriction. But the way with returning the value will be the preferred way. As this is less code (and personally I think its cleaner) and it doesn't makes the intended action less clear.

[Sigmanificient]

Maybe should we consider having a legacy namespace such as

from pincer.legacy import ctx, commands

[Sigmanificient]

Watchers

Watcher objects can be return to have an even trigger which allow to
execute a watcher decorated function.

def check(ctx: Context, m: Message):
    return m.author == ctx.author

@command('something')
async def something() -> Tuple[Embed, Watcher]:
    ...
    return an_embed, watcher(
        'button_click', check=check, something_else
    )

@watcher
async def something_else(ctx: Context) -> Embed:
    ...

[trag1c]

Could use an alternative name like Observer, Beholder, or Spectator, which might work a bit better in my opinion.

[Sigmanificient]

I like Observer! Do you have a reason/logic behind Spectator and Beholder?

[trag1c]

I like Observer! Do you have a reason/logic behind Spectator and Beholder?

Not really, was just seeking synonyms for Observer, which was my first thought 😄

[Arthurdw]

Could use an alternative name like Observer, Beholder, or Spectator, which might work a bit better in my opinion.

Yeah I also prefer Observer, but we can always add aliases. So eg watcher and Observer could be valid.

[Sly-Little-Test]

Arguments
Maybe we should add built-in arguments parsing. Then we can use this regex to split command arguments: / +/g

[Sigmanificient]

Wouldn't be faster to use builtin str.split ? need to test it

[Sly-Little-Test]

Wouldn't be faster to use builtin str.split ? need to test it

This regex will help with duplicate spaces

[Sigmanificient]

Do we want to check double spaces for *, message tho 🤔

[Arthurdw]

Not required, as discord sends the given arguments in the payload already properly "parsed".

[Enderchief]

Current for commands we have this

@command('my_command')
async def ping(self, number: int):
    return f'Pong! Your number is {number}'

This work fine for now but what if we want to send multiple responses? The current suggestions are either creating a watcher or bringing back ctx.send. I propose using generators to send multiple things. This allows the messages to not all be determined at the same time by using yield or being able to send a list of messages/embeds.
Example:

@command('my_command')
async def ping(self, number: int):
   yield 'some long message`
   yield Embed(...)
   if some_condition_that_has_changed():
       yield 'good job'
   else:
       yield 'meh'

[Enderchief]

I believe this would be easier to implement and easier for a person first using the library to understand.

[Lunarmagpie]

2nd this

[Sigmanificient]

That sound like an plausible alternative the the watcher/observer thing

[Enderchief]

Shorthands for some methods

Instead of doing this channel.edit(name="pincer") and Pincer sending a request when doing that, what about using a pythonic approach. Thé edit function still exists for more complicated requests but there is a simpler alternative to use.

channel.name = "pincer" 

Similarly,

channel.delete() # from this 
del channel # to this

[Arthurdw]

Keep in mind that the action must be a coroutine.

[Sigmanificient]

is there a __adel__ ?

[Enderchief]

### TL;DR: It is possible!

Edit: no it's not

I've been trying to make a proof of concept and I found a way to run the coroutines in normal functions (that doesn't impact performance).

For example, I got this command working. It updates the object and the channel on discord.

@command()
async def set_name(self, ctx:, name: str):
    channel = await self.get_channel(ctx.channel_id)
    print(f'Current name is {channel.name}') # Current name is general
    channel.name = name
    return f"Name set to {channel.name}" # Name set to testing

Explanation on how:
The object overrides the __setattr__ function. It makes sure that the property can change and that it is not the dataclass that's setting it. The coroutine in run by getting the event loop and creating a task to run asynchronously.

Since this works, it's possible to create a __del__ and others, using the same concepts.

[Enderchief]

Implementation of subcommands and groups

I suggest that we use nesting and the return value from new decorators.
(I was going to add an explanation but half way through I realized that an example is easier to understand)

---

Sample Code (adapted from the discord docs):

from pincer import command, group, subcommand, User

class ModBot(Client)
  
  @command(group=True)
  async def permissions(self):
    
      @group(name="user", description="Get or edit permissions for a user")
      async def user_group(self):
  
          @subcommand(description="Get permissions for a user")
          async def get(self, ctx, user: User):
              member = GuildMember.from_id(self, ctx.guild_id, user.id)
              return str(member.permissions)
              
          @subcommand(description="Edit permissions for a user")
          async def edit(self, ctx, user: User, role: Role):
              guild = await self.get_guild(ctx.guild_id)
              await guild.modify_member(_id=user.id, roles=[role.id]):
              return "Modified roles"
              
          return [get, edit]
              
      @subcommand(description="Clear all roles from a user")
      async def clear(self, ctx, user: User):
          guild = await self.get_guild(ctx.guild_id)
          await guild.modify_member(_id=user.id, roles=[])
          return "Cleared all roles"
          
      return [user_group, clear]

[beastmatser]

I feel like this could get really ugly with a lot of subcommands, too much indentation

[Enderchief]

The maximum indentation would be what is above but I see your point.

[Sigmanificient]

I believe if the focus is on the return List[SubCommand], nothing should stop you for either using the fiest on example given be @Endercheif, or to use a flatter implementation, such as the following

from pincer import command, group, subcommand, User

class ModBot(Client)

    @subcommand(description="Get permissions for a user")
    async def get(self, ctx, user: User):
        member = GuildMember.from_id(self, ctx.guild_id, user.id)
        return str(member.permissions)
              
    @subcommand(description="Edit permissions for a user")
    async def edit(self, ctx, user: User, role: Role):
        guild = await self.get_guild(ctx.guild_id)
        await guild.modify_member(_id=user.id, roles=[role.id]):
        return "Modified roles"
              
    @subcommand(description="Clear all roles from a user")
    async def clear(self, ctx, user: User):
        guild = await self.get_guild(ctx.guild_id)
        await guild.modify_member(_id=user.id, roles=[])
        return "Cleared all roles"
  
    @group(name="user", description="Get or edit permissions for a user")
    async def user_group(self):
        return [selr.get, self.edit]
  
    @command(group=True)
    async def permissions(self):        
        return [self.user_group, self.clear]