Merge v0.2

Author: 2Cubed

.travis.yml

@@ -0,0 +1,6 @@
+language: python
+python:
+  - "3.4"
+  - "3.5"
+
+script: nosetests

user.py renamed to beam.py

@@ -1,21 +1,28 @@
 from logging import getLogger as get_logger
-from logging import WARNING
+from logging import INFO, WARNING, FileHandler
 from requests import Session
 from json import dumps, loads
 from websockets import connect
 
 
-class User:
+class Beam:
     path = "https://beam.pro/api/v1"
 
+    message_id = 0
+
     def __init__(self, debug="WARNING", **kwargs):
-        self._init_logger(debug)
-        self.session = Session()
+        self._init_logger(debug, kwargs.get("log_to_file", False))
+        self.http_session = Session()
 
-    def _init_logger(self, level):
+    def _init_logger(self, level, log_to_file=False):
         """Initialize logger."""
 
-        self.logger = get_logger('CactusBot')
+        self.logger = get_logger("CactusBot")
+
+        if log_to_file:
+            file_handler = FileHandler("latest.log")
+            file_handler.setLevel(INFO)
+            self.logger.addHandler(file_handler)
 
         if level is True:
             level = "DEBUG"
@@ -43,40 +50,47 @@ def _init_logger(self, level):
 
         self.logger.info("Logger initialized!")
 
-    def request(self, req, url, **kwargs):
+    def _request(self, req, url, **kwargs):
         """Send HTTP request to Beam."""
-        if req.lower() in ('get', 'head', 'post', 'put', 'delete', 'options'):
+        if req.lower() in ("get", "head", "post", "put", "delete", "options"):
             if req.lower() == "get":
-                response = self.session.get(
+                response = self.http_session.get(
                     self.path + url,
                     params=kwargs.get("params")
                 )
             else:
-                response = self.session.__getattribute__(req.lower())(
+                response = self.http_session.__getattribute__(req.lower())(
                     self.path + url,
                     data=kwargs.get("data")
                 )
 
-            if 'error' in response.json().keys():
-                self.logger.warn("Error: {}".format(response.json()['error']))
-
-            return response.json()
+            try:
+                json = response.json()
+            except ValueError:
+                return None
+            else:
+                if "error" in json.keys():
+                    self.logger.warn("Error: {}".format(json["error"]))
+                return json
         else:
             self.logger.debug("Invalid request: {}".format(req))
 
     def login(self, username, password, code=''):
         """Authenticate and login with Beam."""
-        l = locals()
-        packet = {n: l[n] for n in ("username", "password", "code")}
-        return self.request("POST", "/users/login", data=packet)
+        packet = {
+            "username": username,
+            "password": password,
+            "code": code
+        }
+        return self._request("POST", "/users/login", data=packet)
 
     def get_channel(self, id, **p):
         """Get channel data by username."""
-        return self.request("GET", "/channels/{id}".format(id=id), params=p)
+        return self._request("GET", "/channels/{id}".format(id=id), params=p)
 
     def get_chat(self, id):
         """Get chat server data."""
-        return self.request("GET", "/chats/{id}".format(id=id))
+        return self._request("GET", "/chats/{id}".format(id=id))
 
     def connect(self, channel_id, bot_id):
         """Connect to a Beam chat through a websocket."""
@@ -106,21 +120,27 @@ def send_message(self, arguments, method="msg"):
         if isinstance(arguments, str):
             arguments = (arguments,)
 
-        msg_packet = {
+        message_packet = {
             "type": "method",
             "method": method,
             "arguments": arguments,
             "id": self.message_id
         }
 
-        yield from self.websocket.send(dumps(msg_packet))
+        if method == "msg":
+            self.logger.info("$[CactusBot] {message}".format(
+                message=arguments[0]))
+
+        yield from self.websocket.send(dumps(message_packet))
         self.message_id += 1
 
-        return (yield from self.websocket.recv())
+        if method in ("msg", "auth"):
+            return (yield from self.websocket.recv())
+        return True
 
     def remove_message(self, channel_id, message_id):
         """Remove a message from chat."""
-        return self.request("DELETE", "/chats/{id}/message/{message}".format(
+        return self._request("DELETE", "/chats/{id}/message/{message}".format(
             id=channel_id, message=message_id))
 
     def read_chat(self, handle=None):

cactus.py

@@ -1,16 +1,18 @@
 # CactusBot!
 
 from messages import MessageHandler
-from user import User
+from beam import Beam
 
 from os.path import exists
-from time import sleep
-from json import load
+from sys import exit
+from json import load, dump
 from shutil import copyfile
+from functools import reduce
 
 from asyncio import get_event_loop, gather, async
 
 from traceback import format_exc
+from time import sleep
 
 from models import Base, engine
 
@@ -38,7 +40,7 @@
 """
 
 
-class Cactus(MessageHandler, User):
+class Cactus(MessageHandler, Beam):
     started = False
     connected = False
     message_id = 0
@@ -48,12 +50,13 @@ def __init__(self, autorestart=True, **kwargs):
         self.debug = kwargs.get("DEBUG", False)
         self.autorestart = autorestart
         self.config_file = kwargs.get("config_file", "data/config.json")
+        self.stats_file = kwargs.get("stats_file", "data/stats.json")
         self.database = kwargs.get("database", "data/data.db")
 
-    def check_db(self):
+    def _init_database(self, database):
         """Ensure the database exists."""
 
-        if exists(self.database):
+        if exists(database):
             self.logger.info("Found database.")
         else:
             self.logger.info("Database wasn't found.")
@@ -67,22 +70,54 @@ def load_config(self, filename):
         """Load configuration."""
 
         if exists(filename):
-            self.logger.info("Config file was found. Loading...")
+            self.logger.info("Configuration file was found. Loading...")
+            self.config_file = filename
             with open(filename) as config:
                 self.config = load(config)
-                return True
+                return self.config
         else:
-            self.logger.warn("Config file was not found. Creating...")
+            self.logger.warn("Configuration file was not found. Creating...")
             copyfile("data/config-template.json", filename)
             self.logger.error(
-                "Config created. Please enter information, and restart.")
-            raise FileNotFoundError("Config not found.")
+                "Configuration file created. Please enter values and restart.")
+            raise FileNotFoundError("Configuration not found.")
+            exit()
+
+    def load_stats(self, filename):
+        if exists(filename):
+            self.stats_file = filename
+            self.logger.info("Statistics file was found. Loading...")
+            with open(filename) as stats:
+                self.stats = load(stats)
+                return self.stats
+        else:
+            self.logger.warn("Statistics file was not found. Creating...")
+            copyfile("data/stats-template.json", "data/stats.json")
+            self.logger.info("Statistics file created.")
+
+    def update_config(self, keys, value):
+        with open(self.config_file, 'r') as config:
+            config_data = load(config)
+            reduce(lambda d, k: d[k], keys.split('.')[:-1], config_data)[
+                keys.split('.')[-1]] = value
+        with open(self.config_file, 'w+') as config:
+            dump(config_data, config, indent=4, sort_keys=True)
+        self.config = config_data
+
+    def update_stats(self, keys, value):
+        with open(self.stats_file, 'r') as stats:
+            stats_data = load(stats)
+            reduce(lambda d, k: d[k], keys.split('.')[:-1], stats_data)[
+                keys.split('.')[-1]] = value
+        with open(self.config_file, 'w+') as config:
+            dump(stats_data, config, indent=4, sort_keys=True)
+        self.config = stats_data
 
     def run(self, *args, **kwargs):
         """Run bot."""
 
         self.logger.info(cactus_art)
-        self.check_db()
+        self._init_database(self.database)
 
         while self.autorestart or not self.started:
             try:
@@ -91,11 +126,11 @@ def run(self, *args, **kwargs):
                 loop = get_event_loop()
 
                 self.connected = bool(loop.run_until_complete(
-                    self.connect(self.channel_data['id'], self.bot_data['id'])
+                    self.connect(self.channel_data["id"], self.bot_data["id"])
                 ))
 
                 self.logger.info("{}uccessfully connected to chat {}.".format(
-                    ['Uns', 'S'][self.connected], self.channel_data["token"]
+                    ["Uns", "S"][self.connected], self.channel_data["token"]
                 ))
 
                 if self.connected:
@@ -137,8 +172,8 @@ def _run(self, *args, **kwargs):
         """Bot execution code."""
 
         if self.load_config(filename=self.config_file):
-            auth = {n: self.config[n] for n in ("username", "password")}
-            self.bot_data = self.login(**auth)
+            self.load_stats(filename=self.stats_file)
+            self.bot_data = self.login(**self.config["auth"])
             self.username = self.bot_data["username"]
             self.bot_id = self.bot_data["id"]
             self.logger.info("Authenticated as: {}.".format(self.username))
@@ -153,7 +188,9 @@ def _run(self, *args, **kwargs):
             status=["offline", "online"][self.channel_data["online"]]
         ))
 
+        self._init_commands()
+
 
 if __name__ == "__main__":
-    cactus = Cactus(debug="info", autorestart=False)
+    cactus = Cactus(debug="debug", autorestart=False, log_to_file=True)
     cactus.run()

data/config-template.json

@@ -1,11 +1,23 @@
 {
-  "username": "USERNAME",
-  "password": "PASSWORD",
-  "channel": "CHANNELNAME",
-  "points_name": "Thorns",
-  "points_per_interval": 5,
-  "points_enabled": true,
-  "interval": 1,
-  "announce_enter": false,
-  "announce_leave": false
+  "channel": "CHANNEL",
+  "auth": {
+    "username": "USERNAME",
+    "password": "PASSWORD"
+  },
+  "spam_protection": {
+    "maximum_message_length": 256,
+    "maximum_message_capitals": 32,
+    "maximum_message_emotes": 8,
+    "allow_links": false
+  },
+  "announcements": {
+    "announce_enter": false,
+    "announce_leave": false
+  },
+  "points": {
+    "name": "coin",
+    "per_interval": 5,
+    "interval": 1,
+    "enabled": true
+  }
 }