DEV Community: Harvey Church

Multiple Developers; One Discord Bot?

Harvey Church — Tue, 08 Mar 2022 16:56:00 +0000

I had a problem:

How do I keep a Python Discord bot online, allow multiple people to contribute to it and then deploy it when new features are added?

Several Google searches had come up short, partial solutions; no clear answer.

Here is my attempt at a solution (though no promise that it is the smartest, or best.. it has just worked for me ¯\_(ツ)_/¯)

Hosting and Deployment

This project uses discord.py and discord-py-slash-command to patch the missing slash command functionality and is hosted here.

The aim of the project was to allow for any member of a private Discord to contribute custom functionality, test locally and then deploy for all to use.

Code can be developed locally, and continually pushed to a GitHub repo.
No code is pushed to the "Live Server" until a git tag is created for a specific release
This tag triggers a GitHub Action that SSH's into the "live server" and deploys the code
For a user on a Discord server the bot is part of, can now run commands.
Developers can continue to test/create features on a locally hosted bot, and push them without the live bot being effected

For hosting, I am using DigitalOcean.

I am sure any other cloud hosting provider will work, just a few changes in the GitHub action script would be required.

GitHub Actions & Server Setup

The Script

To actually upload the code and implement the triggering of the workflow when a tag is created, I have used the following GitHub workflow script.

name: Deploy Code to Digital Ocean

on:
  push: 
    branches:
    - main
    tags:
     - 'v0.*'

jobs:
  create_release:
    if: github.ref_type == 'tag' && contains(github.ref_name,'v')
    runs-on: ubuntu-latest
    steps:
      - name: Checkout code
        uses: actions/checkout@v2.4.0
      - name: Create Release on GitHub
        uses: softprops/action-gh-release@v1
        with:
           tag_name: ${{ github.ref_name }}
           token: ${{ secrets.GITHUB_TOKEN }}
  push_to_digital_ocean:
    needs: create_release
    runs-on: ubuntu-latest
    steps:
     - name: SSH into Droplet and push
       uses: garygrossgarten/github-action-ssh@release
       with:
        host: ${{ secrets.HOST }}
        username: ${{ secrets.USERNAME }}
        passphrase: ${{ secrets.PASSWORD }}
        privateKey: ${{secrets.SSHKEY}}
        command: |
         cd beeb-bot/
         echo "Running Startup Script"
         pm2 stop main_bot
         git pull
         # For if there have been any changes to the pipefile/dependancies
         pipenv install
         pm2 start main_bot

The core of the script is the SSH portion. GitHub actions are designed for the repeating of others code. This action makes use of Gary Großgarten's "Github Action SSH".

A private key is stored within the repository, with the matching Public Key on the server.

The Juicy Part

The important part of the script is the following commands:

  cd beeb-bot/
         echo "Running Startup Script"
         pm2 stop main_bot
         git pull
         # For if there have been any changes to the pipefile/dependancies
         pipenv install
         pm2 start main_bot

pm2 in the script refers to a process manager, mainly used for Node.js projects -- however it can run Python scripts.

pm2 is used used because just running something like python3 main.py locks up the action, and it can never exit. Using this means the script no longer locks up, and the action succeeds/fails.

main_bot is a short hand for pm2 start "pipenv run python3 main.py" --name main_bot --watch. This project makes use of pipenv to manage dependencies, and to make sure the virtual environment is used, pipenv run is called.

A git instance of repo is stored on the server. git pull gets a copy from GitHub (which should be the latest release).

pipenv install is run to ensure the virtual environment on the server matches the needed packages for the project.

pm2 start main_bot is called to start the process again and run the freshly pulled main.py script.

On the Server (specifically for this project)

The initial set-up on the server has a few requirements. pipenv and pm2 must then be installed.

Following this:

The user must clone the repo on the server
Run pipenv install to establish the same Python packages that the project is expecting (mainly discord.py and discord-py-slash-command)
Have a token stored in the .env file so that when the bot is run, it can talk to Discord and authenticate.
Create a pm2 proccess -- pm2 start "pipenv run python3 main.py" --name main_bot -- Note: This project expects the proccess to be called "main_bot", but in reality, any name can be used.

Final Remarks

This is not entirely comprehensive, but hopefully is a good jumping off point for others.

I am certain that it is not perfect, I have missed something obvious or that there is something simpler.

One big gap, the release process relying on tags is very manual. The usage of Semantic Version could improve this.

A Dumb Sorting Algorithm

Harvey Church — Fri, 05 Jun 2020 18:53:15 +0000

This post is originally from my blog. I try and write semi-often, but only when I feel I have something interesting to say.

The Mistake, but the question.

As part of the preparation for interviews, I have been re-touching some of the foundational concepts in Computer Science. Some of the more interesting challenges have been relearning and implementing sorting algorithms in Python.

Success has been... wrought with interesting mishaps where my understanding did not quite match the implementation I had written. One of these more interesting mistakes arose from creating a bubble sort.

I will say now- I did successfully implement a bubble sort, but the first "mistake" did lead to an interesting question:

"What is the efficiency of this janky creation?"

The concepts around efficiency are not new to me, but testing and saying what it is for a new algorithm where it is not obvious is a new area.

The Algorithm

On a gist here - in case you ever feel (but I do not know why) inclined to copy it and try it out.

def somethingSort(array):
    pointer = 0
    number_of_comparisons = 0
    while pointer < len(array)-1:
        if array[pointer] > array[pointer+1]:
            array[pointer+1],array[pointer] = array[pointer],array[pointer+1]
            pointer = 0

        else:    
            pointer += 1
        number_of_comparisons += 1  
    return array,number_of_comparisons

Summarized:

Compare the current value and the next
If Current is bigger then the next, swap them
Reset the pointer back to 0 (go back to the beginning)
ELSE increase the pointer by one (move onto the next pair of numbers and compare)
If the pointer is at the current length of the input array, then we have finished sort

I can see the problems very clearly when I summarize it like this. If you happen to be sorting at the end of the array, after you find a pair to swap, you will be sent right back to the beginning. This can cause the algorithm to re-check all the values.. at least twice.

The Analysis

Now, this is the bit I was mostly interested in, but unsure when it came to generating a conclusion. This is an area - scalability- where I believe there will always be lots of questions are left to be answered in some form, as to how things scale informs major design decisions.

All calculations were run at least 10 times for each randomly generated list of up to 500 values long. The randomly generated numbers were between 1 and 100 inclusively.

Comparisons

The algorithm quite nicely (but unfortunately) scaled cubically. This being that for every input, it will do the cube of it in terms of the number of comparisons. For reference:

Quick Sort has an average nlogn for comparisons - in the worst cases (but rarely) n²
Bubble Sort has an average and worst of n²

There is an R² value attached to the graph, however this is not a good metric to use, as R² is primarily for comparing linear data to a line of best fit. This is not linear.

Time

This is the point of data is the area I am least certain on. The time was calculated by recording the time before the calculation and after then taking the difference. All calculations were left on the same computer with the same applications in the background.

The point of the analysis I am not sure of is around what the equation of the correlation line is. As stated before, using R² is a bad choice for non-linear data. My indecision arises around how that value improves when increasing the power of the correlation line. So I am being hypocritical by using it to decide on the equation. It is somewhere between n² and n⁵.

Learning is slow but worth the climb

This is still a new area for me. I really did enjoy re-visiting and programming sorting algorithms. The analysis itself might be a bit off, but I can only improve from there.

I already have in mind improvements for this algorithm, and doing so might mean it is just a copy of one that already exists.

Onwards to more learning about how to presenting data! (Any comments on what I did/could do better.. please provide away)