├── .gitignore
├── tests.sh
├── Makefile
├── requirements.txt
├── junkyard
    ├── example.py
    ├── test-bot-key.py
    ├── tests.rkt
    ├── janitor-bot.py
    ├── supervisor.rkt
    ├── dumb-bot.py
    ├── graph-bot.py
    ├── remind-bot.py
    ├── dotabot.go
    ├── FishFactBot.js
    ├── botinfo.py
    ├── hacker-bot.py
    └── dota-bot.py
├── config.json
├── LICENSE.md
├── bots
    ├── eco-bot.py
    ├── dumb-bot.py
    ├── dota-bot.py
    └── Bot.py
└── README.md


/.gitignore:
--------------------------------------------------------------------------------
1 | __pycache__/
2 | *.swp
3 | *.py[cod]
4 | dev
5 | *.key
6 | botdata/
7 | node_modules/
8 | shared/
9 | *\~


--------------------------------------------------------------------------------
/tests.sh:
--------------------------------------------------------------------------------
 1 | #!/bin/sh
 2 | 
 3 | for f in bots/*.py;
 4 | do
 5 |     python -m py_compile $f
 6 | done
 7 | 
 8 | echo "Done"
 9 | # end
10 | 


--------------------------------------------------------------------------------
/Makefile:
--------------------------------------------------------------------------------
 1 | run:
 2 | 	raco superv config.json
 3 | virtualenv:
 4 | 	virtualenv dev
 5 | setup:
 6 | 	pip install -r requirements.txt
 7 | 	raco pkg install superv
 8 | clean:
 9 | 	rm -rf botdata/
10 | test:
11 | 	sh tests.sh
12 | copy_keys:
13 | 	scp -r keys steve@alarmpi:~/discord-bots
14 | 


--------------------------------------------------------------------------------
/requirements.txt:
--------------------------------------------------------------------------------
 1 | aiohttp==3.7.4
 2 | appdirs==1.4.3
 3 | async-timeout==1.2.1
 4 | beautifulsoup4==4.6.0
 5 | bs4==0.0.1
 6 | chardet==3.0.2
 7 | discord.py==0.16.7
 8 | multidict==2.1.4
 9 | packaging==16.8
10 | pyparsing==2.2.0
11 | requests==2.31.0
12 | six==1.10.0
13 | websockets==9.1
14 | 


--------------------------------------------------------------------------------
/junkyard/example.py:
--------------------------------------------------------------------------------
 1 | #!/usr/bin/env python
 2 | #-*- coding: utf-8 -*-
 3 | 
 4 | from Bot import *
 5 | from requests import get, post
 6 | 
 7 | class Example(WebHookBot):
 8 |     def __init__(self, name):
 9 |         super(Example, self).__init__(name)
10 |         self.logger(f"Endpoint: {self.endpoint}")
11 |         self.SLEEP_TIME = 10 
12 | 
13 |     def main(self):
14 |         self.logger("I'm something else!")
15 | 
16 | ex = Example("example")
17 | ex.run()
18 | 


--------------------------------------------------------------------------------
/config.json:
--------------------------------------------------------------------------------
 1 | {
 2 |     "sleep_time": 600,
 3 |     "sleep_count": 12,
 4 |     "hard_restarts": true,
 5 |     "init_sleep": 30,
 6 |     "reset_sleep": 30,
 7 |     "programs": [
 8 |         {
 9 |             "name": "Dumb Bot",
10 |             "program": "python",
11 |             "args": [
12 |                 "bots/dumb-bot.py"
13 |             ]
14 |         },
15 | 	{
16 | 	    "name": "Dota2 Match Bot",
17 | 	    "program": "python",
18 | 	    "args": [
19 | 		"bots/dota-bot.py"
20 | 	    ]
21 | 	},
22 | 	{
23 | 	    "name": "Economy Bot",
24 | 	    "program": "python",
25 | 	    "args": [
26 | 		"bots/eco-bot.py"
27 | 	    ]
28 | 	}
29 |     ]
30 | }
31 | 


--------------------------------------------------------------------------------
/junkyard/test-bot-key.py:
--------------------------------------------------------------------------------
 1 | #!/usr/bin/env python
 2 | #-*- coding: utf-8 -*-
 3 | 
 4 | from botinfo import *
 5 | from sys import argv
 6 | 
 7 | client = discord.Client()
 8 | 
 9 | @client.event
10 | async def on_ready():
11 |     print("Logged in")
12 |     print("ID: {}, Name: {}".format(client.user.id, client.user.name))
13 |     client.logout()
14 |     client.close()
15 |     raise Exception
16 | 
17 | @client.event
18 | async def on_error(err):
19 |     print("Oops")
20 |     client.logout()
21 |     client.close()
22 |     return False
23 | 
24 | if __name__ == "__main__":
25 |     try:
26 |         k = argv[1]
27 |         client.run(k)
28 |     except Exception as e:
29 |         print("{} fail: {}".format(key, e))
30 |     except SystemExit:
31 |         pass
32 |     except KeyboardInterrupt:
33 |         print("Don't touch that!")
34 |     finally:
35 |         print("Stopping")
36 |     quit()
37 | 
38 | # end
39 | 


--------------------------------------------------------------------------------
/LICENSE.md:
--------------------------------------------------------------------------------
 1 | MIT License
 2 | 
 3 | Copyright (c) 2016 Steven Leibrock
 4 | 
 5 | Permission is hereby granted, free of charge, to any person obtaining a copy
 6 | of this software and associated documentation files (the "Software"), to deal
 7 | in the Software without restriction, including without limitation the rights
 8 | to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 9 | copies of the Software, and to permit persons to whom the Software is
10 | furnished to do so, subject to the following conditions:
11 | 
12 | The above copyright notice and this permission notice shall be included in all
13 | copies or substantial portions of the Software.
14 | 
15 | THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
16 | IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
17 | FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
18 | AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
19 | LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
20 | OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
21 | SOFTWARE.
22 | 
23 | 


--------------------------------------------------------------------------------
/junkyard/tests.rkt:
--------------------------------------------------------------------------------
 1 | #lang racket
 2 | 
 3 | (module+ test (require rackunit racket/port "src/supervisor.rkt"))
 4 | 
 5 | (module+ test 
 6 |     (define (debug-args program code)
 7 |       (match program
 8 |         ("node"   (list "-c" code))
 9 |         ("python" (list "-m" "py_compile" code))))
10 |     (define (syscall cmds)
11 |       (parameterize ([current-subprocess-custodian-mode 'kill])
12 |         (apply system* (append (list (find-executable-path (car cmds))) (cdr cmds)))))
13 |     (define (sys->str cmd) (with-output-to-string (λ () (syscall cmd)))))
14 | 
15 | (module+ test
16 |    (test-case "Testing ability to kill subprocs"
17 |      (let ([subs
18 |             (build-list
19 |              10
20 |              (lambda (x)
21 |                  (define-values (a b c d)
22 |                    (syscall '("sleep" "300000")))
23 |                      a))])
24 |        (check = (length subs) 10 "Test size not equal")
25 |        (for-each subproc-kill subs)
26 |        (sleep 2) ; sleep to wait on the OS process killing
27 |        (for-each
28 |         (lambda (sub)
29 |           (check-not-eq? 'running (subprocess-status sub)))
30 |         subs)))
31 |    
32 |    (test-case "Testing successful compiles on all bots"
33 |      (let ([subs
34 |             (build-list
35 |              total-bots
36 |              (lambda (x)
37 |                  (define-values (interp code) (apply values (vector-ref bots x)))
38 |                  (define-values (a b c d) (syscall interp (debug-args interp code)))
39 |                  a))])
40 |        (check = (length subs) total-bots)
41 |        (sleep 5)
42 |        (for-each (lambda (sub) (check-eq? 0 (subprocess-status sub))) subs)
43 |        0))
44 | 
45 |    (test-case "Test whether all packages have been installed"
46 |      (let ([pip-out (sys->str '("pip" "freeze" "--disable-pip-version-check"))]
47 |            [req-txt (port->lines (open-input-file "requirements.txt"))])
48 |        (displayln "Checking if packages were installed...")
49 |        (check <=
50 |               (length req-txt)
51 |               (length (filter non-empty-string? (string-split pip-out "\n"))))))
52 |    )
53 | ; end
54 | 


--------------------------------------------------------------------------------
/junkyard/janitor-bot.py:
--------------------------------------------------------------------------------
 1 | #!/usr/bin/env python
 2 | #-*- coding: utf-8 -*-
 3 | 
 4 | """
 5 | Janitor-bot
 6 | 
 7 | Will clean up old messages and purge channels of certain things
 8 | """
 9 | 
10 | from botinfo import *
11 | from random import choice
12 | 
13 | bot_name = "janitor-bot"
14 | client = discord.Client()
15 | logger = create_logger(bot_name)
16 | 
17 | hooks = {
18 |     "text"  : lambda m: len(m.attachments) == 0,
19 |     "images": lambda m: len(m.attachments) >  0,
20 |     }
21 | 
22 | jokes = [
23 |     "I was going to attend the clairvoyants meeting, but it was canceled due to unforseen events.",
24 |     "Two cannibals are eating a clown. One cannibal turns to the other and asks 'Does this taste funny to you?'",
25 |     "Two atoms are in a bar. One says, 'I think I lost an electron.' The other says, 'Are you sure?' To which the other replies 'I'm positive.'",
26 |     "A neutron walks into a bar. 'How much for a drink here, anyway?' To which the bartender responds, 'For you, no charge.'",
27 |     "I once visited a crematorium that gave discounts for burn victims.",
28 |     "Photons have mass? I didn't even know they were Catholic.",
29 |     "It's common knowledge that irradiated cats have 18 half-lives.",
30 |     "Did you know the best contraceptive for old people is nudity?",
31 |     ]
32 | 
33 | @register_command
34 | async def perms(msg, mobj):
35 |     """
36 |     Check a user's permissions
37 |     Print all of the user's permissions in a readable line-by-line format
38 |     """
39 |     try:
40 |         perms = mobj.channel.permissions_for(mobj.author)
41 |         lines = [
42 |             "Administrator? {}".format(perms.administrator),
43 |             "Manage server? {}".format(perms.manage_server),
44 |             "Manage messages? {}".format(perms.manage_messages),
45 |             "Attach files? {}".format(perms.attach_files),
46 |             ]
47 |         return await client.send_message(mobj.channel, pre_text("\n".join(lines)))
48 |     except Exception as ex:
49 |         logger("!perms: {}".format(ex))
50 |     return await client.send_message(mobj.channel, "Failed to check permissions")
51 | 
52 | @register_command
53 | async def clean(msg, mobj): 
54 |     """
55 |     This cleans all messages from the input channel
56 |     This is only a command allowed for administrators
57 |     Optional argument to purge non-images from a channel
58 |     """
59 |     try:
60 |         perms = mobj.channel.permissions_for(mobj.author)
61 |         if not perms.administrator:
62 |             return await client.send_message(mobj.channel, "Admins only allowed to purge")
63 |         lamb = hooks[msg] if msg in hooks else None
64 |         await client.purge_from(mobj.channel, limit=30000, check=lamb)
65 |         return
66 |     except Exception as ex:
67 |         logger("!clean: {}".format(ex))
68 |     return await client.send_message(mobj.channel, "Failed to execute action")
69 | 
70 | @register_command
71 | async def joke(msg, mobj):
72 |     """
73 |     Returns a random joke
74 |     The real joke is this help message *ba-dum tsh*
75 |     """
76 |     return await client.send_message(mobj.channel, choice(jokes))
77 |     
78 | 
79 | setup_all_events(client, bot_name, logger)
80 | if __name__ == "__main__":
81 |     run_the_bot(client, bot_name, logger)
82 | 
83 | # end
84 | 
85 | 


--------------------------------------------------------------------------------
/bots/eco-bot.py:
--------------------------------------------------------------------------------
 1 | #!/usr/bin/env python
 2 | #-*- coding: utf-8 -*-
 3 | 
 4 | from Bot import ChatBot
 5 | from requests import get
 6 | from bs4 import BeautifulSoup as BS
 7 | 
 8 | class EcoBot(ChatBot):
 9 |     '''
10 |     EcoBot (Economy Bot) is a price fetcher upon-request bot
11 |     He has a few commands, each one tied to the different market
12 |     Searches are implemented based on relative ease and so on
13 |     Results should be posted in USD (or whatever currency is relevant)
14 |     '''
15 | 
16 |     # These have to be set beforehand (and can't be defined locally)
17 |     ChatBot.PREFIX       = '$'
18 |     ChatBot.STATUS       = f'{ChatBot.PREFIX}help for info'
19 | 
20 |     STEAM_SEARCH_URL     = 'http://steamcommunity.com/market/search?q={}'
21 |     STOCKS_SEARCH_URL    = ''
22 |     RUNESCAPE_SEARCH_URL = ''
23 | 
24 |     ERR_NO_ITEMS     = 'Failed to find any items'
25 |     ERR_ITEM_URL     = 'Failed to get target item URL'
26 |     ERR_RESP         = 'Failed search [response: {}]'
27 | 
28 |     def __init__(self, name):
29 |         super(EcoBot, self).__init__(name)
30 | 
31 |     @ChatBot.action('<item name>')
32 |     async def steam(self, args, mobj):
33 |         '''
34 |         Search Steam market for an item
35 |         Example: $steam redline ak
36 |         '''
37 |         url  = self.STEAM_SEARCH_URL.format('+'.join(args))
38 |         resp = get(url)
39 |         if resp.status_code != 200:
40 |             return await self.message(mobj.channel, self.ERR_RESP.format(resp.status_code))
41 | 
42 |         search_bs    = BS(resp.text, 'html.parser')
43 |         item_listing = search_bs.find_all('a', class_='market_listing_row_link')
44 |         if not item_listing:
45 |             return await self.message(self.ERR_NO_ITEMS)
46 | 
47 |         url_first_item = item_listing[0].get('href', None)
48 |         if url_first_item is None:
49 |             return await self.message(self.ERR_ITEM_URL)
50 | 
51 |         """
52 |         # use this later
53 |         resp2 = get(url_first_item)
54 |         if resp2.status_code != 200:
55 |             return await self.message(mobj.channel, f'Failed search (status: {resp.status_code})')
56 |         bsp2  = BS(resp2.text, 'html.parser')
57 |         """
58 |         item_name    = item_listing[0].find('span', id='result_0_name')
59 |         price_span   = item_listing[0].find('span', class_='normal_price')
60 |         normal_price = price_span.find('span', class_='normal_price')
61 |         msg = [
62 |             f"Name: {item_name.text}",
63 |             f"Price: {normal_price.text}",
64 |             f"URL: {url_first_item}",
65 |         ]
66 |         return await self.message(mobj.channel, '\n'.join(msg))
67 | 
68 |     @ChatBot.action('<item name>')
69 |     async def scape(self, args, mobj):
70 |         '''
71 |         Search 2007scape's Grand Exchange
72 |         Example: $scape nature rune
73 |         '''
74 |         return await self.message(mobj.channel, 'Not implemented')
75 | 
76 |     @ChatBot.action('<stock ID>')
77 |     async def stock(self, args, mobj):
78 |         '''
79 |         Search the actual stock market
80 |         Example: $stock GOOG
81 |         '''
82 |         return await self.message(mobj.channel, 'Not implemented')
83 | 
84 |     # end bot def
85 | 
86 | if __name__ == '__main__':
87 |     EcoBot('eco-bot').run()
88 |     pass
89 |     
90 | # end
91 | 
92 |     
93 | 


--------------------------------------------------------------------------------
/junkyard/supervisor.rkt:
--------------------------------------------------------------------------------
 1 | #lang racket/base
 2 | 
 3 | (require racket/system racket/file racket/cmdline)
 4 | (require json)
 5 | 
 6 | ;; Used to color the supervisor's message output and color
 7 | (define fstring "[\033[38;5;~am~a\033[0m @ ~a:~a:~a] ~a")
 8 | 
 9 | ;; define a range function without using racket/list
10 | (define (span x)
11 |   (define (inner x lst)
12 |     (if (< x 0)
13 |         lst
14 |         (inner (sub1 x) (cons x lst))))
15 |   (cond
16 |     [(< x 1) '()]
17 |     [else (inner (sub1 x) '())]))
18 | 
19 | ;; Creates a new function which prints out a message with a name attached
20 | (define (set-logger t-name color)
21 |   (λ (str)
22 |     (define cd (seconds->date (current-seconds))) 
23 |     (displayln
24 |      (apply (λ (x y z) (format fstring color t-name x y z str))
25 |             (map (λ (i) (if (< i 10) (format "0~a" i) (format "~a" i)))
26 |                  (list (date-hour cd) (date-minute cd) (date-second cd)))))))
27 | 
28 | (define logger (set-logger "supervisor  " 9))
29 | 
30 | ;; Create a boty factory which uses a source as a reference point (rather, blueprints)
31 | (define (bot-factory bot-source)
32 |   (λ (bot-id)
33 |     (define bot (vector-ref bot-source bot-id))
34 |     (define-values (a b c d)
35 |       (parameterize ([current-subprocess-custodian-mode 'kill])
36 |         (subprocess
37 |          (current-output-port)
38 |          #f
39 |          'stdout
40 |          (find-executable-path (symbol->string (car bot)))
41 |          (cdr bot))))
42 |     (logger (format "Initialized Bot ~a on PID ~a" bot-id (subprocess-pid a)))
43 |     a))
44 |   
45 | ;; Revive a subprocess as required
46 | (define (reviver threads res-func)
47 |   (λ (bot-id)
48 |     (define subp (vector-ref threads bot-id))
49 |     (when (not (eqv? 'running (subprocess-status subp)))
50 |       (subprocess-kill subp #t)
51 |       (vector-set! threads bot-id (res-func bot-id)))))
52 | 
53 | ;; The main program to run with the command-line
54 | (define (supervisor cfg-file)
55 |   (define jdata (read-json (open-input-file cfg-file)))
56 |   (define hard-restart (hash-ref jdata 'hard_restarts #t))
57 |   (define sleep-count  (hash-ref jdata 'sleep_count 12))
58 |   (define sleep-time   (hash-ref jdata 'sleep_time 300))
59 |   (define init-sleep   (hash-ref jdata 'init_sleep 30))
60 |   (define bots         (list->vector (map (compose car hash->list) (hash-ref jdata 'bots))))
61 |   (define total-bots   (vector-length bots)) ; store how many have been set up
62 |   (define start-bot (bot-factory bots))
63 | 
64 |   (define (cust-loop)
65 |     (logger "Starting Custodian")
66 |     (define cust (make-custodian))
67 |     (parameterize ([current-custodian cust])
68 |       (define threads (build-vector total-bots start-bot))
69 |       (define revive (reviver threads start-bot))
70 |       (logger "Threads initialized")
71 |       (sleep init-sleep)
72 |       (define (loop x)
73 |         (unless (= x sleep-count)
74 |           (logger "Checking on bots")
75 |           (for-each revive (span total-bots))
76 |           (sleep sleep-time)
77 |           (loop (add1 x))))
78 |       (loop 0))
79 |     (when hard-restart
80 |       (logger "Shutting down Custodian")
81 |       (custodian-shutdown-all cust)
82 |       (sleep 30))
83 |     (cust-loop))
84 |   (cust-loop))
85 | 
86 | (module+ main
87 |   (command-line
88 |    #:program "supervisor"
89 |    #:args (config-file)
90 |    (supervisor config-file)))
91 | 
92 | ; end
93 | 


--------------------------------------------------------------------------------
/README.md:
--------------------------------------------------------------------------------
 1 | Discord Bots
 2 | ============
 3 | 
 4 | ## Archival Notice
 5 | 
 6 | Hello anyone stumbling across this repo. As it currently stands, this is one of my most starred repositories, and I started it years ago to make it easier to write Discord bots in Python using the `discord.py` API, which works great and I had a fun time doing it. However, it is time for me to archive this repository, as there is no support or new additions ever coming.
 7 | 
 8 | My last "real" commit on this project was over 6 years ago, and I mostly stopped using this many moons ago and no longer plan on contributing code to this. I am still bumping merge requests from the automated systems to bump dependencies, but even that feels unnecessary. I would rather archive this and let it be preserved; anyone interested in supporting this can fork this and make new additions / do whatever they please. It is MIT licensed, you can do as you wish.
 9 | 
10 | This notice will be the last commit, and I will publish this as a 1.1 tag to make it final. Thank you for all the fish and stars, and I hope my code was helpful to anyone who happened to find it.
11 | 
12 | ---
13 | 
14 | A collection of Robots for Discord.
15 | 
16 | ### Docs
17 | 
18 | * [AsyncIO Docs](https://docs.python.org/3.4/library/asyncio.html)
19 | * [Discord.py API](http://discordpy.readthedocs.io/en/latest/api.html)
20 | * [Discord Dev Portal](https://discordapp.com/developers/docs/intro)
21 | 
22 | 
23 | ### Introduction
24 | 
25 | Discord, the popular chat service aimed at gamers, supports a WebSocket API for sending and receiving data. From this we can create Bot users, so this project has the sole focus of creating various bots to be used with the Discord service.
26 | 
27 | In it's current state, this project has Python code wrapping around the `discord.py` library itself to aid in the development of bots, as well as bots written in Python with many different goals of doing as much as they can.
28 | 
29 | Currently, there's two types of Bots that can be used with Discord:
30 | * Interactive chat bot - a bot that receives and can send messages to channels
31 | * WebHook bot - a bot that can only send data to a channel via a URI endpoint
32 | 
33 | 
34 | ### Requirements
35 | 
36 | To run this project you will need:
37 | 
38 | * Python 3.6
39 | * Racket 6.5 (for the `superv` manager)
40 | * Pip for Python
41 | * `virtualenv` installed from Pip
42 | * Your own set of Discord credentials to use with Bots
43 | 
44 | 
45 | ### Setup
46 | 
47 | The code can be cloned entirely from the Git repository and set up with Pip.
48 | 
49 | ```bash
50 | git clone https://gitlab.com/sleibrock/discord-bots.git && cd discord-bots
51 | virtualenv dev
52 | source dev/bin/activate # source dev/Scripts/activate for Windows
53 | make setup
54 | make run
55 | ```
56 | 
57 | Each bot needs a key in order to use the Discord API. A Chat Bot requires an access token that is assigned when you create a Bot account under your Discord Developer page. A WebHook Bot requires a WebHook URL to post data to. Keys are stored in JSON format for easy loading, so use the following format and store the keys under a `keys/` folder named `<bot-filename>.key`.
58 | ```json
59 | {
60 |     "key": "secret_key" # or https:// link for webhook bots
61 | }
62 | ```
63 | 
64 | 
65 | ### Bots Maintained Currently
66 | 
67 | Here's the list of bots under development.
68 | 
69 | * `dumb-bot`, a basic bot to integrate with the rest of the project
70 | * `dota-bot`, an automated daemon to send Dota match info through WebHooks
71 | * `eco-bot`, a game-economy assistant to look up prices (early development stages)
72 | 
73 | Other bots are currently being ported from an older library, have been removed, 
74 | or are just undergoing plain old experimentation for the time being. Disabled bots
75 | lie in the `junkyard` folder.
76 | 


--------------------------------------------------------------------------------
/junkyard/dumb-bot.py:
--------------------------------------------------------------------------------
  1 | #!/usr/bin/env python
  2 | #-*- coding: utf-8 -*-
  3 | 
  4 | """
  5 | Dumb-bot
  6 | 
  7 | The dumbest bot of them all
  8 | Mostly a collection of scraping utilities and 
  9 | otherwise non-related functions
 10 | """
 11 | 
 12 | from botinfo import *
 13 | from bs4 import BeautifulSoup as BS
 14 | from requests import get as re_get
 15 | from random import randint, choice
 16 | 
 17 | help_msg = """
 18 | The Discord Bot Project
 19 | https://github.com/sleibrock/discord-bots
 20 | 
 21 | Command reference
 22 | https://github.com/sleibrock/discord-bots/blob/master/docs/bot-command-guide.md
 23 | """
 24 | 
 25 | bot_name = "dumb-bot"
 26 | client = discord.Client()
 27 | logger = create_logger(bot_name)
 28 | shared_data = create_filegen("shared")
 29 | 
 30 | # Twitch info here
 31 | TWITCH = "https://api.twitch.tv/kraken"
 32 | TKEY   = read_key("twitch")
 33 | STRAMS = f"{TWITCH}/streams/?game={'{}'}&client_id={TKEY}&limit=1"
 34 | 
 35 | @register_command
 36 | async def howto(msg, mobj):
 37 |     """
 38 |     Return a help message
 39 |     If you came here from !howto help; there's nothing else, sorry
 40 |     """
 41 |     return await client.send_message(mobj.channel, pre_text(help_msg))
 42 | 
 43 | @register_command
 44 | async def rtd(msg, mobj):
 45 |     """
 46 |     Roll a d<N> di[c]e <X> number of times
 47 |     Example: !rtd 2d10 - rolls two d10 dice
 48 |     """
 49 |     if msg == "":
 50 |         return await client.send_message(mobj.channel, "You didn't say anything!")
 51 |     try:
 52 |         times, sides = list(map(int, msg.lower().split("d")))
 53 |         res = [randint(1, sides) for x in range(times)]
 54 |         return await client.send_message(mobj.channel, ", ".join(map(str, res)))
 55 |     except Exception as ex:
 56 |         logger(f"Error: {ex}")
 57 |     return await client.send_message(mobj.channel, "Error: bad input args")
 58 | 
 59 | @register_command
 60 | async def yt(msg, mobj):
 61 |     """
 62 |     Do a youtube search and yield the first result
 63 |     Example: !yt how do I take a screenshot
 64 |     """
 65 |     try:
 66 |         if msg == "":
 67 |             return await client.send_message(mobj.channel, "You didn't search for anything!")
 68 |         msg.replace(" ", "+")
 69 |         url = "https://www.youtube.com/results?search_query={}".format(msg)
 70 |         bs = BS(re_get(url).text, "html.parser")
 71 |         items = bs.find("div", id="results").find_all("div", class_="yt-lockup-content")
 72 |         if not items:
 73 |             return await client.send_message(mobj.channel, "Couldn't find any results")
 74 | 
 75 |         # Search for a proper youtube url, has to start with /watch
 76 |         # TODO: rewrite this with a list comp/filter
 77 |         i, found = 0, False
 78 |         while not found and i < 20:
 79 |             href = items[i].find("a", class_="yt-uix-sessionlink")["href"]
 80 |             if href.startswith("/watch"):
 81 |                 found = True
 82 |             i += 1
 83 |         if not found:
 84 |             return await client.send_message(mobj.channel, "Couldn't find a link")
 85 |         return await client.send_message(mobj.channel, f"https://youtube.com{href}")
 86 |     except Exception as ex:
 87 |         logger("Fail: {}".format(ex))
 88 |     return await client.send_message(mobj.channel, "Failed to request the search")
 89 | 
 90 | @register_command
 91 | async def streams(msg, mobj):
 92 |     pass
 93 | 
 94 | @register_command
 95 | async def clipreg(msg, mobj):
 96 |     """
 97 |     Register a Twitch.tv username into the Clips registry
 98 |     Used to bookmark names to Twitch accounts for ez access
 99 |     Must test the urls given to make sure it's a real Twitch account
100 |     Example: !clipreg bulldog admiralbulldog
101 |     """
102 |     pass
103 | 
104 | @register_command
105 | async def clips(msg, mobj):
106 |     """
107 |     Fetch a clip from a certain registered bookmark
108 |     If no bookmark given (but entries exist), get a random clip
109 |     Example: !clips summit1g
110 |            -> <link to random popular clip>
111 |     """
112 |     pass
113 | 
114 | @register_command
115 | async def dota_id(msg, mobj):
116 |     """
117 |     Registers a user's Discord ID with a Dota 2 player ID
118 |     This will be used by the automated Dota 2 match parser service
119 |     The string given is tested against OpenDota's API to see if it's valid
120 |     """
121 |     if len(msg) > 30:
122 |         return await client.send_message(mobj.channel, "Bro that's too long")
123 | 
124 |     r = re_get(f"{OPENDOTA_API}/players/{msg.strip()}")
125 |     if r.status_code != 200:
126 |         return await client.send_message(mobj.channel, "Invalid Dota 2 ID")
127 | 
128 |     fname = shared_data(f"{mobj.author.id}.dota")
129 |     with open(fname, 'w') as f:
130 |         f.write(msg.strip())
131 | 
132 |     return await client.send_message(
133 |         mobj.channel,
134 |         "Registered Player ID {msg.strip()}"
135 |     )
136 | 
137 | # Last step - register events then run
138 | setup_all_events(client, bot_name, logger)
139 | if __name__ == "__main__":
140 |     run_the_bot(client, bot_name, logger)
141 | 
142 | # end
143 | 
144 | 


--------------------------------------------------------------------------------
/junkyard/graph-bot.py:
--------------------------------------------------------------------------------
  1 | #!/usr/bin/env python
  2 | #-*- coding: utf-8 -*-
  3 | 
  4 | """
  5 | Graph-bot
  6 | 
  7 | Creates graphs, stores them in the data folder,
  8 | then removes them once uploaded
  9 | 
 10 | This will probably eat up 100MB of memory
 11 | """
 12 | 
 13 | from botinfo import *
 14 | import matplotlib
 15 | matplotlib.use('Agg') # only way to render without an Xserver running
 16 | import matplotlib.pylab as plt
 17 | from sympy import sympify, Abs
 18 | from sympy.plotting import plot, plot3d
 19 | from sympy.utilities.lambdify import lambdify
 20 | from mpmath import cplot
 21 | from numpy import matrix as np_matrix
 22 | from os import remove as f_remove
 23 | from ast import literal_eval
 24 | 
 25 | bot_name = "graph-bot"
 26 | client = discord.Client()
 27 | logger = create_logger(bot_name)
 28 | bot_data = create_filegen(bot_name)
 29 | sample_size = 2000 # used for complex graphing
 30 | 
 31 | def monkey_patch_function(expr):
 32 |     """
 33 |     Name says it all
 34 |     Monkey patch any functions with bad func names (abs -> Abs)
 35 |     If anything else needs to be fixed, goes here
 36 |     """
 37 |     return expr.replace(sympify("abs(x)").func, Abs)
 38 | 
 39 | def create_plot(expr, s, color='b'):
 40 |     """
 41 |     Create a plot based on whether it's 1-variable or 2-variable
 42 |     Raise Index error if we don't have any variables, or more than 2
 43 |     """
 44 |     if len(expr.free_symbols) == 1:
 45 |         var1 = list(expr.free_symbols)[0]
 46 |         p = plot(expr, (var1, s["xmin"], s["xmax"]),
 47 |                        xlim=(s["xmin"], s["xmax"]),
 48 |                        ylim=(s["ymin"], s["ymax"]),
 49 |                        legend=True, show=False,
 50 |                        line_color=color)
 51 |     elif len(expr.free_symbols) == 2:
 52 |         var1, var2 = list(expr.free_symbols)
 53 |         p = plot3d(expr, (var1, s["xmin"], s["xmax"]),
 54 |                          (var2, s["ymin"], s["ymax"]),
 55 |                          xlim=(s["xmin"], s["xmax"]),
 56 |                          ylim=(s["ymin"], s["ymax"]),
 57 |                          title=str(expr), show=False)
 58 |     else:
 59 |         raise IndexError("Too many or too little variables")
 60 |     return p
 61 | 
 62 | @register_command
 63 | async def graph(msg, mobj):
 64 |     """
 65 |     Do a 2D-plot of a user's given function
 66 |     Ex1: !graph cos(x)*10
 67 |     Ex2: !graph cos(x)*10, xmax=10, xmin=-7
 68 |     """
 69 |     s = {'xmax':10.0, 'xmin':-10.0,
 70 |          'ymax':10.0, 'ymin':-10.0,}
 71 |     fname = bot_data("{}.png".format(mobj.author.id))
 72 |     try:
 73 |         firstp = msg.split(",") # seperate equation from additional args
 74 |         func = firstp[0]
 75 |         if len(firstp) > 1:
 76 |             for p in firstp[1:]:
 77 |                 arg, val = p.strip().split("=")
 78 |                 if arg in s.keys():
 79 |                     s[arg] = float(val)
 80 |                 else:
 81 |                     return await client.send_message(mobj.channel, "Invalid arguments")
 82 |                 if not all([isinstance(x, float) for x in s.values()]):
 83 |                     return await client.send_message(mobj.channel, "Invalid arguments")
 84 |         graph = create_plot(monkey_patch_function(sympify(func)), s)
 85 |         graph.save(fname)
 86 |         await client.send_file(mobj.channel, fname)
 87 |         f_remove(fname)
 88 |         return
 89 |     except Exception as ex:
 90 |         logger("!graph: {}".format(ex))
 91 |     return await client.send_message(mobj.channel, "Failed to render graph")
 92 | 
 93 | @register_command
 94 | async def graphc(msg, mobj):
 95 |     """
 96 |     Graph a complex equation (using mpmath functions and plotting)
 97 |     Equations should map to the complex domain
 98 |     Ex: !complex gamma(x)
 99 |     """
100 |     fname = bot_data("{}.png".format(mobj.author.id))
101 |     try:
102 |         firstp = msg.split(",")
103 |         func = firstp[0]
104 |         expr = sympify(func)
105 |         var = list(expr.free_symbols)[0]
106 |         lamb = lambdify(var, monkey_patch_function(sympify(func)), modules=["mpmath"])
107 |         cplot(lamb, points=sample_size, file=fname)
108 |         await client.send_file(mobj.channel, fname)
109 |         f_remove(fname)
110 |         return
111 |     except Exception as ex:
112 |         logger("!graphc: {}".format(ex))
113 |     return await client.send_message(mobj.channel, "Failed to render graph")
114 | 
115 | async def calculus(msg, mobj, lam, col):
116 |     """
117 |     Base function to perform some kind of calculus
118 |     :lam is the type of operation we want, should be a lambda function
119 |     :col is the color of the plot we want to have
120 |     """
121 |     s = {'xmax':10.0, 'xmin':-10.0,
122 |          'ymax':10.0, 'ymin':-10.0,}
123 |     fname = bot_data("{}.png".format(mobj.author.id))
124 |     try:
125 |         firstp = msg.split(",")
126 |         func = firstp[0]
127 |         expr = monkey_patch_function(sympify(func))
128 |         var = list(expr.free_symbols)[0]
129 |         graph = create_plot(expr, s)
130 |         graph.extend(create_plot(lam(expr), s, color=col))
131 |         graph.save(fname)
132 |         await client.send_file(mobj.channel, fname)
133 |         f_remove(fname)
134 |         return
135 |     except Exception as ex:
136 |         logger("!calculus: {}".format(ex))
137 |     return await client.send_message(mobj.channel, "Failed to render graph")
138 | 
139 | @register_command
140 | def integrate(msg, mobj):
141 |     """
142 |     Integrate a given function to yield it's anti-derivative
143 |     Function must be continuous, and all results technically have a hidden constant
144 |     Ex: !integrate cos(x)**2
145 |     """
146 |     return calculus(msg, mobj, lambda e: e.integrate(), 'r')
147 | 
148 | @register_command
149 | def derive(msg, mobj):
150 |     """
151 |     Derive a given function to yield it's first derivative
152 |     Note: must be a continuous function
153 |     Ex: !derive x^3
154 |     """
155 |     return calculus(msg, mobj, lambda e: e.diff(), 'g')
156 | 
157 | @register_command
158 | async def matrix(msg, mobj):
159 |     """
160 |     Interpret a user string, convert it to a list and graph it as a matrix
161 |     Uses ast.literal_eval to parse input into a list
162 |     """
163 |     fname = bot_data("{}.png".format(mobj.author.id))
164 |     try:
165 |         list_input = literal_eval(msg)
166 |         if not isinstance(list_input, list):
167 |             raise ValueError("Not a list")
168 |         m = np_matrix(list_input)
169 |         fig = plt.figure()
170 |         ax = fig.add_subplot(1,1,1)
171 |         ax.set_aspect('equal')
172 |         plt.imshow(m, interpolation='nearest', cmap=plt.cm.ocean)
173 |         plt.colorbar()
174 |         plt.savefig(fname)
175 |         await client.send_file(mobj.channel, fname)
176 |         f_remove(fname)
177 |         return
178 |     except Exception as ex:
179 |         logger("!matrix: {}".format(ex))
180 |     return await client.send_message(mobj.channel, "Failed to render graph")
181 | 
182 | setup_all_events(client, bot_name, logger)
183 | if __name__ == "__main__":
184 |     run_the_bot(client, bot_name, logger)
185 | 
186 | # end
187 | 
188 | 


--------------------------------------------------------------------------------
/junkyard/remind-bot.py:
--------------------------------------------------------------------------------
  1 | #!/usr/bin/env python
  2 | #-*- coding: utf-8 -*-
  3 | 
  4 | from botinfo import *
  5 | from time import time, mktime
  6 | from datetime import datetime, timedelta
  7 | 
  8 | # bot info and whatever who cares
  9 | bot_name = "remind-bot"
 10 | client = discord.Client()
 11 | logger = create_logger(bot_name)
 12 | bot_data = create_filegen(bot_name)
 13 | 
 14 | # only support weeks, days and hours right now
 15 | # months and years involves specific edge cases and leap years etc
 16 | units = ["weeks", "days", "hours", "minutes"]
 17 | units.extend([t[:-1] for t in units])
 18 | 
 19 | # settings - used to mutate state across the module
 20 | settings = {"readloop":True,
 21 |             "max_rem": 10,
 22 |             }
 23 | 
 24 | helpmsg = pre_text("""Remind-bot
 25 | Hold up to 10 reminders for remind-bot to remind you about
 26 | Usage: <message> !! <time span>
 27 | Example: dont drink that poison!! 3 hours 20 minutes
 28 | Clear:   !!clear
 29 | List:    !!list
 30 | 
 31 | Disclaimer: reminders are not encrypted, they are stored in plaintext
 32 | """)
 33 | 
 34 | def pretty_res_date(res_date):
 35 |     """
 36 |     Convert a res date list into a pretty list for printing
 37 |     If k==0 then we bump the index up to a single unit
 38 | 
 39 |     i + (units.length/2) * int(k==0) -> 1 minute instead of 1 minutes
 40 |     """
 41 |     result = ["{} {}".format(k, units[i+((len(units)//2)*int(k==1))])
 42 |               for i, k in enumerate(res_date) if k != 0]
 43 |     return ", ".join(result)
 44 | 
 45 | def time_remaining(utime):
 46 |     """
 47 |     Invert a unix time stamp and convert it to a "time remaining"
 48 |     stamp representing weeks/days/hours/minutes
 49 |     Check if the time stamp already expired (if utime <= cur_time)
 50 |     """
 51 |     pass
 52 | 
 53 | def create_offset(time_arr):
 54 |     """
 55 |     Turn a time array of ints into a unix time stamp
 56 |     representing the reminder's time delta
 57 |     """
 58 |     delta = timedelta(days=time_arr[1], weeks=time_arr[0], hours=time_arr[2], minutes=time_arr[3])
 59 |     offset = datetime.now() + delta
 60 |     return mktime(offset.timetuple())
 61 | 
 62 | @client.event
 63 | async def on_ready():
 64 |     """
 65 |     Basic function to log in and set up data
 66 |     """
 67 |     if not setup_bot_data(bot_name, logger):
 68 |         logger("Failed to set up {}'s folder".format(bot_name))
 69 |         client.close()
 70 |     return logger("Connection status: {}".format(client.is_logged_in))
 71 | 
 72 | @client.event
 73 | async def on_error(msg, *args, **kwargs):
 74 |     """
 75 |     When bot receives a fatal websocket error, close the
 76 |     reading thread down and close the client
 77 |     """
 78 |     settings["readloop"] = False
 79 |     client.close()
 80 |     return logger("Discord error: {}".format(msg))
 81 | 
 82 | @client.event
 83 | async def on_message(msg):
 84 |     """
 85 |     Function to handle message dispatch
 86 |     For commands we check if certain ones are equal length to desired commands
 87 |     """
 88 |     auth = str(msg.author.id)
 89 |     m = msg.content.strip()
 90 |     if contains_badwords(m.lower()):
 91 |         return
 92 | 
 93 |     if "!!" not in m:
 94 |         return
 95 | 
 96 |     if m == "!!help":
 97 |         return await client.send_message(msg.channel, helpmsg)
 98 | 
 99 |     if m == "!!clear":
100 |         with open(bot_data(auth), "w") as f:
101 |             f.write("")
102 |         return await client.send_message(msg.author, "Reminders cleared.")
103 | 
104 |     # TODO: convert utimes into remaining time for this function
105 |     if m.startswith('!!list') and len(m) == 6:
106 |         pass
107 | 
108 |     # Check if the input string doesn't match our conditions
109 |     if m.count("!!") != 1 or len(m) < 10:
110 |         return
111 | 
112 |     # strip the message from the time span
113 |     dmsg, tmsg = m.split("!!")
114 | 
115 |     # Transform strings that look like 2d 3h into timedeltas
116 |     splits = tmsg.lower().strip().split(" ")
117 | 
118 |     # Stop if no time span was given (ie: empty list or less than 2 units of text)
119 |     if not splits or len(splits) < 2:
120 |         return
121 | 
122 |     # convert a time span string into an array of ints
123 |     res = [0,0,0,0] # weeks, days, hours, minutes
124 |     while len(splits) != 0:
125 |         num = splits.pop(0) # check if it's a number
126 |         if not num.isnumeric():
127 |             return
128 |         unit = splits.pop(0) # check what unit this is
129 |         if unit not in units:
130 |             return
131 |         index = units.index(unit) % (len(units)//2) # oddest looking code here
132 |         if res[index] != 0:
133 |             return
134 |         res[index] = int(num)
135 | 
136 |     # check to see if a user gave us all 0 units (0 hours, 0 days, etc)
137 |     if not any(res):
138 |         return await client.send_message(msg.author, "Cannot use zero-time delta")
139 | 
140 |     # Read a users file to scan for their previous reminders
141 |     if not isfile(bot_data(auth)):
142 |         lines = []
143 |     else:
144 |         lines = read_lines(bot_data(auth))
145 |         if len(lines) >= settings["max_rem"]:
146 |             return await client.send_message(msg.author, "Full! Clear your list with '!!clear'")
147 | 
148 |     lines.append("{},{}".format(int(create_offset(res)), dmsg))
149 |     with open(bot_data(auth), "w") as f:
150 |         f.write("\n".join(lines))
151 | 
152 |     return await client.send_message(msg.author, "Reminder set for {}".format(pretty_res_date(res)))
153 | 
154 | async def scan_reminders():
155 |     """
156 |     Function to scan all users reminder files
157 |     Builds up a queue then dispatches reminders to each reminder in the queue
158 |     """
159 |     while settings["readloop"]:
160 |         await asyncio.sleep(60) # scan once every 5 minutes
161 |         queue = list()
162 |         for f in listdir(bot_folder(bot_name)):
163 |             with open(bot_data(f), 'r') as df:
164 |                 lines = df.readlines()
165 |             rewrite = list()
166 |             for line in [l.strip() for l in lines if l.strip() != ""]:
167 |                 tstamp, msg = line.split(",")
168 |                 if int(tstamp) <= int(time()):
169 |                     queue.append((f, msg))
170 |                 else:
171 |                     rewrite.append(line)
172 | 
173 |             with open(bot_data(f), 'w') as df:
174 |                 df.write("\n".join(rewrite))
175 | 
176 |         if not client.is_logged_in or client.is_closed:
177 |             settings["readloop"] = False
178 |             return logger("Client is not logged in")
179 | 
180 |         # dispatch alerts that were queued
181 |         for alert in queue:
182 |             if not await send_message(*alert):
183 |                 logger("Couldn't dispatch message to {}".format(alert[0]))
184 |     return logger("Reading thread closed")
185 | 
186 | async def send_message(uid, msg):
187 |     """
188 |     Dispatch a message to a given UID
189 |     Discord does not allow for direct User object creation
190 |     So we have to search in all servers for a user to match the UID
191 |     Then send that user a message
192 |     False if it could not send (invalid UID, network connection error...)
193 |     """
194 |     for server in client.servers:
195 |         for user in server.members:
196 |             if str(user.id) == uid:
197 |                 return await client.send_message(user, "This is your reminder for: {}".format(msg))
198 |     return False
199 | 
200 | if __name__ == "__main__":
201 |     run_the_bot(client, bot_name, logger)
202 | 
203 | # end
204 | 


--------------------------------------------------------------------------------
/junkyard/dotabot.go:
--------------------------------------------------------------------------------
  1 | package main
  2 | 
  3 | import (
  4 | 	"bytes"
  5 | 	"encoding/json"
  6 | 	"fmt"
  7 | 	"io/ioutil"
  8 | 	"math"
  9 | 	"net/http"
 10 | )
 11 | 
 12 | // endpoints to use
 13 | var web_link = "https://discordapp.com/api/webhooks/296303788057427969/CUr6cezgCmIjYfVrbcxTIu2HnFKSorOUv15DKwnOoEvJcTFx8ZMNRR5RhQyNCqodHCHI"
 14 | var dota_api = "https://api.opendota.com/api"
 15 | var matchurl = "https://opendota.com/matches"
 16 | var dota2log = "http://cdn.dota2.com/apps/dota2/images/nav/logo.png"
 17 | 
 18 | // Create a User struct to represent calls made to the OpenDota API
 19 | type User struct {
 20 | 	ID string
 21 | }
 22 | 
 23 | type Hero struct {
 24 | 	ID   uint   `json:"id"`
 25 | 	Name string `json:"localized_name"`
 26 | }
 27 | 
 28 | type MatchInfo struct {
 29 | 	MatchID  uint64 `json:"match_id"`
 30 | 	GameMode uint   `json:"game_mode"`
 31 | }
 32 | 
 33 | type Rune struct {
 34 | 	Bounty uint `json:"5"`
 35 | }
 36 | 
 37 | type Player struct {
 38 | 	AccountID uint64 `json:"account_id"`
 39 | 	Nickname  string `json:"personaname"`
 40 | 	HeroID    uint   `json:"hero_id"`
 41 | 	Kills     uint64 `json:"kills"`
 42 | 	Deaths    uint64 `json:"deaths"`
 43 | 	Assists   uint64 `json:"assists"`
 44 | 	IsRadiant bool   `json:"isRadiant"`
 45 | 	Pings     uint   `json:"pings"`
 46 | 	GPM       uint   `json:"gold_per_min"`
 47 | 	XPM       uint   `json:"xp_per_min"`
 48 | 	Runes     Rune   `json:"runes"`
 49 | }
 50 | 
 51 | type GameInfo struct {
 52 | 	MatchID      uint64   `json:"match_id"`
 53 | 	RadiantScore uint     `json:"radiant_score"`
 54 | 	DireScore    uint     `json:"dire_score"`
 55 | 	GameMode     uint     `json:"game_mode"`
 56 | 	RadiantWin   bool     `json:"radiant_win"`
 57 | 	Players      []Player `json:"players"`
 58 | 	Chat         []struct {
 59 | 		PlayerNick string `json:"unit"`
 60 | 		Message    string `json:"key"`
 61 | 	}
 62 | }
 63 | 
 64 | type Embed struct {
 65 | 	Title       string   `json:"title"`
 66 | 	Description string   `json:"description"`
 67 | 	URL         string   `json:"url"`
 68 | 	Color       uint     `json:"color"`
 69 | 	Thumbnail   ThumbEmb `json:"footer"`
 70 | 	Fields      []EField `json:"fields"`
 71 | }
 72 | 
 73 | type ThumbEmb struct {
 74 | 	URL    string `json:"url"`
 75 | 	Width  uint   `json:"width"`
 76 | 	Height uint   `json:"height"`
 77 | }
 78 | 
 79 | type EField struct {
 80 | 	Name   string `json:"name"`
 81 | 	Value  string `json:"value"`
 82 | 	Inline bool   `json:"inline"`
 83 | }
 84 | 
 85 | type Message struct {
 86 | 	Embeds []Embed `json:"embeds"`
 87 | }
 88 | 
 89 | func (g GameInfo) GetData(uid uint64, heroes []Hero) Message {
 90 | 	var fields []EField
 91 | 
 92 | 	var p Player
 93 | 	for _, player := range g.Players {
 94 | 		if player.AccountID == uid {
 95 | 			p = player
 96 | 		}
 97 | 	}
 98 | 	if p == (Player{}) {
 99 | 		panic("Failed to find user ID")
100 | 	}
101 | 
102 | 	var hero Hero
103 | 	for _, h := range heroes {
104 | 		if h.ID == p.HeroID {
105 | 			hero = h
106 | 		}
107 | 	}
108 | 
109 | 	var victory string
110 | 	if g.RadiantWin && p.IsRadiant {
111 | 		victory = "won"
112 | 	} else {
113 | 		victory = "lost"
114 | 	}
115 | 
116 | 	// Very basic field
117 | 	fields = append(fields, EField{
118 | 		"K/D/A",
119 | 		fmt.Sprintf("%d/%d/%d", p.Kills, p.Deaths, p.Assists),
120 | 		true,
121 | 	})
122 | 
123 | 	fields = append(fields, EField{
124 | 		"GPM / XPM",
125 | 		fmt.Sprintf("%d / %d", p.GPM, p.XPM),
126 | 		true,
127 | 	})
128 | 
129 | 	// Calculate the Ping statistic
130 | 	var totalPings uint
131 | 	if p.Pings != 0 {
132 | 		for _, player := range g.Players {
133 | 			if player.IsRadiant == p.IsRadiant {
134 | 				totalPings += player.Pings
135 | 			}
136 | 		}
137 | 		fields = append(fields, EField{
138 | 			"Pings Used",
139 | 			fmt.Sprintf("%d (%.2f%% of team)", p.Pings, (100.0 * float32(p.Pings) / float32(totalPings))),
140 | 			true,
141 | 		})
142 | 	}
143 | 
144 | 	// Bounty rune field
145 | 	var totalBounties uint
146 | 	if p.Runes != (Rune{}) {
147 | 		for _, player := range g.Players {
148 | 			if player.Runes != (Rune{}) {
149 | 				totalBounties += player.Runes.Bounty
150 | 			}
151 | 		}
152 | 		fields = append(fields, EField{
153 | 			"Bounty Runes Collected",
154 | 			fmt.Sprintf(
155 | 				"%d (%.2f%% of all bounties)",
156 | 				p.Runes.Bounty,
157 | 				(100.0 * float32(p.Runes.Bounty) / float32(totalBounties)),
158 | 			),
159 | 			true,
160 | 		})
161 | 	}
162 | 
163 | 	// search for longest chat message
164 | 	var longest string
165 | 	for _, chat := range g.Chat {
166 | 		if chat.PlayerNick == p.Nickname {
167 | 			if len(chat.Message) > len(longest) {
168 | 				longest = chat.Message
169 | 			}
170 | 		}
171 | 	}
172 | 	if longest != "" {
173 | 		fields = append(fields, EField{
174 | 			"Longest Chat",
175 | 			fmt.Sprintf("'%s' -%s", longest, p.Nickname),
176 | 			true,
177 | 		})
178 | 	}
179 | 
180 | 	msg := Message{
181 | 		[]Embed{
182 | 			Embed{
183 | 				fmt.Sprintf("Results for Match %d", g.MatchID),
184 | 				fmt.Sprintf(p.Nickname + " " + victory + " as " + hero.Name),
185 | 				fmt.Sprintf("%s/%d", matchurl, g.MatchID),
186 | 				uint(math.Mod(float64(g.MatchID), 16777215.0)), // color
187 | 				ThumbEmb{dota2log, 167, 33},
188 | 				fields,
189 | 			},
190 | 		},
191 | 	}
192 | 	return msg
193 | }
194 | 
195 | func LoadHeroes() []Hero {
196 | 	dat, err := ioutil.ReadFile("heroes.json")
197 | 	if err != nil {
198 | 		// File is most likely not found
199 | 		r := fetch(fmt.Sprintf("%s/heroes", dota_api), "Failed to fetch Hero Data")
200 | 		we := ioutil.WriteFile("heroes.json", r, 0655)
201 | 		if we != nil {
202 | 			panic("Failed to write to file")
203 | 		}
204 | 
205 | 		var v []Hero
206 | 		e := json.Unmarshal(r, &v)
207 | 		if e != nil {
208 | 			panic("Couldn't parse Hero JSON data")
209 | 		}
210 | 		return v
211 | 	}
212 | 	var v []Hero
213 | 	e := json.Unmarshal(dat, &v)
214 | 	if e != nil {
215 | 		panic("Hero file corrupted and can't be read")
216 | 	}
217 | 	return v
218 | }
219 | 
220 | func fetch(url string, errmsg string) []byte {
221 | 	resp, err := http.Get(url)
222 | 	if err != nil {
223 | 		panic(errmsg)
224 | 	}
225 | 	data, err := ioutil.ReadAll(resp.Body)
226 | 	if err != nil {
227 | 		panic("Failed to read data blob")
228 | 	}
229 | 	return data
230 | }
231 | 
232 | func post(msg Message) {
233 | 	jv, err := json.Marshal(msg)
234 | 	if err != nil {
235 | 		panic("Can't construct JSON message")
236 | 	}
237 |     fmt.Println(bytes.NewBuffer(jv))
238 | 	_, err2 := http.Post(web_link, "application/json", bytes.NewBuffer(jv))
239 | 	if err2 != nil {
240 | 		panic("Failed to send WebHook message")
241 | 	}
242 | }
243 | 
244 | func LastMatch(uid uint64) uint64 {
245 | 	s := fmt.Sprintf("%s/players/%d/matches?limit=1", dota_api, uid)
246 | 	r := fetch(s, "Failed to get Matches")
247 | 
248 | 	var j []MatchInfo
249 | 	err := json.Unmarshal(r, &j)
250 | 	if err != nil {
251 | 		panic("Failed to read JSON")
252 | 	}
253 | 
254 | 	for _, match := range j {
255 | 		return match.MatchID
256 | 	}
257 | 	return 0
258 | }
259 | 
260 | func ParseMatch(mid uint64, uid uint64, heroes []Hero) {
261 | 	s := fmt.Sprintf("%s/matches/%d", dota_api, mid)
262 | 	r := fetch(s, "Failed to get game data")
263 | 
264 | 	var game GameInfo
265 | 	err := json.Unmarshal(r, &game)
266 | 	if err != nil {
267 | 		panic("Failed to read JSON")
268 | 	}
269 | 
270 | 	// start parsing the game info here
271 | 	msg := game.GetData(uid, heroes)
272 | 	post(msg)
273 | }
274 | 
275 | func main() {
276 | 	var steve uint64
277 | 	steve = 40281889
278 | 	heroes := LoadHeroes()
279 | 	last := LastMatch(steve)
280 | 	fmt.Println("Steve's last match was", last)
281 | 	fmt.Println("Printing match to Discord")
282 | 	ParseMatch(last, steve, heroes)
283 | 	fmt.Println("Done")
284 | 	return
285 | }
286 | 
287 | // end
288 | 


--------------------------------------------------------------------------------
/bots/dumb-bot.py:
--------------------------------------------------------------------------------
  1 | #!/usr/bin/env python
  2 | #-*- coding: utf-8 -*-
  3 | 
  4 | from random import randint, choice
  5 | from Bot import ChatBot
  6 | from requests import get
  7 | from bs4 import BeautifulSoup as BS
  8 | from json import dump as jdump
  9 | 
 10 | class DumbBot(ChatBot):
 11 |     """
 12 |     Dumb Bot is a basic toy bot integration
 13 |     He has some built in functionality as well as webhook-bot
 14 |     integrations to provide a connection to webhooks
 15 | 
 16 |     WebHook data is stored in the 'shared' folder, so we
 17 |     allow Dumb Bot to access the shared pool
 18 |     """
 19 | 
 20 |     STATUS = "I'm a bot, Beep Bloop!"
 21 |     GIT_URL = "https://github.com/sleibrock/discord-bots"
 22 | 
 23 |     # Other strings
 24 |     YOUTUBE_URL = "https://www.youtube.com"
 25 | 
 26 |     # Used to convert chars to emojis for self.roll()
 27 |     emojis = {f"{i}":x for i, x in enumerate([f":{x}:" for x in
 28 |         ("zero", "one", "two", "three", "four", 
 29 |          "five", "six", "seven", "eight", "nine")])}
 30 | 
 31 | 
 32 |     def __init__(self, name):
 33 |         super(DumbBot, self).__init__(name)
 34 |         self.filegen = self._create_filegen("shared")
 35 | 
 36 | 
 37 |     @ChatBot.action('<Command>')
 38 |     async def help(self, args, mobj):
 39 |         """
 40 |         Show the documentation string for a given command
 41 |         If you came here from '!help help', hi and thanks for using me!
 42 |         Example: !help roll
 43 |         """
 44 |         if args:
 45 |             key = args[0]
 46 |             if not args[0].startswith(ChatBot.PREFIX):
 47 |                 key = f'{ChatBot.PREFIX}{args[0]}'
 48 |             if key in self.ACTIONS:
 49 |                 t = self.pre_text(f'Help for \'{key}\':{self.ACTIONS[key].__doc__}')
 50 |                 return await self.message(mobj.channel, t)
 51 | 
 52 |         keys = [f'{k}' for k in self.ACTIONS.keys()]
 53 |         longest = max((len(s) for s in keys)) + 2
 54 |         output = 'Thank you for choosing Dumb Bot™ for your channel\n'
 55 |         output += 'Here are the available commands\n\n'
 56 |         for c in keys:
 57 |             output += f'* {c.ljust(longest)} {self.HELPMSGS.get(c, "")}\n'
 58 |         output += f'\nFor more info on each command, use \'{ChatBot.PREFIX}help <command>\''
 59 |         output += f'\nVisit {self.GIT_URL} for more info'
 60 |         return await self.message(mobj.channel, self.pre_text(output))
 61 | 
 62 | 
 63 |     @ChatBot.action('<Status String>')
 64 |     async def status(self, args, mobj):
 65 |         """
 66 |         Change the bot's status to a given string
 67 |         Example: !status haha ur dumb
 68 |         """
 69 |         return await self.set_status(" ".join(args))
 70 | 
 71 | 
 72 |     @ChatBot.action('<Dota ID String>')
 73 |     async def dota(self, args, mobj):
 74 |         """
 75 |         Register a Dota ID (enable your profile as Public!)
 76 |         Example: !dota 40281889
 77 |         """
 78 |         p = self.filegen(f"{mobj.author.id}.dota")
 79 |         if not args:
 80 |             if p.is_file():
 81 |                 return await self.message(mobj.channel, f"ID: {p.read_text()}")
 82 |             return await self.message(mobj.channel, "No Dota ID supplied")
 83 | 
 84 |         # Get the first argument in the list and check if it's valid
 85 |         u = args[0].strip().strip("\n")
 86 |         if len(u) > 30 or not u.isnumeric():
 87 |             return await self.message(mobj.channel, "Invalid ID given")
 88 | 
 89 |         # Write to file and finish
 90 |         with open(p, 'w') as f:
 91 |             jdump({'dota_id': u}, f)
 92 |         return await self.message(mobj.channel, f"Registered ID {u}")
 93 | 
 94 | 
 95 |     @ChatBot.action()
 96 |     async def coin(self, args, mobj):
 97 |         """
 98 |         Do a coin flip
 99 |         Example: !coin
100 |         """
101 |         return await self.message(mobj.channel, choice([":monkey:", ":snake:"]))
102 | 
103 | 
104 |     @ChatBot.action('<Number>')
105 |     async def roll(self, args, mobj):
106 |         """
107 |         Make a roll (similar to Dota 2's /roll) between [1..1000]
108 |         Example: !roll 100
109 |         """
110 |         if not args or len(args) > 1:
111 |             return await self.message(mobj.channel, "Invalid arg count")
112 | 
113 |         x, = args
114 |         if not x.isnumeric():
115 |             return await self.message(mobj.channel, "Non-numeric arg given")
116 | 
117 |         num = int(x) # bad 
118 |         if num < 1 or num > 1000:
119 |             return await self.message(mobj.channel, "Invalid range given")
120 | 
121 |         res = [self.emojis[x] for x in str(randint(1, num)).zfill(len(x))]
122 |         return await self.message(mobj.channel, "".join(res))
123 | 
124 | 
125 |     @ChatBot.action('[Search terms]')
126 |     async def yt(self, args, mobj):
127 |         """
128 |         Get the first Youtube search result video
129 |         Example: !yt how do I take a screenshot
130 |         """
131 |         if not args:
132 |             return await self.message(mobj.channel, "Empty search terms")
133 |         
134 |         resp = get(f"{self.YOUTUBE_URL}/results?search_query={self.replace(' '.join(args))}")
135 |         if resp.status_code != 200:
136 |             return await self.message(mobj.channel, "Failed to retrieve search")
137 | 
138 |         # Build a BS parser and find all Youtube links on the page
139 |         bs = BS(resp.text, "html.parser")
140 |         main_d = bs.find('div', id='results')
141 |         if not main_d:
142 |             return await self.message(mobj.channel, 'Failed to find results')
143 | 
144 |         items = main_d.find_all("div", class_="yt-lockup-content")
145 |         if not items:
146 |             return await self.message(mobj.channel, "No videos found")
147 | 
148 |         # Loop until we find a valid non-advertisement link
149 |         for container in items:
150 |             href = container.find('a', class_='yt-uix-sessionlink')['href']
151 |             if href.startswith('/watch'):
152 |                 return await self.message(mobj.channel, f'{self.YOUTUBE_URL}{href}')
153 |         return await self.message(mobj.channel, "No YouTube video found")
154 | 
155 | 
156 |     @ChatBot.action('[String]')
157 |     async def spam(self, args, mobj):
158 |         """
159 |         Spam a channel with dumb things
160 |         Example: !spam :ok_hand:
161 |         """
162 |         if not args or len(args) > 10:
163 |             return await self.message(mobj.channel, "Invalid spam input")
164 |         y = args * randint(5, 20)
165 |         return await self.message(mobj.channel, f"{' '.join(y)}")
166 | 
167 |     @ChatBot.action('<Poll Query>')
168 |     async def poll(self, args, mobj):
169 |         """
170 |         Turn a message into a 'poll' with up/down thumbs
171 |         Example: !poll should polling be a feature?
172 |         """
173 |         await self.client.add_reaction(mobj, '👍')
174 |         await self.client.add_reaction(mobj, '👎')
175 |         return
176 | 
177 | 
178 |     @ChatBot.action('[Users]')
179 |     async def ban(self, args, mobj):
180 |         """
181 |         Ban a user from using bot commands (admin required)
182 |         Example: !ban @Username @Username2 ...
183 |         """
184 |         if not self.is_admin(mobj):
185 |             return await self.message(mobj.channel, "Admin permissions needed")
186 |         bancount = 0
187 |         ids = [self.convert_user_tag(x) for x in args]
188 |         for uid in ids:
189 |             if uid is not False:
190 |                 r = self.add_ban(uid)
191 |                 bancount += 1 if r else 0
192 |         return await self.message(mobj.channel, f"{bancount} users banned")
193 | 
194 | 
195 |     @ChatBot.action('[Users]')
196 |     async def unban(self, args, mobj):
197 |         """
198 |         Unban a user from the bot commands (admin required)
199 |         Example: !unban @Username @Username2 ...
200 |         """
201 |         if not self.is_admin(mobj):
202 |             return await self.message(mobj.channel, "Admin permissions needed")
203 |         unbanc = 0
204 |         ids = [self.convert_user_tag(x) for x in args]
205 |         for uid in ids:
206 |             if uid is not False:
207 |                 r = self.del_ban(uid)
208 |                 unbanc += 1 if r else 0
209 |         return await self.message(mobj.channel, f"{unbanc} users unbanned")
210 | 
211 | 
212 |     @ChatBot.action()
213 |     async def botinfo(self, args, mobj):
214 |         """
215 |         Print out debug information about the bot
216 |         Example: !botinfo
217 |         """
218 |         lines = []
219 | 
220 |         with open('.git/refs/heads/master') as f:
221 |             head_hash = f.read()[:-1]
222 | 
223 |         # All the lines used in the output
224 |         lines = [
225 |             f'Name: {self.name}',
226 |             f'Actions loaded: {len(self.ACTIONS)}',
227 |             f'Ban count: {len(self.BANS)}',
228 |             f'Commit version: #{head_hash[:7]}'
229 |             f'Commit URL: {self.GIT_URL}/commit/{head_hash}'
230 |         ]
231 |         return await self.message(mobj.channel, '```{}```'.format('\n'.join(lines)))
232 | 
233 | 
234 | if __name__ == '__main__':
235 |     DumbBot('dumb-bot').run()
236 |     pass
237 | 
238 | # end
239 | 


--------------------------------------------------------------------------------
/junkyard/FishFactBot.js:
--------------------------------------------------------------------------------
  1 | var Discordie = require('discordie');
  2 | 
  3 | //obnoxious array of fishfacts... will most likely be handled by a scraper some time in the future...
  4 | var factArray = 
  5 | [
  6 | 'Most fish reproduce by laying eggs, though some fish, such as great white sharks, give birth to live babies called pups.',
  7 | 'Starfish are not fish. Neither are jellyfish.',
  8 | "Although the fangtooth fish is only a few inches long, it has teeth about the size of a human's.",
  9 | 'The mudskipper is a fish that spends most of its time out of water and can "walk" on its fins. It carries a portable water supply in its gill chambers when it leaves the water. It can also breathe through the pores of its wet skin.',
 10 | 'Catfish have over 27,000 taste buds. Humans have around 7,000.',
 11 | 'Most brands of lipstick contain fish scales.',
 12 | 'Lungfish can live out of water for several years. It secretes a mucus cocoon and burrows itself under the unbaked earth. It takes in air with its lung through a built-in breathing tube that leads to the surface. A lungfish has both gills and a lung.',
 13 | 'Seahorses are the only fish that swim upright.',
 14 | 'Some fish, such as the great white shark, can raise their body temperature. This helps them hunt for prey in cold water.',
 15 | 'The oldest known age for a fish was an Australian lungfish. In 2003, it was still alive and well at 65 years old.',
 16 | 'Fish use a variety of low-pitched sounds to convey messages to each other. They moan, grunt, croak, boom, hiss, whistle, creak, shriek, and wail. They rattle their bones and gnash their teeth. However, fish do not have vocal chords. They use other parts of their bodies to make noises, such as vibrating muscles against their swim bladder.',
 17 | 'Fish can form schools containing millions of fish. They use their eyes and something called a lateral line to hold their places in the school. The lateral line is a row of pores running along the fish’s sides from head to tail. Special hairs in the pores sense changes in water pressure from the movements of other fish or predators.',
 18 | 'Since a fish’s jaw is not attached to its skull, many fishes can shoot their mouths forward like a spring to catch startled prey.',
 19 | 'Electric eels and electric rays have enough electricity to kill a horse',
 20 | 'Sharks are the only fish that have eyelids.',
 21 | 'Fish have sleep-like periods where they have lowered response to stimuli, slowed physical activity, and reduced metabolism but they do not share the same changes in brain waves as humans do when they sleep.',
 22 | 'Some fish, such as the herbivorous fish (grazers), often lack jaw teeth but have tooth-like grinding mills in their throats called pharyngeal teeth.',
 23 | 'Most fish have taste buds all over their body.',
 24 | 'An estimated one third of male fish in British waters are changing sex due to pollution in human sewage.',
 25 | 'Saltwater fish need to drink more water than freshwater fish. Since seawater is saltier than the liquids in a fish’s body, water inside the fish is constantly flowing out. If they didn’t drink to replace the lost water, saltwater fish would dry up like prunes.',
 26 | 'The oldest fishhook ever found dates back to about 42,000 years ago.',
 27 | 'Most fish have little salt in them. Sharks, however, have meat as salty as the ocean they live in.',
 28 | 'Most fish can see in color and use colors to camouflage themselves or defend themselves and their territory. Most fish have the best possible eyesight for their habitat and can most certainly see you peering at them in a fish tank. Some fish can see polarized and ultraviolet light.',
 29 | 'A fish does not add new scales as it grows, but the scales it has increase in size. In this way, growth rings are formed and the rings reveal the age of a fish.',
 30 | 'Fish that have thin fins with a split tail indicate that they move very quickly or may need them to cover great distances. On the other had, fish that live among rocks and reefs near the ocean floor have broad lateral fin and large tails.',
 31 | 'A ship has a heavy keel in the lower part to keep it from capsizing. Fish, on the other hand, have the keel on top. If the paired fins stop functioning to keep the fish balanced, the fish turns over because its heaviest part tends to sink, which happens when it dies.',
 32 | 'On average, flying fish can glide 160 feet (50m), but have been known to glide as far as 660 feet (200 m). And they can reach heights up to 19 feet (6m).',
 33 | 'An inflated porcupine fish can reach a diameter of up to 35 inches (90 cm). It puffs up by swallowing water and then storing it in its stomach. The stomach increases in size with more water. If the fish is taken out of water, it can inflate in a similar way by swallowing air.',
 34 | 'A fish can drown in water. Like humans, fish need oxygen, so if there isn’t enough oxygen in the water, they will suffocate.',
 35 | 'The fish in the middle of a school control the school. The fish on the outside are guided by those in the middle. Only bony fish can swim in highly coordinated groups.',
 36 | 'Most fish cannot swim backwards. Those that can are mainly members of one of the eel families.',
 37 | 'Fish would suffocate if they tried to chew because chewing would interfere with water passing over their gills.',
 38 | 'The biggest fish in the world is the giant whale shark, which can grow to nearly 60 feet, or the length of two school buses. It weighs over 25 tons and eats mainly plankton. It has over 4,000 teeth, though they are only 3 mm long.',
 39 | 'The most poisonous fish in the world is the stone fish. Its sting can cause shock, paralysis, and even death if not treated within a few hours.',
 40 | 'The word “piranha” is from the Tupi (Brazil) pira nya and means “scissors.” Found in freshwater rivers in South America, piranhas have razor-sharp teeth. They typically eat fish, insects, seeds, fruit, and even larger animals such as horses. While there are no proven reports of piranhas killing a person, they do eat human carcasses.',
 41 | 'The fastest fish is the sailfish. It can swim as fast as a car travels on the highway.',
 42 | 'The slowest fish is a seahorse. It swims so slowly that a person can barely tell it is moving. The slowest is the Dwarf Seahorse, which takes about one hour to travel five feet. It even looks like it is simply standing up, not swimming.',
 43 | 'Some fish do not have scales. Sharks, for example, have rough sandpapery skin instead of scales.',
 44 | 'Fish have multiple Christian and pre-Christian overtones. For example, the Greek word for fish is Ichthys, which is an acronym for "Jesus Christ, God’s Son, Savior" and was used to mark early Christian tombs and meeting places. Because of their association with fertility, fish have also been linked to Isis and Aphrodite.',
 45 | 'In Japan, the fugu, or puffer fish, is a succulent but lethal delicacy. It contains tetrodotoxin, a deadly poison. However, it is so delicious that Japanese gourmets risk their lives to prepare it. To make this high-risk dish, chefs must have a certificate from a special school that teaches preparation of this toxic fish.',	
 46 | ];
 47 | 
 48 | 
 49 | const Events = Discordie.Events;
 50 | const client = new Discordie();
 51 | 
 52 | 
 53 | client.connect(
 54 | {
 55 | 	token: 'MjQ2NTczMzYxOTIzMDk2NTc2.Cwcm5A.d2e1XhYxTnwErVkHIn33OzuptOE'
 56 | })
 57 | 
 58 | 
 59 | client.Dispatcher.on(Events.GATEWAY_READY, e => {
 60 | 	console.log('Connected as: FISHFACTBOT5000');
 61 | });
 62 | 
 63 | client.Dispatcher.on(Events.MESSAGE_CREATE, e => {
 64 | 
 65 | 	var incoming = e.message.content.toLowerCase();
 66 | 
 67 | 	if(incoming == '!fishfact')
 68 | 	{
 69 | 		//generate a random fishfact from the fishfact array and send to the channel as a message
 70 | 		var random = Math.floor(Math.random()*factArray.length);
 71 | 		var message = 'Fish Fact #' + (random +1) + "  - " +  factArray[random];
 72 | 		e.message.channel.sendMessage(message);
 73 | 	}
 74 | 
 75 | 	if(incoming.startsWith('!') && incoming.endsWith('fact') && incoming !== '!fishfact')
 76 | 	{
 77 | 		//generate a fish fact based on the type of fish requested by the user
 78 | 		var fish = incoming.substring(1,incoming.length-4).toLowerCase();
 79 | 		var fishArray = [];
 80 | 		//create a new array to hold the info about the fish
 81 | 		for(var i = 0; i < factArray.length; i++)
 82 | 		{
 83 | 			if(factArray[i].toLowerCase().includes(fish))
 84 | 			{
 85 | 				fishArray.push(factArray[i]);
 86 | 			}
 87 | 		}
 88 | 		// if theres no info about th desired fish let the user know nothing was found
 89 | 		if(fishArray.length == 0)
 90 | 		{
 91 | 			e.message.channel.sendMessage('I dont know anything about that!');
 92 | 		}
 93 | 
 94 | 		else
 95 | 		{
 96 | 			//otherwise send a random fact about the desired fish
 97 | 			fish = fish.charAt(0).toUpperCase() + fish.slice(1);
 98 | 			var random = Math.floor(Math.random()*fishArray.length);
 99 | 			var message = fish + ' Fact #' + (random +1) + ' - ' + fishArray[random];
100 | 			e.message.channel.sendMessage(message);
101 | 		}
102 | 	}
103 | 	if(incoming.includes('!fishfact#'))
104 | 	{
105 | 		//generate a specific fish fact for the user based on the total (currently 40)
106 | 		var whichFact = incoming.substring(10,incoming.lenth);
107 | 		var factNum = parseInt(whichFact);
108 | 		//send a message letting the user know they messed up the input either by putting in a negative number, non number, or a number that is too large
109 | 		if(factNum > factArray.length)
110 | 		{
111 | 			e.message.channel.sendMessage("I don't know that many facts yet! I only know " + factArray.length + ' facts.');
112 | 		}
113 | 		else if(factNum == NaN)
114 | 		{
115 | 			e.message.channel.sendMessage("Your fact number was either negative or not a number... Don't try and fool me!");
116 | 		}
117 | 		else
118 | 		{
119 | 			//if the input is ok send the desired fact back!
120 | 			var random = Math.floor(Math.random()*factArray.length);
121 | 			var message = 'Fish Fact #' + factNum + "  - " +  factArray[factNum-1];
122 | 			e.message.channel.sendMessage(message);
123 | 		}
124 | 	}
125 | });
126 | 
127 | 
128 | 


--------------------------------------------------------------------------------
/junkyard/botinfo.py:
--------------------------------------------------------------------------------
  1 | #!/usr/bin/env python
  2 | #-*- coding: utf-8 -*-
  3 | 
  4 | """
  5 | Packages to use across bot programs
  6 | 
  7 | TODO: perhaps use PathLib instead of os.path.join
  8 | """
  9 | 
 10 | import discord
 11 | from discord import Embed
 12 | import asyncio
 13 | from subprocess import getstatusoutput
 14 | from time import strftime, localtime
 15 | from os import mkdir, listdir
 16 | from os.path import isfile, isdir, join
 17 | from ast import literal_eval
 18 | from pathlib import Path
 19 | 
 20 | # Bot local data information
 21 | BOT_FOLDER = "botdata"
 22 | KEY_FOLDER = "keys"
 23 | SHR_FOLDER = "shared"
 24 | 
 25 | LOG_STR = "[\033[38;5;{3}m{0:<12}\033[0m @ {1}] {2}"
 26 | 
 27 | # shortcut to unpack a syscall from getstatusoutput
 28 | call = lambda p: getstatusoutput(p)[1]
 29 | 
 30 | # Prefix to use for automating registering commands
 31 | bot_prefix = "!"
 32 | 
 33 | # a map for all characters in URL search bars to replace
 34 | # most search engines replace " " with "+" but for the most
 35 | # part it seems to work with either/or '+' or '%20'
 36 | char_map = {" ": "%20", "'": "%27", "`": "%60", "%": "%25", "&": "%26",
 37 |             "!": "%21", "@": "%40", "#": "%23", "$": "%24", "+": "%2B",
 38 |             "*": "%2A", "^": "%5E", "(": "%28", ")": "%29", "=": "%3D",
 39 |             "[": "%5B", "]": "%5D", "{": "%7B", "}": "%7D"}
 40 | 
 41 | # I'm trying to stop malicious searches from my Pi ;_;
 42 | bad_words = ["fuck", "cock", "child", "kiddy", "porn", "pron",
 43 |              "masturbate", "shit", "piss", "anal", "cum", "wank"]
 44 | 
 45 | def req_join_link(client):
 46 |     """
 47 |     Return an OAuth URL upon request (just to have this utility)
 48 |     """
 49 |     return discord.utils.oauth_url(client.user.id)
 50 | 
 51 | 
 52 | def display_url_when_no_servers(client, logger):
 53 |     """
 54 |     Print a clickable URL when the bot sees no servers active
 55 |     This is to defeat the previous method of creating bot links
 56 |     """
 57 |     if not client.servers:
 58 |         logger("Link: {}".format(req_join_link(client)))
 59 |     return
 60 | 
 61 | 
 62 | def contains_badwords(string):
 63 |     """
 64 |     Return whether a string contains bad words
 65 |     """
 66 |     return any([x in string for x in bad_words])
 67 | 
 68 | 
 69 | def get_last_message(client, chan, uid=None):
 70 |     """
 71 |     Search through the client's messages to find the last message
 72 |     Can also add a User ID to get a specific user's messages
 73 |     """
 74 |     if len(client.messages) == 0:
 75 |         raise Exception("How are we even here?")
 76 |     if len(client.messages) == 1:
 77 |         return None
 78 |     c_uid = lambda u, v: True
 79 |     if uid is not None:
 80 |         c_uid = lambda u, v: u == v
 81 |     res = [msg for msg in client.messages
 82 |             if msg.channel == chan
 83 |             and msg.author.id != client.user.id
 84 |             and c_uid(uid, msg.author.id)]
 85 |     if len(res) <= 1:
 86 |         return None
 87 |     return res[-2]
 88 | 
 89 | 
 90 | def setup_all_events(client, bot_name, logger, on_r=None, on_e=None, on_m=None):
 91 |     """
 92 |     Setup all events using default events
 93 |     We can pass in custom events to each variable to set those as the events
 94 |     The given events have to be named appropriately (on_message, on_ready, on_error)
 95 |     """
 96 |     if on_r is None:
 97 |         client.event(setup_on_ready(client, bot_name, logger))
 98 |     elif callable(on_r):
 99 |         client.event(on_r)
100 |     if on_e is None:
101 |         client.event(setup_on_error(client, logger))
102 |     elif callable(on_e):
103 |         client.event(on_e)
104 |     if on_m is None:
105 |         client.event(setup_on_message(client, logger))
106 |     elif callable(on_m):
107 |         client.event(on_m)
108 |     return
109 | 
110 | 
111 | def setup_on_ready(client, bot_name, logger):
112 |     """
113 |     Automate the on_ready connection process
114 |     """
115 |     async def on_ready():
116 |         if not setup_bot_data(bot_name, logger):
117 |             client.close()
118 |             return logger("Failed to set up {}'s folder".format(bot_name))
119 |         display_url_when_no_servers(client, logger)
120 |         return logger("Connection status: {}".format(client.is_logged_in))
121 |     return on_ready
122 | 
123 | 
124 | def setup_on_error(client, logger):
125 |     """
126 |     Automate the on_error process (it's real simple)
127 |     """
128 |     async def on_error(msg, *args, **kwargs):
129 |         return logger("Discord error: {}".format(msg))
130 |     return on_error
131 | 
132 | 
133 | def setup_bot_data(bot_name, logger):
134 |     """
135 |     Set up the bot data folder in the root location
136 |     If it can't create the folders, return False
137 |     else return True (so our bot can continue)
138 |     """
139 |     try:
140 |         if not isdir(BOT_FOLDER):
141 |             logger("Setting up root bot folder")
142 |             mkdir(BOT_FOLDER)
143 |         if not isdir(Path(BOT_FOLDER, bot_name)):
144 |             logger("Setting up {} data folder".format(bot_name))
145 |             mkdir(Path(BOT_FOLDER, bot_name))
146 |     except Exception as ex:
147 |         logger("Fail: {}".format(ex))
148 |         return False
149 |     return True
150 | 
151 | 
152 | def register_command(func=None, binds={}):
153 |     """
154 |     We're gonna use some real bad behavior
155 |     We're going to store binds inside of the function's default arg
156 |     When the function is passed None, we return the binds
157 |     When we pass a function, we register it to the binds
158 |     Else we return the function we were originally given so
159 |     we can ensure it acts as a wrapper of the given function
160 |     """
161 |     if callable(func):
162 |         if func.__name__ not in binds:
163 |             binds["{}{}".format(bot_prefix, func.__name__)] = func
164 |             return True
165 |         return False
166 |     elif func is None:
167 |         return binds
168 |     return func
169 | 
170 | 
171 | def setup_on_message(client, logger):
172 |     """
173 |     Create a basic on_message function to use
174 |     If 'help' is fed to the function, print out a help message in pre-tags
175 |     """
176 |     async def on_message(msg):
177 |         if contains_badwords(msg.content.lower()):
178 |             return
179 |         splits = msg.content.strip().split(" ")
180 |         key = splits.pop(0).lower()
181 |         rest = " ".join(splits) if len(splits) > 0 else ""
182 |         args = [rest, msg]
183 |         binds = register_command()
184 |         if key in binds:
185 |             if rest.lower().startswith("help"):
186 |                 return await client.send_message(
187 |                     msg.channel,
188 |                     pre_text(
189 |                         "Help for '{}':{}".format(key, binds[key].__doc__)
190 |                     )
191 |                 )
192 |             return await binds[key](*args)
193 |         return
194 |     return on_message
195 | 
196 | 
197 | def read_file(path):
198 |     """
199 |     Read a file and handle the I/O exceptions
200 |     """
201 |     try:
202 |         with open(path, 'r') as f:
203 |             return f.read().strip("\n").strip("\r").replace("\n", "")
204 |     except Exception:
205 |         raise IOError("File can't be read (doesn't exist)")
206 |     return False
207 | 
208 | 
209 | def read_key(bot_name):
210 |     """
211 |     Read a key file which contains bot tokens
212 |     Return false if the key couldn't be read
213 |     """
214 |     return read_file(join(KEY_FOLDER, "{}.key".format(bot_name)))
215 | 
216 | 
217 | def pre_text(string, lang=None):
218 |     """
219 |     Encapsulate a string inside a Markdown <pre> container
220 |     """
221 |     s = "```{}```"
222 |     if lang is not None:
223 |         s = s.format(lang+"\n{}")
224 |     return s.format(string.rstrip().strip("\n").replace("\t", ""))
225 | 
226 | def url_replace(string, cmap=char_map):
227 |     """
228 |     Safely replace characters with URL friendly characters
229 |     Optional: feed in a character map to use (defaults to predefined)
230 |     """
231 |     s = string
232 |     for k, v in cmap.items():
233 |         s = s.replace(k, v)
234 |     return s
235 | 
236 | 
237 | def read_lines(file_name):
238 |     """
239 |     Read all the lines in a given file
240 |     Shortcut to avoid clumping up of many with-blocks
241 |     Handles the IO exception to return a blank list when no file is present
242 |     """
243 |     lines = []
244 |     try:
245 |         with open(file_name, "r") as f:
246 |             lines = f.readlines()
247 |     except Exception:
248 |         pass
249 |     return lines
250 | 
251 | 
252 | def write_lines(file_name, lines):
253 |     """
254 |     Inverse of read_lines(), just do the opposite
255 |     True if written, False otherwise
256 |     """
257 |     try:
258 |         with open(file_name, "w") as f:
259 |             f.writelines("\n".join([
260 |                 line.strip().replace("\n","") for line in lines
261 |                 if line.strip().replace("\n","") != ""
262 |             ]))
263 |     except Exception:
264 |         return False
265 |     return True
266 | 
267 | 
268 | def create_filegen(bot_name):
269 |     """
270 |     Create a function which allows quick path joins
271 |     to interact with files in a Bot's folder
272 |     """
273 |     def bot_file(filename=None):
274 |         if filename is None or filename == "":
275 |             return Path(BOT_FOLDER, bot_name)
276 |         return Path(BOT_FOLDER, bot_name, filename)
277 |     return bot_file
278 | 
279 | 
280 | def create_logger(bot_name):
281 |     """
282 |     Create a logger func to yield messages from bots
283 |     Color is generated by sum([ord(x) for x in name])
284 |     """
285 |     color = 16 + (hash(bot_name) % 240)
286 |     def logger(msg):
287 |         print(LOG_STR.format(bot_name, strftime("%H:%M:%S", localtime()), msg, color))
288 |         return True
289 |     return logger
290 | 
291 | 
292 | # One function to bind them all (it's a bot runner)
293 | def run_the_bot(client, bot_name, loggy):
294 |     """
295 |     Abstract to keep the bot running function in one place
296 |     Only works when each bot uses the same Client type object
297 |     """
298 |     try:
299 |         loop = asyncio.get_event_loop()
300 |         loop.run_until_complete(client.start(read_key(bot_name)))
301 |     except Exception as e:
302 |         loggy("Whoops! {}".format(e))
303 |     except SystemExit:
304 |         loggy("SystemExit, quitting")
305 |     except KeyboardInterrupt:
306 |         loggy("Keyboard Int, quitting")
307 |     finally:
308 |         loggy("Exiting")
309 |         loop.run_until_complete(client.logout())
310 |         loop.stop()
311 |         loop.close()
312 |         quit()
313 | 
314 | # end
315 | 


--------------------------------------------------------------------------------
/bots/dota-bot.py:
--------------------------------------------------------------------------------
  1 | #!/usr/bin/env python
  2 | #-*- coding: utf-8 -*-
  3 | 
  4 | """
  5 | Webhook automated Dota 2 match parsing service for Discord
  6 | 
  7 | Users can register their IDs via a chatbot and the Dota bot
  8 | will look for local JSON files in the botdata/shared folder.
  9 | JSON files are where Dota player IDs are stored, as well as
 10 | the last match they played for caching. Every loop, players
 11 | get scanned to see if they have a newer match, which will
 12 | then update the cache file with that match ID and post
 13 | an embed into the WebHooked channel.
 14 | """
 15 | 
 16 | from json import load as jload, dump as jdump
 17 | from time import sleep
 18 | from random import choice
 19 | from pathlib import Path
 20 | from Bot import WebHookBot
 21 | from requests import get, post
 22 | 
 23 | class DotaBot(WebHookBot):
 24 |     """
 25 |     Automated match-fetching bot for Discord
 26 |     Users can register through a chat bot or the
 27 |     files can be stored on the host machine
 28 |     (or perhaps, even on a website?)
 29 |     """
 30 | 
 31 |     DELAY_GAP    = 60
 32 |     OPENDOTA_API = "https://api.opendota.com/api"
 33 |     OPENDOTA_URL = "https://opendota.com/matches"
 34 |     HERO_FILE    = "heroes.json"
 35 |     HEADERS      = {
 36 |         'Content-Type': 'application/json',
 37 |         'User-Agent':   'Dota 2 scraper bot, contact steven(dot)leibrock(at)gmail(dot)com',
 38 |     }
 39 | 
 40 |     # Joke names are what you want to have heroes labeled as in the result
 41 |     JOKES1 = {
 42 |         "Io":               "Wisp",
 43 |         "Tiny":             "Tony",
 44 |         "Phoenix":          "Firequacker",
 45 |         "Leshrac":          "Shrack",
 46 |         "Monkey King":      "Donkey Kong",
 47 |         "Bristleback":      "Bristlebutt",
 48 |         "Wraith King":      "Skeleton King",
 49 |         "Faceless Void":    "Maceless Void",
 50 |         "Spirit Breaker":   "Space Cow",
 51 |     }
 52 | 
 53 |     # Instead of saying the standard footer, a joke is included at the bottom if matches
 54 |     JOKES2 = {
 55 |         "Sniper":           "Snipin's a good job mate",
 56 |         "Kunkka":           "No room to swing a cat in this crowd",
 57 |         "Undying":          "Left 4 Dead",
 58 |         "Venomancer":       "With Vim and Venom",
 59 |         "Wraith King":      "DEATH IS MY BITCH",
 60 |         "Shadow Shaman":    "MY ANCESTORS",
 61 |         "Skywrath Mage":    "From the Ghastly Eeyrie...",
 62 |         "Faceless Void":    "Now we meet, mace to face",
 63 |         "Crystal Maiden":   "Swift as the wolves of Icewrack",
 64 |         "Spirit Breaker":   "MoooooooOooOOOOOOOOOOOoooooooo",
 65 |         "Legion Commander": "FIGHT ME",
 66 |         "Nature's Prophet": "Nature's Wrath",
 67 |     }
 68 | 
 69 | 
 70 |     def __init__(self, name):
 71 |         super(DotaBot, self).__init__(name)
 72 |         self.heroes     = list()
 73 |         self.filegen    = self._create_filegen("shared")
 74 |         self.herojson   = self.filegen(self.HERO_FILE)
 75 |         self.match_url  = self._load_match_url()
 76 |         self.SLEEP_TIME = 60 * 60 # refresh every hour
 77 | 
 78 |         # Prefab the hero data via http GET or local file
 79 |         self._load_hero_data()
 80 |         self.logger(f"Heroes loaded: {len(self.heroes)}")
 81 | 
 82 | 
 83 |     def _load_match_url(self):
 84 |         "Load up a match URL from the key settings"
 85 |         url = self.keydata.get("match_url", self.OPENDOTA_URL)
 86 |         if not url.startswith("http"):
 87 |             raise IOError("Invalid key given for 'match_url': not http(s)")
 88 |         return url
 89 | 
 90 | 
 91 |     def _load_hero_data(self, force=False):
 92 |         "Prefetch the Hero JSON from OpenDota"
 93 |         if self.herojson.is_file():
 94 |             with open(self.herojson, 'r') as f:
 95 |                 self.heroes = jload(f)
 96 |                 return
 97 |         r = get(f"{self.OPENDOTA_API}/heroes")
 98 |         if r.status_code != 200:
 99 |             raise IOError("Failed to prefetch Hero JSON data from OpenDota")
100 |         with open(self.herojson, 'w') as f:
101 |             jdump(r.json(), f)
102 |         self.heroes = r.json()
103 |         return
104 | 
105 | 
106 |     def find_hero(self, hid):
107 |         "Wrapper for finding a hero in a haystack of heroes"
108 |         for hero in self.heroes:
109 |             if hero["id"] == hid:
110 |                 return hero["localized_name"]
111 |         return "Jebaited"
112 | 
113 | 
114 |     @staticmethod
115 |     def percent(a=0, b=0, d=1):
116 |         "Convert (a+b)/d to a 1.23 float"
117 |         if d == 0:
118 |             return 0
119 |         return round(((a+b)/float(d))*100.0, 2)
120 | 
121 | 
122 |     @staticmethod
123 |     def get_timestr(seconds_i):
124 |         "Create a [H:]M:S string from seconds"
125 |         minutes = seconds_i // 60
126 |         seconds = f"{seconds_i % 60}".zfill(2)
127 |         hours = ""
128 |         if minutes > 59:
129 |             hours = f"{minutes // 60}:"
130 |             minutes = f"{minutes % 60}".zfill(2)
131 |         return f"{hours}{minutes}:{seconds}"
132 | 
133 | 
134 |     def get_last_match(self, player_path):
135 |         """
136 |         Get the last match from a given file
137 |         Yield a pair of strings (Match ID * Dota ID * String) when the match
138 |         differs from the cache
139 |         If not newer, return (None * None * Error String)
140 |         """
141 |         if not player_path.is_file():
142 |             return (None, None, "Invalid Path() given for get_last_match()")
143 | 
144 |         # Read the player's profile file
145 |         with open(player_path, 'r') as f:
146 |             player_data = jload(f)
147 | 
148 |         dota_id    = player_data.get('dota_id', "")
149 |         last_match = player_data.get('last_match', 0)
150 | 
151 |         # If there's no ID at all, just stop
152 |         if not dota_id:
153 |             return (None, None, "Invalid dota ID string")
154 | 
155 |         # Request data from OpenDota API to get the last match played
156 |         # Toggle significant to zero to allow for non-important (skill-based)
157 |         resp = get(f"{self.OPENDOTA_API}/players/{dota_id}/matches?limit=1&significant=0")
158 |         if resp.status_code != 200:
159 |             return (None, None, f"Couldn't load matches for {dota_id}")
160 | 
161 |         data = resp.json()
162 |         if not data:
163 |             return (None, None, "No matches to be found (???)")
164 | 
165 |         match_id = data[0].get('match_id', 0)
166 |         if match_id == 0:
167 |             return (None, None, "Failed to find any new matches")
168 | 
169 |         if match_id != last_match:
170 |             with open(player_path, 'w') as f:
171 |                 data = {'dota_id': dota_id, 'last_match': match_id}
172 |                 jdump(data, f)
173 |                 return (match_id, dota_id, "")
174 |         return (None, None, f"No new matches for {dota_id}")
175 | 
176 | 
177 |     def get_payload(self, match_id, dota_id):
178 |         """
179 |         Craft an embed payload for the Discord endpoint
180 |         Returns either a (None * Error String) or (Dictionary * Null String)
181 |         """
182 |         resp = get(f"{self.OPENDOTA_API}/matches/{match_id}")
183 |         if resp.status_code != 200:
184 |             return (None, "Failed to get data from OpenDota API")
185 | 
186 |         jsonblob = resp.json()
187 |         data     = dict()
188 |         embs     = list()
189 | 
190 |         # Game dependent variables
191 |         players       = jsonblob["players"]
192 |         radiant_win   = jsonblob["radiant_win"]
193 |         game_mode     = jsonblob["game_mode"]
194 |         scores        = (jsonblob["radiant_score"], jsonblob["dire_score"])
195 |         duration      = self.get_timestr(jsonblob["duration"])
196 | 
197 |         # Find the player (or not, then just fail)
198 |         player = None
199 |         for p in jsonblob["players"]:
200 |             if str(p["account_id"]) == dota_id:
201 |                 player = p
202 |         if player is None:
203 |             return (None, "Failed to find the player ID in the match")
204 | 
205 |         # Player variable declarations for use later
206 |         k, a, d     = player['kills'], player['assists'], player['deaths']
207 |         team        = player["isRadiant"]
208 |         pname       = player["personaname"]
209 |         hero_name   = self.find_hero(player["hero_id"])
210 | 
211 |         # Score of game
212 |         wlt = ["Radiant", "~~Dire~~"]  # use strikethrough to show who lost
213 |         if not radiant_win:
214 |             wlt = ["~~Radiant~~", "Dire"]
215 |         embs.append({
216 |             "name"  : "Final Score",
217 |             "value" : f"{wlt[0]} **{scores[0]}** - **{scores[1]}** {wlt[1]}",
218 |             "inline": True
219 |         })
220 | 
221 |         # Player Stats field
222 |         pt = self.percent(k, a, scores[0 if team else 1])
223 |         embs.append({
224 |             "name"  : "Stats (KDA)",
225 |             "value" : f"{k}/{d}/{a} ({pt}% of team)",
226 |             "inline": True
227 |         })
228 | 
229 |         # replay sensitive data is still tagged in the JSON output
230 |         # such that trying to access a replay tag will always be None or some_value
231 |         # Use <dictproperty>.get(key, <default_value>) to request a value
232 |         # and check if the data is there (it will be None otherwise)
233 | 
234 |         # ping details
235 |         pings = player.get('pings', None)
236 |         if pings is not None:
237 |             tp = sum([p.get('pings', 0) for p in players
238 |                       if p.get("isRadiant") == team])
239 |             pingpc = self.percent(pings, 0, tp)
240 |             embs.append({
241 |                 "name"  : "Total Pings",
242 |                 "value" : f"{player.get('pings', 0)} ({pingpc}% of team)",
243 |                 "inline": True
244 |             })
245 | 
246 |         # rune details - fetch the bounty rune stuff
247 |         runes = player.get('runes', None)
248 |         if runes is not None:
249 |             total_bounties = sum([p['runes'].get('5', 0) for p in players])
250 |             bountypc = self.percent(runes.get('5', 0), 0, total_bounties)
251 |             embs.append({
252 |                 "name"  : "Bounties Collected",
253 |                 "value" : f"{runes.get('5', 0)} ({bountypc}% of game)",
254 |                 "inline": True
255 |             })
256 | 
257 |         # Fetch a random quote from the match
258 |         chat = jsonblob.get('chat', None)
259 |         if chat is not None:
260 |             user_lines = [l.get('key', '') for l in chat
261 |                           if l.get('unit', '') == pname]
262 |             if user_lines:
263 |                 embs.append({
264 |                     "name"  : "Random Quote",
265 |                     "value" : f"*{choice(user_lines)}* -{pname}",
266 |                     "inline": True
267 |                 })
268 | 
269 |         # craft the main embed
270 |         player_won  = team is radiant_win
271 |         hname       = self.JOKES1.get(hero_name, hero_name)
272 |         winstatus   = "won" if player_won else "lost"
273 |         match_color = 0x92A525 if player_won else 0xC23C2A
274 |         data["embeds"] = [{
275 |             "title"      : f"Results for Match #{match_id}",
276 |             "description": f"{pname} {winstatus} as {hname} ({duration})",
277 |             "url"        : f"{self.match_url}/{match_id}",
278 |             "color"      : match_color,
279 |             "fields"     : embs,
280 |             "footer": {
281 |                 "text": self.JOKES2.get(hero_name, "Provided by OpenDota API")
282 |             }
283 |         }]
284 |         return (data, "")
285 | 
286 | 
287 |     def post_payload(self, data):
288 |         "Send a data dict to the Discord endpoint"
289 |         if not data:
290 |             self.logger("Invalid payload, nothing sent")
291 |             return False
292 |         re = post(self.endpoint, json=data, headers=self.HEADERS)
293 |         if re.status_code != 204:
294 |             return self.logger("Failed to post match")
295 |         return re
296 | 
297 | 
298 |     def main(self):
299 |         "Main Dota 2 match loop"
300 |         files = [f for f in self.filegen().iterdir() if f"{f}".endswith("dota")]
301 |         self.logger(f"Keys: {files}")
302 |         for keypath in files:
303 |             sleep(self.DELAY_GAP)
304 |             self.logger("Fetching most recent match")
305 |             last_match, dota_id, err = self.get_last_match(keypath)
306 |             if last_match is None:
307 |                 self.logger(err)
308 |                 continue
309 | 
310 |             self.logger("Posting match")
311 |             payload, err = self.get_payload(last_match, dota_id)
312 |             if payload is None:
313 |                 self.logger(err)
314 |                 continue
315 |             self.post_payload(payload)
316 |         self.logger("Finished looping")
317 | 
318 | 
319 | if __name__ == "__main__":
320 |     DotaBot("dota-bot").run()
321 |     pass
322 | # end
323 | 


--------------------------------------------------------------------------------
/bots/Bot.py:
--------------------------------------------------------------------------------
  1 | #!/usr/bin/env python
  2 | #-*- coding: utf-8 -*-
  3 | 
  4 | from sys import exc_info
  5 | import asyncio
  6 | from time import strftime, localtime
  7 | from pathlib import Path
  8 | from time import sleep
  9 | from json import load as jload, dump as jdump
 10 | 
 11 | from discord import Client, Game
 12 | from discord.utils import oauth_url
 13 | 
 14 | """
 15 | The new and improved class-based Bot library
 16 | 
 17 | Bots are broken down into two categories: Chat and Webhook
 18 | 
 19 | Chat: a bot that receives and can send messages through guilds
 20 | Webhook: a bot that can only send messages to specified channel
 21 | 
 22 | ChatBots require an authorized Discord application token, while a
 23 | WebHookBot only requires an endpoint acquired from setting up a
 24 | Webhook on a specific Discord Guild channel. Both can be useful in
 25 | different scenarios (Webhook is better at automated tasks, while
 26 | Chat is better at replying to user requests (and also voice)).
 27 | """
 28 | 
 29 | class Bot(object):
 30 |     """
 31 |     The main Bot class for all bots to inherit from
 32 |     The Bot class holds any and most static variables to use
 33 |     across all the bots
 34 |     """
 35 | 
 36 |     BOT_FOLDER = "botdata"
 37 |     KEY_FOLDER = "keys"
 38 |     SHARED = "shared"
 39 |     LOGSTR = "[\033[38;5;{3}m{0:<12}\033[0m @ {1}] {2}"
 40 | 
 41 |     URLMAP = {" ": "%20", "'": "%27", "`": "%60", "%": "%25", "&": "%26",
 42 |               "!": "%21", "@": "%40", "#": "%23", "$": "%24", "+": "%2B",
 43 |               "*": "%2A", "^": "%5E", "(": "%28", ")": "%29", "=": "%3D",
 44 |               "[": "%5B", "]": "%5D", "{": "%7B", "}": "%7D"}
 45 |     
 46 |     BADWORDS = ('fuck', 'cock', 'shit', 'piss', 'wank', 'kiddy', 'child',
 47 |                 'porn', 'masturbate', 'bate', 'anal', 'cum')
 48 | 
 49 |     # Static methods will come first
 50 |     @staticmethod
 51 |     def replace(string="", char_map=URLMAP):
 52 |         "Replace a string with URL safe characters (' ' => '%20')"
 53 |         s = string
 54 |         for k, v in char_map.items():
 55 |             s.replace(k, v)
 56 |         return s
 57 |     
 58 |     @staticmethod
 59 |     def has_badwords(string=""):
 60 |         "Determine if a string has a bad word in it"
 61 |         if not string:
 62 |             return False
 63 |         return any((x in string for x in Bot.BADWORDS))
 64 | 
 65 |     @staticmethod
 66 |     def _make_folder(path):
 67 |         "Make a folder if it doesn't exist and isn't a file"
 68 |         if not path.is_dir() and not path.is_file():
 69 |             path.mkdir()
 70 |             return True
 71 |         return False
 72 | 
 73 |     @staticmethod
 74 |     def _create_logger(bot_name):
 75 |         """
 76 |         Create a pretty-format printer for bots to use
 77 |         Bots will use colors in the range of 16-256 based on their hash modulo
 78 |         """
 79 |         color = 16 + (hash(bot_name) % 240)
 80 |         def logger(msg):
 81 |             print(Bot.LOGSTR.format(bot_name, strftime("%H:%M:%S", localtime()), msg, color))
 82 |             return True
 83 |         return logger
 84 | 
 85 |     @staticmethod
 86 |     def _create_filegen(bot_name):
 87 |         """
 88 |         Create a function to generate file Paths for us
 89 |         If no filename was given, yield the path to the folder instead
 90 |         """
 91 |         Bot._make_folder(Path(Bot.BOT_FOLDER))
 92 |         Bot._make_folder(Path(Bot.BOT_FOLDER, bot_name))
 93 |         def bot_file(filename=None):
 94 |             if filename is None or filename == "":
 95 |                 return Path(Bot.BOT_FOLDER, bot_name)
 96 |             return Path(Bot.BOT_FOLDER, bot_name, filename)
 97 |         return bot_file
 98 | 
 99 |     @staticmethod
100 |     def _read_file(path):
101 |         "Attempt to read a file from a Path"
102 |         if not path.is_file():
103 |             raise IOError
104 |         with open(path, 'r') as f:
105 |             return f.read()
106 |         return None 
107 | 
108 |     @staticmethod
109 |     def pre_text(msg, lang=None):
110 |         "Encapsulate a string in a <pre> container"
111 |         s = "```{}```"
112 |         if lang is not None:
113 |             s = s.format(format+"\n{}")
114 |         return s.format(msg.rstrip().strip("\n").replace("\t", ""))
115 | 
116 |     # Instance methods go below __init__()
117 |     def __init__(self, name):
118 |         self.name    = name
119 |         self.logger  = self._create_logger(self.name)
120 |         self.keydata = self.load_keyfile()
121 | 
122 |     def load_keyfile(self):
123 |         "Read a keyfile dictionary and store it to the bot's locals"
124 |         with open(Path(self.KEY_FOLDER, f'{self.name}.key'), 'r') as f:
125 |             return jload(f)
126 |         return None
127 | 
128 |     def read_key(self):
129 |         "Fetch the key from the keydata local"
130 |         key = self.keydata.get("key", "")
131 |         if not key:
132 |             raise IOError("Key not found in JSON keyfile")
133 |         return key
134 | 
135 |     # end Bot class
136 | 
137 | class ChatBot(Bot):
138 |     """
139 |     The ChatBot is a wrapper for the Discord client itself
140 |     Any bots that take user input from a channel will inherit this
141 |     
142 |     In order to create a Discord Client, a bot has to have an authorized
143 |     token associated with it. The keys are read from files (no trailing newlines)
144 |     inside of a local "keys" folder. The "keys" folder is at the root of the 
145 |     project, not inside the Bot Data folder
146 |     
147 |     TODO: add a Singleton pattern to prevent creating more than one bot instance
148 |     """
149 |     PREFIX    = "!"
150 |     BLACKLIST = "blacklist"
151 | 
152 |     BANS      = dict()
153 |     ACTIONS   = dict()
154 |     HELPMSGS  = dict()
155 | 
156 |     # Bad words to prevent malicious searches from a host device
157 |     BADWORDS  = ["fuck", "cock", "child", "kiddy", "porn", "pron", "pr0n",
158 |                  "masturbate", "bate", "shit", "piss", "anal", "cum", "wank"]
159 | 
160 |     # Change this to adjust your default status setting (loads in on_ready())
161 |     STATUS    = "Beep bloop!"
162 | 
163 |     @staticmethod
164 |     def action(help_msg=""):
165 |         """
166 |         Decorator to register functions into the action map
167 |         This is bound to static as we can't use an instance object's method
168 |         as a decorator (could be a classmethod but who cares)
169 |         """
170 |         def regfunc(function):
171 |             if callable(function):
172 |                 if function.__name__ not in ChatBot.ACTIONS:
173 |                     fname = f'{ChatBot.PREFIX}{function.__name__}'
174 |                     ChatBot.ACTIONS[fname]  = function
175 |                     ChatBot.HELPMSGS[fname] = help_msg.strip()
176 |                     return True
177 |             return function
178 |         return regfunc
179 |     
180 |     @staticmethod
181 |     def get_emojis(msg_obj):
182 |         "Fetch emojis from a Message object"
183 |         if msg_obj.server is not None:
184 |             return msg_obj.server.emojis
185 |         return list()
186 | 
187 |     @staticmethod
188 |     def convert_user_tag(tag_str):
189 |         "Convert a string <@(?){0,1}[0-9]> to [0-9] (False if invalid)"
190 |         print(f"Given: {tag_str}")
191 |         if not tag_str.startswith("<@") and not tag_str.endswith(">"):
192 |             return False
193 |         inside = tag_str[(3 if tag_str.startswith("<@!") else 2):-1]
194 |         if not inside.isnumeric():
195 |             return False
196 |         return inside
197 | 
198 |     @staticmethod
199 |     def is_admin(mobj):
200 |         "Return whether user is an administrator or not"
201 |         return mobj.channel.permissions_for(mobj.author).administrator
202 | 
203 | 
204 |     # Instance methods below
205 |     def __init__(self, name):
206 |         super(ChatBot, self).__init__(name)
207 |         self.actions  = dict()
208 |         self.client   = Client()
209 |         self.token    = self.read_key()
210 | 
211 |         # load up the ban list
212 |         self._load_bans()
213 | 
214 |     async def message(self, channel, string):
215 |         """
216 |         Shorthand version of client.send_message
217 |         So that we don't have to arbitrarily type 
218 |         'self.client.send_message' all the time
219 |         """
220 |         return await self.client.send_message(channel, string)
221 | 
222 |     def _load_bans(self):
223 |         "Load the banfile and convert it to a blacklist"
224 |         p = Path(self.BLACKLIST)
225 |         if not p.is_file():
226 |             return self.logger("Local blacklist not found")
227 |         with open(p, 'r') as f:
228 |             self.BANS = jload(f)
229 |         self.logger("Initial banned users:")
230 |         for k, v in self.BANS.items():
231 |             self.logger(f"* {k}")
232 |         return
233 | 
234 |     def display_no_servers(self):
235 |         """
236 |         If the bot isn't connected to any servers, show a link
237 |         that will let you add the bot to one of your current servers
238 |         """
239 |         if not self.client.servers:
240 |             self.logger(f"Join link: {oauth_url(self.client.user.id)}")
241 |         return
242 | 
243 |     def add_ban(self, ban_target):
244 |         "Add a user to the bans and dump the dict (True=Added, False=Not)"
245 |         if ban_target in self.BANS:
246 |             return False
247 |         self.BANS[ban_target] = True
248 |         with open(Path(self.BLACKLIST), 'w') as f:
249 |             jdump(self.BANS, f)
250 |         return True
251 | 
252 |     def del_ban(self, ban_target):
253 |         "Remove a user from the bans and update the file"
254 |         if ban_target not in self.BANS:
255 |             return False
256 |         self.bans.pop(ban_target)
257 |         with open(Path(self.BLACKLIST), 'w') as f:
258 |             jdump(self.BANS, f)
259 |         return True
260 | 
261 |     def is_banned(self, userid):
262 |         "Return whether a user is banned or not"
263 |         return userid in self.BANS
264 | 
265 |     def get_last_message(self, chan, uid=None):
266 |         """
267 |         Search the given channel for the second-to-last message
268 |         aka: the message before the command was given to the bot
269 |         """
270 |         if len(self.client.messages) == 0:
271 |             raise Exception("Wat")
272 |         if len(client.messages) == 1:
273 |             return None
274 |         c_uid = lambda u, v: True
275 |         if uid is not None:
276 |             c_uid = lambda u, v: u == v
277 |         res = [msg for msg in self.client.messages
278 |                if msg.channel == chan
279 |                and msg.author.id != self.client.user.id
280 |                and c_uid(uid, msg.author.id)]
281 |         if len(res) <= 1:
282 |             return None
283 |         return res[-2]
284 | 
285 |     async def set_status(self, string):
286 |         "Set the client's presence via a Game object"
287 |         return await self.client.change_presence(game=Game(name=string))
288 | 
289 |     def event_ready(self):
290 |         "Change this event to change what happens on login"
291 |         async def on_ready():
292 |             self.display_no_servers()
293 |             await self.set_status(self.STATUS)
294 |             return self.logger(f"Bot online, {len(self.ACTIONS)} commands loaded")
295 |         return on_ready
296 | 
297 |     def event_error(self):
298 |         "Change this for better error logging if needed"
299 |         async def on_error(evt, *args, **kwargs):
300 |             self.logger(f"Discord error in '{evt}''")
301 |             return self.logger(exc_info())
302 |         return on_error
303 | 
304 |     def event_message(self):
305 |         "Change this to change overall on message behavior"
306 |         async def on_message(msg):
307 |             "Sub generator for handling messages (checks bans, words)"
308 |             contents = msg.content.strip().lower()
309 |             if self.has_badwords(contents):
310 |                 return
311 |             key, *args = contents.split(" ")
312 |             if key in self.ACTIONS:
313 |                 if self.is_banned(msg.author.id):
314 |                     self.logger("Banned user attempted command")
315 |                     if self.keydata.get("delete_banned_user_coms", False):
316 |                         return await self.client.delete_message(msg)
317 |                 return await self.ACTIONS[key](self, args, msg)
318 |             return
319 |         return on_message
320 | 
321 |     def setup_events(self):
322 |         """
323 |         Set up all events for the Bot
324 |         You can override each event_*() method in the class def
325 |         """
326 |         self.client.event(self.event_message())
327 |         self.client.event(self.event_error())
328 |         self.client.event(self.event_ready())
329 | 
330 |     def run(self):
331 |         """
332 |         Main event loop
333 |         Set up all Discord client events and then run the loop
334 |         """
335 |         self.setup_events()
336 |         try:
337 |             loop = asyncio.get_event_loop()
338 |             loop.run_until_complete(self.client.start(self.token))
339 |         except Exception as e:
340 |             self.logger(f"Caught an exception: {e}")
341 |         except SystemExit:
342 |             self.logger(f"System Exit signal")
343 |             print("System Exit signal")
344 |         except KeyboardInterrupt:
345 |             self.logger("Keyboard interrupt signal")
346 |         finally:
347 |             self.logger(f"{self.name} quitting")
348 |             loop.run_until_complete(self.client.logout())
349 |             loop.stop()
350 |             loop.close()
351 |             quit()
352 |         return
353 | 
354 | 
355 | class WebHookBot(Bot):
356 |     """
357 |     A WebHookBot is a bot that will automatically execute actions
358 |     based on a timer and will fire messages towards a Discord endpoint
359 |     These are more of "daemons" one can make to automate multitudes of tasks
360 |     
361 |     NOTE: WebHookBots can not receive user input directly from a Discord channel
362 |     Use a ChatBot to take input from a user and write it to a file a WebHookBot
363 |     can access easily (a "shared" folder), or a microservice like a database,
364 |     memcache or even a messaging queue like Rabbitmq/Zeromq
365 | 
366 |     (With some changes, WebHook bot could be made to use asyncio/uvloop)
367 |     """
368 |     SLEEP_TIME = 60
369 | 
370 |     def __init__(self, name):
371 |         super(WebHookBot, self).__init__(name)
372 |         self.endpoint = self.read_key()
373 | 
374 |     def main(self):
375 |         """
376 |         Override this in your webhook definition
377 |         The main() function must take no arguments
378 |         """
379 |         self.logger(f"I'm a WebHook bot!")
380 | 
381 |     def run(self):
382 |         """
383 |         Run the program loop
384 |         Override the main() function to change what happens in each loop cycle
385 |         """
386 |         try:
387 |             while True:
388 |                 self.main()
389 |                 sleep(self.SLEEP_TIME)
390 |             return
391 |         except Exception as e:
392 |             print(e)
393 |             self.logger(f"Exception caught: {e}")
394 |         except SystemExit:
395 |             self.logger("Sys Interrupt")
396 |         except KeyboardInterrupt:
397 |             self.logger("Keyboard Interrupt")
398 |         finally:
399 |             self.logger(f"Shutting down {self.name}")
400 |         return quit()
401 |             
402 | # end 
403 | 


--------------------------------------------------------------------------------
/junkyard/hacker-bot.py:
--------------------------------------------------------------------------------
  1 | #!/usr/bin/env python
  2 | #-*- coding: utf-8 -*-
  3 | 
  4 | """
  5 | Hacker bot
  6 | 
  7 | Designed as a way to interact with the host machine
  8 | Also comes with a Lis.py interpreter (thanks Peter Norvig)
  9 | Requires: cowsay, screenfetch, cowfortune
 10 | """
 11 | 
 12 | from botinfo import *
 13 | from bs4 import BeautifulSoup as BS
 14 | from requests import get as re_get
 15 | from random import choice, random, randint
 16 | 
 17 | # Lisp interpreter imports
 18 | import math
 19 | import operator as op
 20 | from functools import reduce
 21 | 
 22 | # setting maximum recursion limits for Lisp evaluation
 23 | from sys import setrecursionlimit
 24 | setrecursionlimit(100)
 25 | 
 26 | bot_name = "hacker-bot"
 27 | client   = discord.Client()
 28 | logger   = create_logger(bot_name)
 29 | bot_data = create_filegen(bot_name)
 30 | max_slen = 300
 31 | max_data = 100
 32 | 
 33 | ## Lisp Interpreter section 
 34 | Symbol = str          # A Lisp Symbol is implemented as a Python str
 35 | List   = list         # A Lisp List is implemented as a Python list
 36 | Number = (int, float) # A Lisp Number is implemented as a Python int or float
 37 | def tokenize(chars):
 38 |     """
 39 |     Convert a string of characters into a list of tokens
 40 |     TODO: work on joining strings together at this level
 41 |     If mismatched quotes detected, raise SyntaxError
 42 |     """
 43 |     old_tokens = chars.replace('(', ' ( ').replace(')', ' ) ').split()
 44 |     return old_tokens
 45 | 
 46 | def parse(program):
 47 |     "Read a Scheme expression from a string."
 48 |     return read_from_tokens(tokenize(program))
 49 | 
 50 | def read_from_tokens(tokens):
 51 |     """
 52 |     Read an expression from a sequence of tokens
 53 |     TODO: add support for dicts, strings and lists
 54 |     """
 55 |     if len(tokens) == 0:
 56 |         raise SyntaxError('Unexpected EOF while reading')
 57 |     token = tokens.pop(0)
 58 |     if '(' == token:
 59 |         L = []
 60 |         while tokens[0] != ')':
 61 |             L.append(read_from_tokens(tokens))
 62 |         tokens.pop(0) # pop off ')'
 63 |         return L
 64 |     elif ')' == token:
 65 |         raise SyntaxError('Unexpected )')
 66 |     else:
 67 |         return atom(token)
 68 | 
 69 | def atom(token):
 70 |     """
 71 |     Numbers become numbers; every other token is a symbol
 72 |     Order of checks: Bool, String, Int, Float, Symbol
 73 |     Strings end with ' or "
 74 |     """
 75 |     if token in ("True", "False"):
 76 |         return bool(token)
 77 |     if token == "#t": return True
 78 |     if token == "#f": return False
 79 |     if token.startswith("\"") and token.endswith("\""):
 80 |         return str(token)
 81 |     if token.startswith("'") and token.endswith("'"):
 82 |         return str(token)
 83 |     try:
 84 |         return int(token)
 85 |     except ValueError:
 86 |         try:
 87 |             return float(token)
 88 |         except ValueError:
 89 |             return Symbol(token)
 90 | 
 91 | class Procedure(object):
 92 |     "A user-defined Scheme procedure."
 93 |     def __init__(self, parms, body, env):
 94 |         self.parms, self.body, self.env = parms, body, env
 95 |     def __call__(self, *args): 
 96 |         return lispeval(self.body, Env(self.parms, args, self.env))
 97 | 
 98 | class Env(dict):
 99 |     "An environment: a dict of {'var':val} pairs, with an outer Env."
100 |     def __init__(self, parms=(), args=(), outer=None):
101 |         self.update(zip(parms, args))
102 |         self.outer = outer
103 |     def find(self, var):
104 |         "Find the innermost Env where var appears."
105 |         return self if (var in self) else self.outer.find(var)
106 | 
107 | def compose(*list_of_funcs):
108 |     """
109 |     Compose a list of functions into a singular function
110 |     """
111 |     if not isinstance(list_of_funcs, (tuple, list)):
112 |         raise SyntaxError("compose: No list given")
113 |     if not all(map(callable, list_of_funcs)):
114 |         raise SyntaxError("compose: Non-composable type given")
115 |     def whatever(in_var):
116 |         for func in list_of_funcs:
117 |             in_var = func(in_var)
118 |         return in_var
119 |     return whatever
120 | 
121 | def compareduce(f, *lst):
122 |     """
123 |     A reduce modified to work for `f :: a -> b -> Bool` functions
124 |     If `f` ever evaluates to False, return False, else return True
125 |     This is mandatory because functools.reduce doesn't store previous
126 |     values for each pair in the computation chain
127 |     """
128 |     if len(lst) <= 1:
129 |         raise SyntaxError(f"{f.__name__}: List too small for evaluation")
130 |     first_value = lst[0]
131 |     for next_value in lst[1:]:
132 |         if not f(first_value, next_value):
133 |             return False
134 |         first_value = next_value
135 |     return True
136 | 
137 | def standard_env():
138 |     """
139 |     An environment with some Scheme standard procedures
140 |     Updated for Python 3 specifics and a lot more Lispy stuff
141 |     """
142 |     env = Env()
143 |     env.update(vars(math)) # sin, cos, sqrt, pi, ...
144 |     env.update({
145 |         'append'     : op.add,  
146 |         'eq?'        : op.is_, 
147 |         'equal?'     : op.eq, 
148 |         'not'        : op.not_,
149 |         'negate'     : op.neg,
150 |         'int'        : int,
151 |         'float'      : float,
152 |         'bool'       : bool,
153 |         'ord'        : ord,
154 |         'chr'        : chr,
155 |         'bin'        : bin,
156 |         'oct'        : oct,
157 |         'hex'        : hex,
158 |         'hash'       : hash,
159 |         'abs'        : abs,
160 |         'length'     : len, 
161 |         'sum'        : sum,
162 |         'any'        : any,
163 |         'all'        : all,
164 |         'max'        : max,
165 |         'min'        : min,
166 |         'reduce'     : reduce,
167 |         'reverse'    : reversed,
168 |         'random'     : random,
169 |         'randint'    : randint,
170 |         'choice'     : choice,
171 |         'round'      : round,
172 |         'compose'    : compose,
173 |         'id'         : lambda x      : x,
174 |         'eq?'        : lambda *x     : compareduce(op.is_, x),
175 |         'equal?'     : lambda *x     : compareduce(op.eq, x),
176 |         '+'          : lambda *x     : reduce(op.add, x),
177 |         'append'     : lambda *x     : reduce(op.add, x),
178 |         '-'          : lambda *x     : reduce(op.sub, x),
179 |         '*'          : lambda *x     : reduce(op.mul, x),
180 |         '/'          : lambda *x     : reduce(op.truediv, x),
181 |         '%'          : lambda *x     : reduce(op.mod, x),
182 |         'mod'        : lambda *x     : reduce(op.mod, x),
183 |         'modulo'     : lambda *x     : reduce(op.mod, x),
184 |         '>'          : lambda *x     : all(map(f, zip(x, x[1:]))),
185 |         '>'          : lambda *x     : compareduce(op.gt, *x),
186 |         '<'          : lambda *x     : compareduce(op.lt, *x),
187 |         '>='         : lambda *x     : compareduce(op.ge, *x),
188 |         '<='         : lambda *x     : compareduce(op.le, *x),
189 |         '='          : lambda *x     : compareduce(op.eq, *x),
190 |         '>>'         : lambda x, y   : op.rshift(x, y),
191 |         '<<'         : lambda x, y   : op.lshift(x, y),
192 |         'or'         : lambda *x     : reduce(lambda x, y: x or y, x),
193 |         'and'        : lambda *x     : reduce(lambda x, y: x and y, x),
194 |         'add1'       : lambda x      : x + 1,
195 |         'sub1'       : lambda x      : x - 1,
196 |         'range'      : lambda x      : list(range(x)),
197 |         'span'       : lambda x, y   : list(range(x, y)),
198 |         'enum'       : lambda x      : list(enumerate(x)),
199 |         'zip'        : lambda x      : list(zip(x)),
200 |         '^'          : lambda x, y   : pow(x, y),
201 |         'pow'        : lambda x, y   : pow(x, y),
202 |         'apply'      : lambda f, x   : f(*x),
203 |         'begin'      : lambda *x     : x[-1],
204 |         'cons'       : lambda x, y   : [x] + y,
205 |         'car'        : lambda x      : x[0],
206 |         'cdr'        : lambda x      : x[1:],
207 |         'head'       : lambda x      : x[0],
208 |         'tail'       : lambda x      : x[1:],
209 |         'take'       : lambda x, y   : x[:y],
210 |         'drop'       : lambda x, y   : x[y:],
211 |         'takewhile'  : lambda x, y   : None,
212 |         'dropwhile'  : lambda x, y   : None,
213 |         'list'       : lambda *x     : list(x),
214 |         'tuple'      : lambda *x     : tuple(x),
215 |         'dict'       : lambda *x     : dict(x),
216 |         'set'        : lambda *x     : set(x),
217 |         'frozenset'  : lambda *x     : frozenset(x),
218 |         'map'        : lambda f, x   : list(map(f, x)),
219 |         'filter'     : lambda f, x   : list(filter(f, x)),
220 |         'ormap'      : lambda f, x   : any(map(f, x)),
221 |         'andmap'     : lambda f, x   : all(map(f, x)),
222 |         'zero?'      : lambda x      : x == 0,
223 |         'empty?'     : lambda x      : len(x) == 0,
224 |         'pair?'      : lambda x      : len(x) == 2,
225 |         'procedure?' : lambda x      : callable(x),
226 |         'number?'    : lambda x      : isinstance(x, Number),
227 |         'symbol?'    : lambda x      : isinstance(x, Symbol),
228 |         'string?'    : lambda x      : isinstance(x, str),
229 |         'bool?'      : lambda x      : isinstance(x, bool),
230 |         'odd?'       : lambda x      : bool((x % 2) == 1),
231 |         'even?'      : lambda x      : not bool((x %2) == 1),
232 |         'list?'      : lambda x      : isinstance(x, list),
233 |         'tuple?'     : lambda x      : isinstance(x, tuple),
234 |         'set?'       : lambda x      : isinstance(x, set),
235 |         'frozenset?' : lambda x      : isinstance(x, frozenset),
236 |         'dict?'      : lambda x      : isinstance(x, dict),
237 |         'contains?'  : lambda x, y   : op.contains(x, y),
238 |         'foldl'      : lambda o, i, x: reduce(o, x, i),
239 |     })
240 |     return env
241 | 
242 | global_env = standard_env()
243 | 
244 | def lispeval(x, env=global_env):
245 |     """
246 |     Evaluate an expression in an environment
247 |     """
248 |     if isinstance(x, Symbol):      # variable reference
249 |         return env.find(x)[x]
250 |     elif not isinstance(x, List):  # constant literal
251 |         return x                
252 |     elif x[0] == 'quote':          # quotation
253 |         (_, exp) = x
254 |         return exp
255 |     elif x[0] == 'if':             # conditional
256 |         (_, test, conseq, alt) = x
257 |         exp = (conseq if lispeval(test, env) else alt)
258 |         return lispeval(exp, env)
259 |     elif x[0] == 'define':         # definition
260 |         (_, var, exp) = x
261 |         env[var] = lispeval(exp, env)
262 |     elif x[0] == 'set!':           # assignment
263 |         (_, var, exp) = x
264 |         env.find(var)[var] = lispeval(exp, env)
265 |     elif x[0] == 'lambda':         # procedure
266 |         (_, parms, body) = x
267 |         return Procedure(parms, body, env)
268 |     else:                          # procedure call
269 |         proc = lispeval(x[0], env)
270 |         args = [lispeval(arg, env) for arg in x[1:]]
271 |         return proc(*args)
272 | 
273 | @register_command
274 | async def e(msg, mobj):
275 |     """
276 |     Interpret a Lisp expression using a Lisp-to-Python translator
277 |     Ex1: !e (define x (+ 20 40 pi)) 
278 |     Ex2: !e (map (lambda (x) (+ x 5)) (range 10))
279 |     """
280 |     try:
281 |         result = lispeval(parse(msg))
282 |         if len(str(result)) + len(msg) > 1900:
283 |             return await client.send_message(mobj.channel, "Output too large")
284 |         return await client.send_message(mobj.channel,
285 |                                          pre_text("{}\n => {}".format(msg, result), "lisp"))
286 |     except Exception as ex:
287 |         return await client.send_message(mobj.channel, pre_text("{}: {}".format(type(ex).__name__, ex)))
288 |     return await client.send_mesage(mobj.channel, "Failed to compute expression")
289 | 
290 | ## end lisp section
291 | 
292 | @register_command
293 | async def info(msg, mobj):
294 |     """
295 |     Return current channel/guild information
296 |     """
297 |     chan = mobj.channel
298 |     serv = mobj.guild
299 |     chan_name, serv_name = None, None
300 |     chan_id, serv_id = 0, 0
301 |     if hasattr(chan, 'name'): chan_name = chan.name
302 |     if hasattr(serv, 'name'): serv_name = serv.name
303 |     if hasattr(chan, 'id'): chan_id = chan.id
304 |     if hasattr(serv, 'id'): serv_id = serv.id
305 |     msg = [
306 |         f"Channel: {chan.name}",
307 |         f"Channel ID: {chan_id}",
308 |         f"Server: {serv.name}",
309 |         f"Server ID: {serv_id}",
310 |     ]
311 |     return await client.send_message(mobj.channel, pre_text("\n".join(msg)))
312 |             
313 | @register_command
314 | async def uptime(msg, mobj):
315 |     """
316 |     Return the uptime of the host system
317 |     """
318 |     return await client.send_message(mobj.channel, pre_text(call("uptime")))
319 | 
320 | @register_command
321 | async def free(msg, mobj):
322 |     """
323 |     Return how much memory is free
324 |     """
325 |     return await client.send_message(mobj.channel, pre_text(call("free -m")))
326 | 
327 | @register_command
328 | async def vmstat(msg, mobj):
329 |     """
330 |     Return raw memory stats from `vmstat`
331 |     """
332 |     return await client.send_message(mobj.channel, pre_text(call("vmstat")))
333 | 
334 | @register_command
335 | async def uname(msg, mobj):
336 |     """
337 |     Return `uname -a` showing system and kernel version
338 |     """
339 |     return await client.send_message(mobj.channel, pre_text(call("uname -a | cowsay")))
340 | 
341 | @register_command
342 | async def cal(msg, mobj):
343 |     """
344 |     Return the current month calendar
345 |     """
346 |     return await client.send_message(mobj.channel, pre_text(call("cal")))
347 | 
348 | @register_command
349 | async def screenfetch(msg, mobj):
350 |     """
351 |     Return a screenfetch output
352 |     Example: !screenfetch
353 |     """
354 |     return await client.send_message(mobj.channel, pre_text(call("screenfetch -N -n")))
355 | 
356 | @register_command
357 | async def sed(msg, mobj):
358 |     """
359 |     Sed the previous user's message (as opposed to just editing it)
360 |     Example: !sed s/hi/hello/g
361 |     """
362 |     if msg == "":
363 |         return
364 |     auth = mobj.author.id
365 |     chan = mobj.channel
366 |     last_m = get_last_message(client, chan, auth).content.strip().replace("\"", "'")
367 |     return await client.send_message(chan, pre_text(call("echo \"{}\" | sed -s {}".format(last_m, msg))))
368 | 
369 | # The Git section
370 | @register_command
371 | async def update(msg, mobj):
372 |     """
373 |     Execute a `git pull` to update the code
374 |     If there was a successful pull, the bot will quit and be restarted later
375 |     Example: !update
376 |     """
377 |     print(msg)
378 |     result = call("git pull")
379 |     await client.send_message(mobj.channel, pre_text(result))
380 |     if result.strip() == "Already up-to-date.":
381 |         return
382 |     logger("Restarting self")
383 |     client.close()
384 |     return quit()
385 | 
386 | @register_command
387 | async def commits(msg, mobj):
388 |     """
389 |     Execute a `git log --oneline --graph --decorate=short | head -n 5`
390 |     Example: !commits
391 |     """
392 |     return await client.send_message(
393 |         mobj.channel, pre_text(call("git log --oneline --graph --decorate=short | head -n 5")))
394 | 
395 | # The Cowsay section for cowtagging and cowsay
396 | @register_command
397 | async def cowtag(msg, mobj):
398 |     """
399 |     Find the message before this one and add it to our cow list
400 |     Example: !cowtag
401 |     """
402 |     chan = mobj.channel
403 |     cowlist = bot_data("{}.txt".format(chan.id))
404 |     last_m = get_last_message(client, chan)
405 |     if last_m is None:
406 |         return await client.send_message(chan, "Couldn't tag last message")
407 |     last_m = last_m.content.replace("\n", " ").replace("\r", " ").strip()[:max_slen]
408 |     last_m = last_m.replace("\"", "'")
409 |     lines = read_lines(cowlist)
410 |     lines.append(last_m)
411 |     if len(lines) > max_data:
412 |         lines.pop(0)
413 |     if not write_lines(cowlist, lines):
414 |         return await client.send_message(chan, "Error writing to file")
415 |     return await client.send_message(chan, "Bagged and tagged")
416 | 
417 | @register_command
418 | async def cowsay(msg, mobj):
419 |     """
420 |     Return a random cowsay message
421 |     Example: !cowsay
422 |     """
423 |     chan = mobj.channel.id
424 |     cowlist = bot_data("{}.txt".format(chan))
425 |     cowlines = read_lines(cowlist)
426 |     if not cowlines:
427 |         return await client.send_message(mobj.channel, "No cow messages here")
428 |     rand = choice(cowlines)
429 |     if rand.strip() == "":
430 |         return await client.send_message(mobj.channel, "No cow messages here")
431 |     return await client.send_message(mobj.channel, pre_text(call("echo \"{}\" | cowsay".format(rand))))
432 | 
433 | @register_command
434 | async def fortune(msg, mobj):
435 |     """
436 |     Return a `fortune | cowsay` call
437 |     Example: !fortune
438 |     """
439 |     return await client.send_message(mobj.channel, pre_text(call("fortune | cowsay")))
440 | 
441 | # search options
442 | @register_command
443 | async def hoogle(msg, mobj):
444 |     """
445 |     Send a Haskell type signature to Hoogle and return the first result
446 |     If no results, error string
447 |     Ex1: !hoogle (a -> b) -> M a -> M b
448 |     Ex2: !hoogle >>=
449 |     """
450 |     if contains_badwords(msg):
451 |         return
452 |     if msg == "":
453 |         return await client.send_message(mobj.channel, "Nothing sent")
454 |     base_url = "https://www.haskell.org/hoogle/?hoogle={}"
455 |     search = BS(re_get(base_url.format(url_replace(msg))).text, "html.parser")
456 |     answers = search.find_all("div", class_="ans")
457 |     if not answers:
458 |         return await client.send_message(mobj.channel, "Nothing was found, bud")
459 |     res = answers[0]
460 |     text = res.text
461 |     url = res.find("a", class_="a")["href"]
462 |     return await client.send_message(mobj.channel, "{}\n{}".format(text, url))
463 | 
464 | setup_all_events(client, bot_name, logger)
465 | if __name__ == "__main__":
466 |     run_the_bot(client, bot_name, logger)
467 | 


--------------------------------------------------------------------------------
/junkyard/dota-bot.py:
--------------------------------------------------------------------------------
  1 | #!/usr/bin/env python
  2 | #-*- coding: utf-8 -*-
  3 | 
  4 | """
  5 | Dota bot
  6 | 
  7 | This bot's goal is aimed at Dota-related activities
  8 | """
  9 | 
 10 | from random import choice
 11 | from botinfo import *
 12 | from bs4 import BeautifulSoup as BS
 13 | from requests import get as re_get
 14 | from json import load as jload, dump as jdump
 15 | from pathlib import Path
 16 | 
 17 | # build a static list of heroes/items here
 18 | # Instead of waiting on a net request, just write them all
 19 | # Include whether a hero is RANGED, MELEE, or MIXED
 20 | # This will determine rules for melee/ranged bonus items
 21 | HEROES = [
 22 |     {"name": "Abaddon",             "type": "melee"},
 23 |     {"name": "Alchemist",           "type": "melee"},
 24 |     {"name": "Ancient Apparition",  "type": "ranged"},
 25 |     {"name": "Anti-Mage",           "type": "melee"},
 26 |     {"name": "Arc Warden",          "type": "ranged"},
 27 |     {"name": "Axe",                 "type": "melee"},
 28 |     {"name": "Bane",                "type": "ranged"},
 29 |     {"name": "Batrider",            "type": "ranged"},
 30 |     {"name": "Beastmaster",         "type": "melee"},
 31 |     {"name": "Bloodseeker",         "type": "melee"},
 32 |     {"name": "Bounty Hunter",       "type": "melee"},
 33 |     {"name": "Brewmaster",          "type": "melee"},
 34 |     {"name": "Bristleback",         "type": "melee"},
 35 |     {"name": "Broodmother",         "type": "melee"},
 36 |     {"name": "Centaur Warrunner",   "type": "melee"},
 37 |     {"name": "Chaos Knight",        "type": "melee"},
 38 |     {"name": "Chen",                "type": "ranged"},
 39 |     {"name": "Clinkz",              "type": "ranged"},
 40 |     {"name": "Clockwerk",           "type": "melee"},
 41 |     {"name": "Crystal Maiden",      "type": "melee"},
 42 |     {"name": "Dark Seer",           "type": "melee"},
 43 |     {"name": "Dazzle",              "type": "ranged"},
 44 |     {"name": "Death Prophet",       "type": "ranged"},
 45 |     {"name": "Disruptor",           "type": "ranged"},
 46 |     {"name": "Doom",                "type": "melee"},
 47 |     {"name": "Dragon Knight",       "type": "mixed"},
 48 |     {"name": "Drow Ranger",         "type": "ranged"},
 49 |     {"name": "Earth Spirit",        "type": "melee"},
 50 |     {"name": "Earthshaker",         "type": "melee"},
 51 |     {"name": "Elder Titan",         "type": "melee"},
 52 |     {"name": "Ember Spirit",        "type": "melee"},
 53 |     {"name": "Enchantress",         "type": "ranged"},
 54 |     {"name": "Enigma",              "type": "ranged"},
 55 |     {"name": "Faceless Void",       "type": "melee"},
 56 |     {"name": "Gyrocopter",          "type": "ranged"},
 57 |     {"name": "Huskar",              "type": "ranged"},
 58 |     {"name": "Invoker",             "type": "ranged"},
 59 |     {"name": "Io",                  "type": "ranged"},
 60 |     {"name": "Jakiro",              "type": "ranged"},
 61 |     {"name": "Juggernaut",          "type": "melee"},
 62 |     {"name": "Keeper of the Light", "type": "ranged"},
 63 |     {"name": "Kunkka",              "type": "melee"},
 64 |     {"name": "Legion Commander",    "type": "melee"},
 65 |     {"name": "Leshrac",             "type": "ranged"},
 66 |     {"name": "Lich",                "type": "ranged"},
 67 |     {"name": "Lifestealer",         "type": "melee"},
 68 |     {"name": "Lina",                "type": "ranged"},
 69 |     {"name": "Lion",                "type": "ranged"},
 70 |     {"name": "Lone Druid",          "type": "mixed"},
 71 |     {"name": "Luna",                "type": "ranged"},
 72 |     {"name": "Lycan",               "type": "melee"},
 73 |     {"name": "Magnus",              "type": "melee"},
 74 |     {"name": "Medusa",              "type": "ranged"},
 75 |     {"name": "Meepo",               "type": "melee"},
 76 |     {"name": "Mirana",              "type": "ranged"},
 77 |     {"name": "Monkey King",         "type": "melee"},
 78 |     {"name": "Morphling",           "type": "ranged"},
 79 |     {"name": "Naga Siren",          "type": "melee"},
 80 |     {"name": "Nature's Prophet",    "type": "melee"},
 81 |     {"name": "Necrophos",           "type": "ranged"},
 82 |     {"name": "Nightstalker",        "type": "melee"},
 83 |     {"name": "Nyx Assassin",        "type": "melee"},
 84 |     {"name": "Ogre Magi",           "type": "melee"},
 85 |     {"name": "Omniknight",          "type": "melee"},
 86 |     {"name": "Oracle",              "type": "ranged"},
 87 |     {"name": "Outworld Devourer",   "type": "ranged"},
 88 |     {"name": "Phantom Assassin",    "type": "melee"},
 89 |     {"name": "Phantom Lancer",      "type": "melee"},
 90 |     {"name": "Phoenix",             "type": "ranged"},
 91 |     {"name": "Puck",                "type": "ranged"},
 92 |     {"name": "Pudge",               "type": "melee"},
 93 |     {"name": "Pugna",               "type": "ranged"},
 94 |     {"name": "Queen of Pain",       "type": "ranged"},
 95 |     {"name": "Razor",               "type": "ranged"},
 96 |     {"name": "Riki",                "type": "melee"},
 97 |     {"name": "Rubick",              "type": "ranged"},
 98 |     {"name": "Sand King",           "type": "melee"},
 99 |     {"name": "Shadow Demon",        "type": "ranged"},
100 |     {"name": "Shadow Fiend",        "type": "ranged"},
101 |     {"name": "Shadow Shaman",       "type": "ranged"},
102 |     {"name": "Silencer",            "type": "ranged"},
103 |     {"name": "Skywrath Mage",       "type": "ranged"},
104 |     {"name": "Slardar",             "type": "melee"},
105 |     {"name": "Slark",               "type": "melee"},
106 |     {"name": "Sniper",              "type": "ranged"},
107 |     {"name": "Spectre",             "type": "melee"},
108 |     {"name": "Spirit Breaker",      "type": "melee"},
109 |     {"name": "Storm Spirit",        "type": "ranged"},
110 |     {"name": "Sven",                "type": "melee"},
111 |     {"name": "Techies",             "type": "ranged"},
112 |     {"name": "Templar Assassin",    "type": "ranged"},
113 |     {"name": "Terrorblade",         "type": "mixed"},
114 |     {"name": "Tidehunter",          "type": "melee"},
115 |     {"name": "Timbersaw",           "type": "melee"},
116 |     {"name": "Tinker",              "type": "ranged"},
117 |     {"name": "Tiny",                "type": "melee"},
118 |     {"name": "Treant Protector",    "type": "melee"},
119 |     {"name": "Troll Warlord",       "type": "mixed"},
120 |     {"name": "Tusk",                "type": "melee"},
121 |     {"name": "Underlord",           "type": "melee"},
122 |     {"name": "Undying",             "type": "melee"},
123 |     {"name": "Ursa",                "type": "melee"},
124 |     {"name": "Vengeful Spirit",     "type": "ranged"},
125 |     {"name": "Venomancer",          "type": "ranged"},
126 |     {"name": "Viper",               "type": "ranged"},
127 |     {"name": "Visage",              "type": "ranged"},
128 |     {"name": "Warlock",             "type": "ranged"},
129 |     {"name": "Weaver",              "type": "ranged"},
130 |     {"name": "Windranger",          "type": "ranged"},
131 |     {"name": "Winter Wyvern",       "type": "ranged"},
132 |     {"name": "Wraith King",         "type": "melee"},
133 |     {"name": "Zeus",                "type": "ranged"},
134 | ]
135 | 
136 | # Boots to pick from
137 | # Guardian Greaves is ignored because that's more of a flex pickup
138 | # It won't even qualify for normal items just because of it's nature
139 | BOOTS = [
140 |     {"name": "Phase Boots", "price": 1240},
141 |     {"name": "Tranquil Boots", "price": 900},
142 |     {"name": "Power Treads", "price": 1350},
143 |     {"name": "Boots of Travel", "price": 2400},
144 |     {"name": "Arcane Boots", "price": 1300},
145 |     {"name": "Guardian Greaves", "price": 5250},
146 | ]
147 | 
148 | # Optional tie-ins for certain types of characters
149 | MELEE_ONLY = [
150 |     {"name": "Echo Saber", "price": 2650},
151 | ]
152 | 
153 | RANGED_ONLY = [
154 |     {"name": "Dragon Lance", "price": 1900},
155 | ]
156 | 
157 | # Rapier won't be included as it can lead to many game losses
158 | # Each item has an associated cost so you can measure how much
159 | # gold is required to reach your target (and possibly re-roll
160 | # if the GPM is just an impossibility for your given character)
161 | ITEMS = [
162 |     {"name": "Daedelus",                  "price": 5520},
163 |     {"name": "Abyssal Blade",             "price": 6400},
164 |     {"name": "Monkey King Bar",           "price": 5400},
165 |     {"name": "Eye of Skadi",              "price": 5675},
166 |     {"name": "Bloodthorn",                "price": 7195},
167 |     {"name": "Radiance",                  "price": 5150},
168 |     {"name": "Manta Style",               "price": 4950},
169 |     {"name": "Battlefury",                "price": 4500},
170 |     {"name": "Silver Edge",               "price": 5100},
171 |     {"name": "Helm of the Dominator",     "price": 1800},
172 |     {"name": "Mask of Madness",           "price": 1900},
173 |     {"name": "Diffusal Blade",            "price": 3150},
174 |     {"name": "Sange and Yasha",           "price": 4100},
175 |     {"name": "Mjollnir",                  "price": 5700},
176 |     {"name": "Butterfly",                 "price": 5525},
177 |     {"name": "Blink Dagger",              "price": 2250},
178 |     {"name": "Moon Shard",                "price": 4000},
179 |     {"name": "Desolator",                 "price": 3500},
180 |     {"name": "Satanic",                   "price": 5800},
181 |     {"name": "Heaven's Halberd",          "price": 3500},
182 |     {"name": "Blaemail",                  "price": 2200},
183 |     {"name": "Crimson Guard",             "price": 3550},
184 |     {"name": "Assault Cuirass",           "price": 5250},
185 |     {"name": "Black King Bar",            "price": 3975},
186 |     {"name": "Shiva's Guard",             "price": 4700},
187 |     {"name": "Lotus Orb",                 "price": 4000},
188 |     {"name": "Linken's Sphere",           "price": 4800},
189 |     {"name": "Heart of Tarrasque",        "price": 5500},
190 |     {"name": "Ethereal Blade",            "price": 4700},
191 |     {"name": "Dagon",                     "price": 2720},
192 |     {"name": "Necronomicon",              "price": 2650},
193 |     {"name": "Rod of Atos",               "price": 3100},
194 |     {"name": "Eul's Scepter of Divinity", "price": 2750},
195 |     {"name": "Veil of Discord",           "price": 2240},
196 |     {"name": "Aghanim's Scepter",         "price": 4200},
197 |     {"name": "Bloodstone",                "price": 4900},
198 |     {"name": "Refresher Orb",             "price": 5200},
199 |     {"name": "Glimmer Cape",              "price": 1850},
200 |     {"name": "Aether Lens",               "price": 2350},
201 |     {"name": "Force Staff",               "price": 2250},
202 |     {"name": "Pipe of Insight",           "price": 3100},
203 |     {"name": "Solar Crest",               "price": 2625},
204 |     {"name": "Vladmir's Offering",        "price": 2275},
205 | ]
206 | 
207 | bot_name = "dota-bot"
208 | client   = discord.Client()
209 | logger   = create_logger(bot_name)
210 | bot_data = create_filegen(bot_name)
211 | 
212 | # API endpoints go here
213 | OPENDOTA_URL = "https://opendota.com/matches"
214 | OPENDOTA_API = "https://api.opendota.com/api"
215 | 
216 | # Prefetch a list of heroes from OpenDota
217 | # Cache it to disk just to avoid making too many reqs
218 | hero_data_cached = False
219 | hero_dataf = Path(bot_data("heroes.json"))
220 | 
221 | # Check if the file exists in the system
222 | # Else load the JSON from a request
223 | if hero_dataf.is_file():
224 |     hero_data_cached = True
225 |     with open(hero_dataf, "r") as f:
226 |         hero_data = jload(f)
227 | else:
228 |     r = re_get(f"{OPENDOTA_API}/heroes")
229 |     if r.status_code != 200:
230 |         print(f"Error pre-fetching hero data (code: {r.status_code})")
231 |     hero_data_cached = False 
232 |     hero_data = r.json()
233 |     
234 | @register_command
235 | async def osfrog(msg, mobj):
236 |     """
237 |     Patch 7.02: help string was removed from Captain's Mode 
238 |     """
239 |     osfrogs = [
240 |         "Added Monkey King to the game",
241 |         "Reduced Lone Druid's respawn talent -50s to -40s",
242 |     ]
243 |     return await client.send_message(mobj.channel, choice(osfrogs))
244 | 
245 | @register_command
246 | async def challenge(msg, mobj):
247 |     """
248 |     The Challenge
249 |     Picks a random Dota 2 hero to play and gives you 3 items to work towards
250 |     Optional: supply a hero and get the 3 items to play (sd/ap/rd applicable)
251 |     Example: !challenge
252 |              -> Bloodseeker: Guardian Greaves, Abyssal Blade, Dagon 
253 |     """
254 |     msg = []
255 |     hs = msg.strip().lower().capitalize()
256 |     if hs != "":
257 |         search = [h for h in HEROES if h["name"] == hs]
258 |         if not search:
259 |             return await client.send_message(mobj.channel, "Couldn't find hero")
260 |         hero = search[0]
261 |     else:
262 |         hero = choice(HEROES)
263 |         msg.append(f"Hero: {hero['name']}")
264 | 
265 |     item_pool = ITEMS
266 |     if hero["type"] == "mixed":
267 |         item_pool.extend(MELEE_ONLY)
268 |         item_pool.extend(RANGED_ONLY)
269 |     elif hero["type"] == "melee":
270 |         item_pool.extend(MELEE_ONLY)
271 |     else:
272 |         item_pool.extend(RANGED_ONLY)
273 |     shuffle(item_pool)
274 | 
275 |     # Start filling the pool with items
276 |     boots = choice(BOOTS)
277 |     picked_items = []
278 |     while len(picked_items) < 3:
279 |         picked_items.append(item_pool.pop(0))
280 |         shuffle(item_pool)
281 | 
282 |     msg.append(f"Hero: {hero['name']}")
283 |     msg.append(f"Items: {', '.join([i['name'] for i in picked_items])}")
284 |     msg.append(f"Total cost: {sum([i['price'] for i in picked_items])}")
285 |     
286 |     return await client.send_message(mobj.channel, "\n".join(msg))
287 | 
288 | @register_command
289 | async def dota_id(msg, mobj):
290 |     """
291 |     Register's a user's Discord ID and associates it with a Dota ID
292 |     This is used to retrieve a user's last played match from OpenDota 
293 |     The string must be tested against OpenDota's API to see if it's valid
294 |     """
295 |     if len(msg) > 30:
296 |         return await client.send_message(mobj.channel, "Bro that's too long")
297 | 
298 |     r = re_get(f"{OPENDOTA_API}/players/{msg.strip()}")
299 |     if r.status_code != 200:
300 |         return await client.send_message(mobj.channel, "Invalid Dota ID")
301 | 
302 |     fname = bot_data(f"{mobj.author.id}.txt")
303 |     print(fname)
304 |     with open(fname, 'w') as f:
305 |         f.write(msg.strip())
306 | 
307 |     print("Returning")
308 |     return await client.send_message(mobj.channel, "Registered your Dota ID")
309 | 
310 | @register_command
311 | async def lastmatch(msg, mobj):
312 |     """
313 |     Fetch a user's ID from the FS and yield the last played match
314 |     from the OpenDota API
315 |     The user must first associate a Dota ID with !dota_id to use this
316 |     """
317 |     fname = bot_data(f"{mobj.author.id}.txt") 
318 |     if not fname:
319 |         return await client.send_message(mobj.channel, "Register your ID first")
320 |     dota_id = None
321 |     with open(fname, 'r') as f:
322 |         dota_id = f.read().strip("\n")
323 | 
324 |     r    = re_get(f"{OPENDOTA_API}/players/{dota_id}/matches?limit=1") 
325 |     if r.status_code != 200:
326 |         return await client.send_message(mobj.channel, "Failed to get matches")
327 |     data = r.json()
328 | 
329 |     mid  = data[0]['match_id']
330 |     mr   = re_get(f"{OPENDOTA_API}/matches/{mid}")
331 |     if mr.status_code != 200:
332 |         return await client.send_message(mobj.channel, "Error retrieving data")
333 | 
334 |     # Find the player object in the players property
335 |     mdata   = mr.json()
336 |     players = mdata["players"]
337 |     pfilter = [p for p in players if str(p["account_id"]) == dota_id]
338 |     if not pfilter:
339 |         return await client.send_message(mobj.channel, f"Couldn't find user (???)")
340 |     player  = pfilter[0]
341 |     victory = "won" if player["win"] == 1 else "lost"
342 | 
343 |     # Start grabbing details
344 |     pname        = player["personaname"]
345 |     heroid       = player["hero_id"]
346 |     k            = player["kills"]
347 |     d            = player["deaths"]
348 |     a            = player["assists"]
349 |     kda          = player["kda"] 
350 |     gpm          = player["gold_per_min"]
351 |     damage_dealt = player["hero_damage"]
352 |     team         = player["isRadiant"] # t if Rad, f if Dire
353 | 
354 |     hero_filter = [h for h in hero_data if h["id"] == heroid]
355 |     if not hero_filter:
356 |         return await client.send_message(mobj.channel, f"Can't find hero {heroid}")
357 |     hero_name = hero_filter[0]["localized_name"]
358 | 
359 |     # Grab Ping details of entire team
360 |     ppings      = player["pings"]
361 |     total_pings = sum([p["pings"] for p in players if p["isRadiant"] == team])
362 |     pingpc      = round((float(ppings) / total_pings) * 100.0, 2)
363 | 
364 |     # Grab bounty runes picked up (bounty is ID# 5)
365 |     bounties = player["runes"].get("5", 0)
366 |     all_bounties = sum([p["runes"].get("5", 0) for p in players])
367 |     bcp = round((float(bounties) / all_bounties) * 100.0, 2)
368 | 
369 |     # Grab messages sent in all chat
370 |     allchat = mdata["chat"]
371 |     allchat_msgs = sorted(
372 |         [m for m in allchat if m["unit"] == pname],
373 |         key=lambda d: len(d["key"]),
374 |         reverse=True
375 |     )
376 |     acp = round((float(len(allchat_msgs)) / len(allchat)) * 100.0, 2)
377 | 
378 |     allchat_longest = ""
379 |     if allchat_msgs:
380 |         allchat_longest = allchat_msgs[0]['key']
381 | 
382 |     # Get team's kills and calculate kill participation
383 |     ts = mdata["radiant_score"] if team else mdata["dire_score"]
384 |     kp = round(float(k+a) / ts, 2)
385 | 
386 |     # Create an embed inside of Discord
387 |     emb = Embed(
388 |         title=f"Match {mid}",
389 |         url=f"{OPENDOTA_URL}/{mid}",
390 |         description=f"{pname} {victory} as **{hero_name}**",
391 |         color=0x993925
392 |     )
393 | 
394 |     # Set the embed image in the corner
395 |     # emb.set_thumbnail(url="https://lol.com/lol.jpg")
396 | 
397 |     emb.add_field(name="Score", value=f"{k}/{d}/{a} (KDA:{kda}, GPM:{gpm})")
398 | 
399 |     if bounties:
400 |         emb.add_field(name="Bounty Runes Collected",
401 |                       value=f"{bounties} ({bcp}% of all bounties)")
402 | 
403 |     if ppings:
404 |         emb.add_field(name="Ping Stats",
405 |                       value=f"{ppings} ({pingpc}% of team)")
406 | 
407 |     if allchat_msgs:
408 |         emb.add_field(name="Allchat Stats",
409 |                       value=f"{len(allchat_msgs)} ({acp}% of allchat)")
410 |         emb.add_field(name="Longest Quote",
411 |                       value=f"*'{allchat_longest}'* -{pname}")
412 | 
413 |     emb.set_footer(text=f"Provided by OpenDota API")
414 | 
415 |     return await client.send_message(mobj.channel, embed=emb)
416 | 
417 | @register_command
418 | def last100(msg, mobj):
419 |     """
420 |     Report winrate stats in the last 100 matches
421 |     """
422 |     pass
423 | 
424 | setup_all_events(client, bot_name, logger)
425 | 
426 | # Write the bot data to cache if it isn't there
427 | # Has to be done here to await creating the bot data folder
428 | if not hero_data_cached:
429 |    with open(hero_dataf, "w") as f:
430 |        jdump(hero_data, f)
431 |  
432 | if __name__ == "__main__":
433 |     run_the_bot(client, bot_name, logger)
434 | 
435 | # end
436 | 


--------------------------------------------------------------------------------