Shilling list definition (core)

This document holds information regarding shilling with message objects.

We will now see how our shilling / advertisement list can be defined.

Definition of accounts (core)

Discord accounts / clients are inside DAF represented by the daf.client.ACCOUNT class. It accepts many parameters, out of which these are the most important:

• token: A string (text) parameter. It is the token an account needs to login into Discord. Token can be obtained through the developer portal for bot accounts and through a browser for user accounts.

• is_user: An optional True / False parameter. Discord has 2 types of clients - user accounts and bots. Set this to True when the above token belongs to a user and not a bot.

• proxy: An optional string (text) parameter. Represents a proxy URL used to access Discord.

• servers: A list of servers. In DAF, servers are referred to as “guild”, which was Discord’s original name for a server. Elements inside this list can be any objects inherited from daf.guild.BaseGUILD class. Three types of servers exist (are inherited from daf.guild.BaseGUILD):

  • daf.guild.GUILD

    Represents an actual Discord server with channels and members.

  • daf.guild.USER

    Represents a user and their direct messages.

    Caution

    Shilling to DM’s is not recommended as there is no way to check if our client has permissions. There is a high risk of Discord automatically banning you if you attempt to shill messages to users, who can’t receive them from you.

  • daf.guild.AutoGUILD

    Represents multiple Discord servers with channels and members, whose names match a configured pattern. Strictly speaking, this isn’t actually inherited from daf.guild.BaseGUILD, but is rather a wrapper for multiple daf.guild.GUILD. It can be used to quickly define the entire the entire server list, without manually creating each daf.guild.GUILD.

    Refer to the Automatic Generation (core) section for more information.

Now let’s see an example.

from daf.client import ACCOUNT
import daf

accounts = [
    ACCOUNT(
        token="HHJSHDJKSHKDJASHKDASDHASJKDHAKSJDHSAJKHSDSAD",
        is_user=True,  # Above token is user account's token and not a bot token.
        servers=[]
    )
]

daf.run(accounts=accounts)

As you can see from the above example, the definition of accounts is rather simple. Notice we didn’t define our servers. We will do that in the next section.

After running the example, the following output is displayed. Ignore the intents warnings for now. These warnings are not even relevant for user accounts. Intents are settings of what kind of events the ACCOUNT should listen to and are controlled with its intents parameter. User accounts have no notion of intents.

Notice the first line of the output. It tells us that the logs will be stored into a specific folder. DAF supports message logging, meaning that a message log is created for each sent message. A logger can be given to the daf.core.run()’s logger parameter. For more information about logging see Logging (core).

[2024-01-21 13:24:22.887679] (NORMAL) | daf.logging.logger_file: LoggerJSON logs will be saved to C:\Users\david\daf\History (None)
[2024-01-21 13:24:22.887679] (WARNING) | daf.client: Members intent is disabled, it is needed for automatic responders' constraints and invite link tracking. (None)
[2024-01-21 13:24:22.887679] (WARNING) | daf.client: Message content intent is disabled, it is needed for automatic responders. (None)
[2024-01-21 13:24:22.887679] (NORMAL) | daf.client: Logging in... (None)
[2024-01-21 13:24:25.910163] (NORMAL) | daf.client: Logged in as Aproksimacka (None)
[2024-01-21 13:24:25.910163] (NORMAL) | daf.core: Initialization complete. (None)

Definition of servers / guilds (core)

We will only cover the definition of daf.guild.GUILD here. We will not cover daf.guild.USER separately as the definition process is exactly the same. We will also not cover daf.guild.AutoGUILD here, as it is covered in Automatic Generation (core).

Let’s define our daf.guild.GUILD object now. Its most important (but not all) parameters are:

• snowflake: An integer parameter. Represents a unique identifier, which identifies every Discord resource. Snowflake can be obtained by enabling the developer mode, right-clicking on the guild of interest, and then left-clicking on Copy Server ID.

• messages: A list parameter of our message objects. Message objects represent the content that will be sent into specific channels, with a specific period. For our daf.guild.GUILD, messages can be the following classes:

  • daf.message.TextMESSAGE: Message type for sending textual data. Data includes files as well.

  • daf.message.VoiceMESSAGE: Message type for sending audio data / playing audio to voice channels.

Let’s expand our example from Definition of accounts (core).

from daf.client import ACCOUNT
from daf.guild import GUILD
import daf

accounts = [
    ACCOUNT(
        token="HHJSHDJKSHKDJASHKDASDHASJKDHAKSJDHSAJKHSDSAD",
        is_user=False,  # Above token is user account's token and not a bot token.
        servers=[
            GUILD(
                snowflake=863071397207212052,
                messages=[]
            )
        ]
    )
]

daf.run(accounts=accounts)

Now let’s define our messages.

Definition of messages (core)

Three kinds of messages exist. Additional to daf.message.TextMESSAGE and daf.message.VoiceMESSAGE, is the daf.message.DirectMESSAGE message type. This message type is used together with daf.guild.USER for sending messages into DMs. Unlike the previously mentioned message types, DirectMESSAGE does not have the channels parameter.

Now let’s describe some parameters. The most important parameters inside daf.message.TextMESSAGE are:

• data: A TextMessageData object or a DynamicMessageData (Dynamically obtained data) inherited object. It represents the data that will be sent into our text channels.

• channels: A list of integers or a single AutoCHANNEL object. The integers inside a list represents channel snowflake IDs. Obtaining the IDs is the same as for guilds. See Automatic Generation (core) for information about AutoCHANNEL.

• period: It represents the time period at which messages will be periodically sent. It can be one of the following types:

  • FixedDurationPeriod: A fixed time period.

  • RandomizedDurationPeriod: A randomized (within a certain range) time period.

  • DaysOfWeekPeriod: A period that sends at multiple specified days at a specific time.

  • DailyPeriod: A period that sends every day at a specific time.

• constraints: A list of constraints that only allow a message to be sent when they are fulfilled. This can for example be used to only send messages to channels when the last message in that channel is not or own, thus preventing unnecessary spam. Currently a single constraint is supported:

  • daf.message.constraints.AntiSpamMessageConstraint

Now that we have an overview of the most important parameters, let’s define our message. We will define a message that sends fixed data into a single channel, with a fixed time (duration) period.

from daf.message.constraints import AntiSpamMessageConstraint
from daf.message.messageperiod import FixedDurationPeriod
from daf.messagedata import TextMessageData
from daf.message import TextMESSAGE
from daf.client import ACCOUNT
from daf.guild import GUILD

from datetime import timedelta

import daf

accounts = [
    ACCOUNT(
        token="HHJSHDJKSHKDJASHKDASDHASJKDHAKSJDHSAJKHSDSAD",
        is_user=False,  # Above token is user account's token and not a bot token.
        servers=[
            GUILD(
                snowflake=2312312312312312313123,
                messages=[
                    TextMESSAGE(
                        data=TextMessageData(content="Looking for NFT?"),
                        channels=[3215125123123123123123],
                        period=FixedDurationPeriod(duration=timedelta(seconds=5)),
                        constraints=[AntiSpamMessageConstraint(per_channel=True)]
                    )
                ]
            )
        ]
    )
]

daf.run(accounts=accounts)

Similarly to text messages, voice messages can be defined with daf.message.VoiceMESSAGE. Definition is very similar to daf.message.TextMESSAGE. The only thing that differs from the above example is the data parameter. That parameter is with VoiceMESSAGE of type VoiceMessageData (Fixed data) or DynamicMessageData (Dynamically obtained data). Additionally, it contains a volume parameter.

Message advertisement examples

The following examples show a complete core script (without message constraints) setup needed to advertise periodic messages.

TextMESSAGE

Listing 6 TextMESSAGE full example

"""
Example shows the basic message shilling into a fixed guild.
A text message is sent every 8-12 hours (randomly chosen) and it contains a text content and 3 files.
The message will be first sent in 4 hours.
"""

# Import the necessary items
from daf.logging.logger_json import LoggerJSON

from daf.messagedata import FILE
from daf.messagedata.textdata import TextMessageData
from datetime import timedelta
from daf.client import ACCOUNT
from daf.message.text_based import TextMESSAGE
from daf.message.messageperiod import RandomizedDurationPeriod
from daf.guild.guilduser import GUILD
from daf.logging.tracing import TraceLEVELS
import daf

# Define the logger
logger = LoggerJSON(
    path="C:\\Users\\david\\daf\\History",
)


# Defined accounts
accounts = [
    ACCOUNT(
        token="TOKEN",
        is_user=True,
        servers=[
            GUILD(
                snowflake=123456789,
                messages=[
                    TextMESSAGE(
                        data=TextMessageData(
                            content="Buy our red dragon NFTs today!",
                            files=[
                                FILE(filename="C:/Users/david/Downloads/Picture1.png"),
                                FILE(filename="H:/My Drive/PR/okroznice/2023/2023_01_28 - Skiing.md"),
                                FILE(filename="H:/My Drive/PR/okroznice/2023/2023_10_16 - Volitve SSFE.md"),
                            ],
                        ),
                        channels=[123123231232131231, 329312381290381208321, 3232320381208321],
                        period=RandomizedDurationPeriod(
                            minimum=timedelta(hours=8.0),
                            maximum=timedelta(hours=12.0),
                            next_send_time=timedelta(hours=4.0),
                        ),
                    ),
                ],
                logging=True,
            ),
        ],
    ),
]

# Run the framework (blocking)
daf.run(
    accounts=accounts,
    logger=logger,
    debug=TraceLEVELS.NORMAL,
)

VoiceMESSAGE

Listing 7 VoiceMESSAGE full example

"""
Example shows the basic message shilling into a fixed guild.
A text message is sent every 30-90 minutes (randomly chosen) and it plays a single audio file.
The message will be first sent in 10 minutes.
"""

# Import the necessary items
from daf.logging.logger_json import LoggerJSON

from daf.messagedata import FILE
from daf.messagedata.voicedata import VoiceMessageData
from datetime import timedelta
from daf.client import ACCOUNT
from daf.message.voice_based import VoiceMESSAGE
from daf.message.messageperiod import RandomizedDurationPeriod
from daf.guild.guilduser import GUILD
from daf.logging.tracing import TraceLEVELS
import daf

# Define the logger
logger = LoggerJSON(
    path="C:\\Users\\david\\daf\\History",
)

# Defined accounts
accounts = [
    ACCOUNT(
        token="TOKEN",
        is_user=True,
        servers=[
            GUILD(
                snowflake=318732816317823168276278,
                messages=[
                    VoiceMESSAGE(
                        data=VoiceMessageData(FILE(filename="./VoiceMESSAGE.mp3")),
                        channels=[1136787403588255784, 1199125280149733449],
                        period=RandomizedDurationPeriod(
                            minimum=timedelta(minutes=30),
                            maximum=timedelta(minutes=90),
                            next_send_time=timedelta(minutes=10),
                        ),
                    ),
                ],
                logging=True,
            ),
        ],
    ),
]

# Run the framework (blocking)
daf.run(
    accounts=accounts,
    logger=logger,
    debug=TraceLEVELS.NORMAL,
)

DirectMESSAGE

Listing 8 DirectMESSAGE full example

"""
Example shows the basic message shilling into a fixed DM.
A text message is sent every 8-12 hours (randomly chosen) and it contains a text content and 3 files.

!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
WARNING! Using this do directly shill to DM is VERY DANGEROUS!!!
!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
There is no way to check for permissions with DM messages, thus the client
may try to make many forbidden requests. This will eventually result in Discord
banning. USE AT YOUR OWN RISK!!!!

If you just want to respond to DM messages, the DMResponder is a better example.
"""

# Import the necessary items
from daf.logging.logger_json import LoggerJSON

from daf.messagedata import FILE
from daf.messagedata.textdata import TextMessageData
from datetime import timedelta
from daf.client import ACCOUNT
from daf.message.text_based import DirectMESSAGE
from daf.message.messageperiod import RandomizedDurationPeriod
from daf.guild.guilduser import USER
from daf.logging.tracing import TraceLEVELS
import daf

# Define the logger
logger = LoggerJSON(
    path="C:\\Users\\david\\daf\\History",
)


# Defined accounts
accounts = [
    ACCOUNT(
        token="TOKEN",
        is_user=False,
        servers=[
            USER(
                snowflake=145196308985020416,
                messages=[
                    DirectMESSAGE(
                        data=TextMessageData(
                            content="Buy our red dragon NFTs today!",
                            files=[
                                FILE(filename="C:/Users/david/Downloads/Picture1.png"),
                                FILE(filename="H:/My Drive/PR/okroznice/2023/2023_01_28 - Skiing.md"),
                                FILE(filename="H:/My Drive/PR/okroznice/2023/2023_10_16 - Volitve SSFE.md"),
                            ],
                        ),
                        period=RandomizedDurationPeriod(
                            minimum=timedelta(hours=8.0),
                            maximum=timedelta(hours=12.0),
                        ),
                    ),
                ],
                logging=True,
            ),
        ],
    ),
]

# Run the framework (blocking)
daf.run(
    accounts=accounts,
    logger=logger,
    debug=TraceLEVELS.NORMAL,
)

Next up, we will take a look how to setup and use message logging.