Fix all pylint errors and follow PEP Guidelines for naming

Author: aahnik

Scripts/Bots/runPython_bot/bot/config.py

@@ -1,9 +1,15 @@
+'''
+Configs for the bot
+'''
+
 # expressions which are banned
 banned = ['quit', 'input', 'open', 'import', 'exit']
 
 # timeout in seconds
-timeout = 6
+TIMEOUT = 6
 
-timeout_message = f'😢 Timeout of {timeout} reached. I have limited resources. \nYou may increase the timeout and run this bot on your own server if required.'
+timeout_message = f'''😢 Timeout of {TIMEOUT} reached.
+I have limited resources. 
+You may increase the timeout and run this bot on your own server if required.'''
 
 restricted_message = f'☹️ SECURITY ISSUE:\nYou have used a restricted word \n{banned}'

Scripts/Bots/runPython_bot/bot/execute_code.py

@@ -4,8 +4,8 @@
 import logging
 from subprocess import TimeoutExpired
 import subprocess
-from .config import banned, timeout, timeout_message, restricted_message
 import multiprocessing
+from .config import banned, TIMEOUT, timeout_message, restricted_message
 
 
 def contains_restricted(input_text):
@@ -18,35 +18,42 @@ def contains_restricted(input_text):
 
 def run(update) -> str:
     '''
-    This function takes an Telegram `update` object, passed by the `reply` function in runPython_bot module, and returns the result after executing update.message.text.
+    This function takes an Telegram `update` object,
+    passed by the `reply` function in the runPython_bot module,
+    and returns the result after executing update.message.text.
     '''
 
     def execute_py(code):
         '''
-        This function takes a string of python code and executes it in a subprocess of timeout 30s, and returns the standard out and standard error.
+        This function takes a string of python code
+        and executes code in a subprocess of timeout 30s,
+        Returns the standard out and standard error.
 
-        Learn more about subprocesses from the official docs of Python 
+        Learn more about subprocesses from the official docs of Python
         https://docs.python.org/3/library/subprocess.html
 
-        For a shorter intro read this stack overflow answer 
+        For a shorter intro read this stack overflow answer
         https://stackoverflow.com/questions/64606880/how-to-get-the-python-interactive-shell-output-of-a-python-code-in-a-variable
         '''
 
         proc = subprocess.Popen(['/usr/bin/python3.8', '-c', code],
-                                stdin=subprocess.PIPE, stdout=subprocess.PIPE, stderr=subprocess.PIPE)
+                                stdin=subprocess.PIPE,
+                                stdout=subprocess.PIPE,
+                                stderr=subprocess.PIPE)
         try:
-            stdout, stderr = proc.communicate(timeout=timeout)
+            stdout, stderr = proc.communicate(timeout=TIMEOUT)
             return stdout.decode('utf-8'), stderr.decode('utf-8')
         except TimeoutExpired:
             return '', timeout_message
-        except Exception as e:
-            return '', f'Problem occured \n{e}'
+        except Exception as error:
+            return '', f'Problem occured \n{error}'
         finally:
             proc.kill()
 
     def func(input_text: str):
         '''
-        This function is a helper function which does some validation job before passing the code to execute_py.
+        This function is a helper function which does some validation job before passing
+        the code to execute_py.
         '''
 
         if contains_restricted(input_text):
@@ -62,11 +69,10 @@ def func(input_text: str):
 
             out = func(input_text)
             return out
-        else:
-            return 'update.message.text was None'
-    except Exception as e:
+        return 'update.message.text was None'
+    except Exception as error:
         msg = 'Error in handling update.message.text'
-        logging.log(level=40, msg=msg)
+        logging.log(level=40, msg=error)
         return msg
 
 
@@ -80,24 +86,25 @@ def evaluate(input_text, return_val):
         '''wrapper for eval'''
         try:
             return_val[input_text] = str(eval(input_text))
-        except Exception as e:
+        except Exception as error:
             return_val[
-                input_text] = f'''😔 /e feeds your expression to python's eval function, and the following error occured: \n\n{e}'''
+                input_text] = f'''😔 /e feeds your expression to python's eval function.
+                The following error occured: \n\n{error}'''
 
     if contains_restricted(input_text):
         return restricted_message
 
     # using multiprocessing and getting value returned by target function
-    m = multiprocessing.Manager()
-    return_val = m.dict()  # enable target function to return a value
-
-    p = multiprocessing.Process(target=evaluate, args=(input_text, return_val))
-    p.start()
-    p.join(6)  # allow the process to run for 6 seconds
-    if p.is_alive():
+    manger = multiprocessing.Manager()
+    return_val = manger.dict()  # enable target function to return a value
+
+    process = multiprocessing.Process(
+        target=evaluate, args=(input_text, return_val))
+    process.start()
+    process.join(6)  # allow the process to run for 6 seconds
+    if process.is_alive():
         # kill the process if it is still alive
-        p.kill()
+        process.kill()
         return timeout_message
-    else:
-        output = return_val[input_text]
-        return output
+    output = return_val[input_text]
+    return output

Scripts/Bots/runPython_bot/bot/run_python_bot.py

@@ -0,0 +1,128 @@
+'''
+This module makes the bot actually run
+'''
+
+from telegram.ext import CommandHandler, MessageHandler, Filters, Updater
+# python-telegram-bot is a Pythonic Wrapper to the core Telegram API
+# it helps us to be DRY by giving us convinient wrapper functions to deal with Telegram API
+# you can install it by pip install python-telegram-bot --upgrade
+# learn more about it here https://github.com/python-telegram-bot/python-telegram-bot
+
+
+from .execute_code import eval_py, run
+
+# read the token for authenticating our bot
+with open('token.txt') as f:
+    tok = f.readline().strip()
+
+with open('docs/start.txt') as f:
+    start_text = f.read()
+
+with open('docs/help.txt') as f:
+    help_text = f.read()
+
+with open('docs/code.txt') as f:
+    code_text = f.read()
+
+
+def handle_long_message(msg):
+    '''Telegram does not support messages over 4096 characters.
+    This handler handles all messages above 2000 characters
+    '''
+
+    if msg:
+        if len(msg) > 2000:
+            return msg[:2000]+'\n\n 😟 Output was too long, truncated to 2000 characters'
+        return msg
+    return 'handle_long_message recieved an empty message'
+
+
+def bot():
+    '''
+    Running this function runs the bot
+    You may learn more from this tutorial
+    https://github.com/python-telegram-bot/python-telegram-bot/wiki/Extensions-%E2%80%93-Your-first-Bot
+    '''
+
+    updater = Updater(token=tok)
+
+    dispatcher = updater.dispatcher
+
+    def start(update, context):
+        '''This fuction replies to the start command'''
+
+        context.bot.send_message(
+            chat_id=update.effective_chat.id, text=start_text, parse_mode='Markdown')
+        # for more info on parse modes
+        # see https://python-telegram-bot.readthedocs.io/en/stable/telegram.parsemode.html
+
+    def bot_help(update, context):
+        '''This function replies to the help command'''
+        context.bot.send_message(
+            chat_id=update.effective_chat.id, text=help_text, parse_mode='Markdown')
+
+    def code_info(update, context):
+        '''This function replies to the code command.'''
+        context.bot.send_message(
+            chat_id=update.effective_chat.id, text=code_text, parse_mode='Markdown')
+
+    def reply_execute(update, context):
+        '''
+        This function replies to any non-command messages.
+        '''
+        input_text = str(update.message.text)
+        # allowing usage of /e at the end of expressions
+
+        if input_text == 'hi':
+            user = update.message.from_user
+            context.bot.send_message(chat_id=update.effective_chat.id,
+                                     text=f'Hi! {user["username"]} 🥰')
+
+        if input_text.endswith('/e'):
+            message = handle_long_message(eval_py(input_text.strip('/e')))
+            update.message.reply_text(message, quote=True)
+        else:
+            returned_val = run(update)
+            if not returned_val:
+                update.message.reply_text(
+                    '''*No output. No error.*
+                    \n> Try using a `print` statement.
+                    \n > To evaluate an expression use the /e command.''',
+                    quote=True, parse_mode='Markdown')
+            else:
+                message = handle_long_message(returned_val)
+                update.message.reply_text(message, quote=True)
+
+    def reply_eval(update, context):
+        ''' This function handles the /e command'''
+        if context.args:
+            input_text = ''
+            for string in context.args:
+                input_text += string + ' '
+            out = eval_py(input_text)
+            message = handle_long_message(out)
+            update.message.reply_text(message, quote=True)
+        else:
+            update.message.reply_text(
+                '''*No expression provided to eval*.
+                \nUse command /e before or after your expression like
+                \n/e `4 >= 5` \n \t or \n`4 >= 5` /e ''', quote=True, parse_mode='Markdown')
+
+    _handlers = {}
+
+    _handlers['start_handler'] = CommandHandler('start', start)
+    _handlers['help_handler'] = CommandHandler('help', bot_help)
+    _handlers['code_info_handler'] = CommandHandler('code', code_info)
+    _handlers['message_handler'] = MessageHandler(
+        Filters.text & (~Filters.command), reply_execute)
+    _handlers['eval_handler'] = CommandHandler('e', reply_eval)
+
+    for name, _handler in _handlers.items():
+        print(f'Adding {name}')
+        dispatcher.add_handler(_handler)
+
+    updater.start_polling()
+    updater.idle()
+    # Search google to know what is polling...
+    # i came to know while building this project
+    # this can be stopped by interrupting the terminal by `Ctrl+C`

Scripts/Bots/runPython_bot/docs/images/run-py-bot.png

@@ -1,4 +1,4 @@
-from bot import runPython_bot
+from bot import run_python_bot
 import logging
 from pytz import timezone
 from datetime import datetime
@@ -14,4 +14,4 @@
 logger = logging.getLogger()
 logger.setLevel(20)
 
-runPython_bot.bot()
+run_python_bot.bot()