class TestServerAccount(unittest.TestCase): def setUp(self): self.db = Database() self.db.connect() def tearDown(self): self.db.close() def test_init(self): account = Account(self.db) self.assertIsInstance(account, Account) account2 = Account(self.db, 1) self.assertIsInstance(account, Account) def test_exists(self): account = Account(self.db, 123) account.destroy() self.assertFalse(account.exists()) account.create() self.assertTrue(account.exists()) def test_destroy(self): account = Account(self.db, 123) account.create() self.assertTrue(account.exists()) account.destroy() self.assertFalse(account.exists()) def test_create(self): account = Account(self.db) self.assertFalse(account.exists()) accountId = account.create() cursor = self.db.connection.cursor() cursor.execute("SELECT id FROM bitcoin.accounts WHERE id = %s LIMIT 1", [accountId]) self.assertIsNotNone(cursor.fetchone()) def test_update(self): account = Account(self.db) accountId = account.create() self.assertTrue(account.balanceBitcoins == 0.0) account.balanceBitcoins = 543.0 account.update() account2 = Account(self.db, accountId) self.assertTrue(account2.balanceBitcoins == 543.0) def test_create_update_fetch_init(self): account = Account(self.db) self.assertIsInstance(account.create(), int) account.balanceBitcoins = 123.0 account.update() account.fetch() self.assertTrue(account.balanceBitcoins == 123.0) # create new instance and test it self.assertTrue( Account(self.db, account.accountId).balanceBitcoins == 123.0)
def main(): """Main Irads function. Sets everything up and launches our application """ # Set up CherryPy config current_dir = os.path.dirname(os.path.abspath(__file__)) # Static directories for serving up various files conf = {'/': {'tools.staticdir.root': current_dir, 'tools.sessions.on': True, 'tools.sessions.storage_type': "ram", 'tools.sessions.timeout': 3600 }, '/css': {'tools.staticdir.on': True, 'tools.staticdir.dir': 'css'}, '/docs': {'tools.staticdir.on': True, 'tools.staticdir.dir': 'docs/html'}, '/js': {'tools.staticdir.on': True, 'tools.staticdir.dir': 'js'}} # Set up IP address and port cherrypy.config.update({'server.socket_host': config.IP, 'server.socket_port': config.PORT}) # Connect to the database database = Database(connect=True) database.connect( config.DATABASE_USERNAME, config.DATABASE_PASSWORD, config.DATABASE_HOSTNAME, config.DATABASE) # Set up CherryPy mapping Mapping = Irads() Mapping.analysis = IradsAnalysis() Mapping.manager = IradsManager() Mapping.report = IradsReport() Mapping.search = IradsSearch() Mapping.upload = IradsUpload() # Start cherrypy.quickstart(Mapping, '/', config=conf)
from tabulate import tabulate from database.database import Database from models.player import Player # Open the connection to the database database = Database.connect('mlb.db') def printPlayers(): players = database.player.getPlayers() count = -1 table = [] for jugador in (players): count += 1 table.append([count, *jugador.print()]) print(tabulate(table, headers=["position", "NAME", "AGE"], tablefmt="grid"))
class MusiciansDBApp(npyscreen.NPSAppManaged): def __init__(self, *args, **keywords): super().__init__(*args, **keywords) self.database = Database('127.0.0.1', 'postgres') def onStart(self): self.database.connect('postgres', '1') self.fill_database() self.addForm("MAIN", MainList.MainListDisplay, title='Main menu') self.addForm("MUSICIANSLIST", MusiciansList.MusiciansListDisplay, title='Musicians') self.addForm("MUSICIANEDIT", MusicianEdit.MusicianEdit) self.addForm("RELEASESLIST", ReleasesList.ReleasesListDisplay) self.addForm("RELEASEEDIT", ReleaseEdit.ReleaseEdit) self.addForm("LISTENERSLIST", ListenersList.ListenersListDisplay) self.addForm("LISTENEREDIT", ListenerEdit.ListenerEdit) self.addForm("SUBSCRIBE_TO_RELEASE", SubscribeToRelease.SubscribeToRelease) self.addForm("SEARCH_STATUS", SearchStatus.SearchStatus) self.addForm("SEARCH_VIDEO", SearchVideo.SearchVideo) self.addForm("FULLTEXT_SEARCH", FulltextSearch.FulltextSearch) def onCleanExit(self): self.database.close() def fill_database(self): self.database.create_musicians_table() self.database.create_releases_table() self.database.create_listeners_table() self.database.create_listeners_releases_table() patokaband = Musician(name='Patoka', status=Status.BAND.value, members=["Skiper", "Kovalski", "Rico"]) sportband = Musician(name='Lets sport', status=Status.BAND.value, members=["Skiper", "Kovalski", "Private"]) sportsband = Musician( name='sports', status=Status.ORCHESTRA.value, members=["Skiper", "Kovalski", "Rico", "Private"]) sportsportsport = Musician( name='sport sport sport', status=Status.BAND.value, members=["sportsman1", "sportsman2", "sportsman3"]) release1 = Release(name='Release1', date=datetime.datetime(year=1999, month=1, day=7), style="Pop", is_video=True, musician_id=3) release2 = Release(name='Release2', date=datetime.datetime(year=2018, month=1, day=7), style="Garage rock", is_video=False, musician_id=1) release3 = Release(name='Release3', date=datetime.datetime(year=2018, month=1, day=7), style="Rock", is_video=False, musician_id=3) listener1 = Listener(name='Anna Siryk', services=["soundcloud", "bandcamp"]) listener2 = Listener(name='Simple Listener', services=["soundcloud", "vk"]) listener3 = Listener(name='Listener3', services=["soundcloud"]) self.database.create_new_musician(patokaband) self.database.create_new_musician(sportband) self.database.create_new_musician(sportsband) self.database.create_new_musician(sportsportsport) # self.database.generate_random_musicians(100) self.database.create_new_release(release1) self.database.create_new_release(release2) self.database.create_new_release(release3) self.database.create_new_listener(listener1) self.database.create_new_listener(listener2) self.database.create_new_listener(listener3) self.database.add_listener_release(1, 1) self.database.add_listener_release(2, 1) self.database.add_listener_release(1, 2)
class RESTServer(object): """ The rest server itself """ def __init__(self): """ Initialise servers, regexes """ english = Dictionary.get_language(Dictionary.ENGLISH) logging.basicConfig(filename=os.path.join(__here__, english.get("_server_log_")), level=logging.DEBUG) self.__database = Database(os.path.join(__here__, english.get("_server_db_"))) self.__server = responder.Responder() def __call__(self, env, start_response): """ Entry point """ database = None user = None response = responder.Response() # First' check for session cookie try: database = self.__database.connect() if "HTTP_COOKIE" in env: #args = post_parser.parse(data=env["HTTP_COOKIE"]) #if args: cookies = cookie.Cookie.restore(env["HTTP_COOKIE"]) for c in cookies: #cookie = cookie.Cookie(client_string = env["HTTP_COOKIE"]) user = database.users().find_session(c) if user: logging.debug(user) break # # Check there is a valid path # path = env["PATH_INFO"] # if path[0:len(self.__root)] != self.__root: # logging.error("Can't handle this path!") # response.set_status_code(response.BAD_REQUEST) # return path = env["PATH_INFO"][1:].split("/") # Special paths: "", "favicon.ico", "sitemap.xml", "robots.txt" special = ["favicon.ico", "sitemap.xml", "robots.txt"] if len(path) == 1 and path[0] in special: path.append(path[0]) path[0] = "static" # if not path[1]: # path[1] = "index.html" # if path[1].endswith(".html"): # response.set_body(html_format_file("protein", protein_name.upper()), "text/html") # return response try: logging.debug("Now serving " + str(path)) if len(path) == 1: if not path[0]: path[0] = "index.html" if path[0].endswith(".html"): response.set_html(path[0], user) else: module = importlib.import_module("server." + path[0]) factory = getattr(module, path[0].title()) server = factory() response = server.serve(env, path, user, database) assert response finally: pass except Exception as exc: logging.error("Exception in main: " + str(exc)) logging.error(traceback.format_exc()) logging.error("--------") finally: response.finalise(user) logging.debug(response.get_status_code()) if database: database.close() return self.__server.serve(start_response, response)
def test_connect(self): db = Database() db.connect() self.assertIsNotNone(db.connection) self.assertIsNotNone(db.connection.cursor())
def test_getSampleData(self): db = Database() db.connect() self.assertIsNotNone(db.getSampleData())
def test_close(self): db = Database() db.connect() db.close()
import yaml import json import urllib.request import time from wallet import Wallet from database.database import Database config = yaml.safe_load(open("config.yml")) db = Database() db.connect() walletBitcoin = 0.0 cash_wallet = Wallet() firstrun = True transection = 0.002 print ('Starting simulator...') def getMidPrice(): with urllib.request.urlopen('https://api.bitfinex.com/v1/pubticker/btcusd') as response: html = response.read() return float(json.loads(html)['mid']) def getSellPrice(): with urllib.request.urlopen('https://api.bitfinex.com/v1/pubticker/btcusd') as response: html = response.read() return float(json.loads(html)['last_price']) oldPrice = currentPrice = initPrice = getSellPrice()
class Bot(Client): def __init__(self): Client.__init__(self) self.utils = Utils() self.timeout = Timeout() self.send = self.utils.send self.modules = self.utils.get_modules_info() self.config = self.utils.get_config_info() self.start_time = self.utils.time_now() self.say = self.send_message return def start_bot(self): try: try: self.database = Database() self.database.connect() except Exception as e: self._quit("Database connection error!") return # TODO MAKE BEETER self.loop.run_until_complete(self.start(self.config.bot.token)) except KeyboardInterrupt: self._cleanup() finally: sys.stdout.write("Bot has been closed\n") return async def on_ready(self): self.send(1, "Logged in as: {}".format(self.user.name)) self.send(1, "Client ID: {}".format(self.user.id)) self.send(1, "Listening to the chat!") return def _quit(self, msg=""): sys.exit(msg + "\n") def _cleanup(self): try: self.loop.run_until_complete(self.logout()) self.database.close() self.database.dispose() except: pass finally: pending = asyncio.Task.all_tasks() gathered = asyncio.gather(*pending) try: gathered.cancel() self.loop.run_until_complete(gathered) gathered.exception() except: pass finally: self.loop.close() def restart_bot(self): try: self._cleanup() except: self._quit("error restarting the bot") finally: self.start_bot() async def on_member_join(self, member): server_exists = self.database.server.exists(member.server.id) if not server_exists: self.database.server.add(member.server.id) server_info = self.database.server.get(member.server.id) if server_info.welcome_channel != None: channel = self.get_channel(server_info.welcome_channel) letter = server_info.welcome_message if letter != "": await self.send_message(channel, letter.format(member.name, member.server.name) ) #{0=username} {1=servername} if server_info.welcome_private: letter = server_info.welcome_private_message if letter != "": await self.send_message(member, letter.format(member.name) ) #{0=username} return async def on_member_remove(self, member): server_info = self.database.server.get_from_server_aut_add( member.sesrver) name = self.utils.author_nickanme(member) if server_info.goodbye_channel != None: channel = self.get_channel(server_info.goodbye_channel) letter = server_info.goodbye_message if letter != "": await self.send_message( channel, letter.format(member.name, member.nick, name, member.server.name) ) #{0=username} {1=usernick} {2=nick then name}{3=servername} return async def on_member_update(self, before, after): if before.nick != after.nick: self.send(1, "Adding nick for {}".format(before.name)) self.database.nickname.add(before.id, before.nick, after.nick) if (before.game != after.game) or (before.status != after.status): try: game_before = before.game.name except: game_before = "" try: game_after = after.game.name except: game_after = "" try: game_type = after.game.type except: game_type = 0 self.send(1, "Updating game for {}".format(before.name)) self.database.status.add(after.id, game_before, game_after, game_type, str(before.status), str(after.status)) return async def on_message_delete(self, message): self.database.message.delete(message) return async def on_message_edit(self, before, after): return async def get_module(self, module_name): for module in self.modules: if module_name == module.call or module_name in module.aliases: return module async def filter_module(self, message, server_stats): if not message.content.startswith(server_stats.command_start): return content = message.content.replace(server_stats.command_start, "", 1) try: command, args = content.split(" ", 1) except: command = content args = None finally: class_name_, arguments = "", [] # Check if cd, if not -> add if await self.timeout.user_cmd_check_add(message.author.id, command): return module = await self.get_module(command) if module is None: class_name_ = "GetCommand" arguments = command else: if module.owner: if message.author.id != message.server.owner.id: return class_name_ = module.class_name if module.args.delimeter is None: if args != None: arguments.append(args) if not (len(arguments) in module.args.length): return elif module.args.delimeter is not None: if args: arguments.extend( args.split(module.args.delimeter, module.args.split)) if len(arguments) not in module.args.length: return class_ = getattr(modules, class_name_)() await class_.main(self, self.database, message, arguments) await asleep(self.database.cache.botinfo.module_timeout) await self.timeout.user_cmd_remove(message.author.id, command) async def on_message(self, message): """Doesn't really like private messages yet, actually not at all""" name = self.utils.author_nickanme(message.author) self.send(1, "{} > {}".format(name, message.content)) self.database.message.add(message) if message.channel.is_private: #TODO ADD HELP MODULE HERE return user_stats = self.database.user.get_from_msg_aut_add(message) server_stats = self.database.server.get_from_server_aut_add( message.server) bot_stats = self.database.bot.get() if message.content.startswith(server_stats.command_start): points_amount = randint(bot_stats.cmd_point_min, bot_stats.cmd_point_max) xp_amount = randint(bot_stats.cmd_xp_min, bot_stats.cmd_xp_max) else: points_amount = randint(bot_stats.msg_point_min, bot_stats.msg_point_max) xp_amount = randint(bot_stats.msg_xp_min, bot_stats.msg_xp_max) messages_active = await self.timeout.check_user_msg(message.author.id) if not messages_active: self.database.user.points_alter(message.author.id, points_amount) self.database.user.xp_alter(message.author.id, xp_amount) await self.timeout.user_msg(message.author.id) levels = self.utils.level_check(message.author.id, user_stats.xp, user_stats.level, bot_stats.level_base_xp, bot_stats.level_scaling_xp, bot_stats.level_scaling_max) if levels.set_level: self.database.user.level_alter(message.author.id, 1) if server_stats.post_level: letter = server_stats.post_level_msg if server_stats.post_level_same_channel_as_msg: await self.send_message( message.channel, letter.format(name, levels.new_level)) else: channel = self.get_channel(server_info.post_info_channel) await self.send_message( channel, letter.format(name, levels.new_level)) if message.author.id == self.user.id: return await self.filter_module(message, server_stats) return
class RESTServer(object): """ The rest server itself """ def __init__(self): """ Initialise servers, regexes """ english = Dictionary.get_language(Dictionary.ENGLISH) logging.basicConfig(filename=os.path.join(__here__, english.get("_server_log_")), level=logging.DEBUG) self.__database = Database( os.path.join(__here__, english.get("_server_db_"))) self.__server = responder.Responder() def __call__(self, env, start_response): """ Entry point """ database = None user = None response = responder.Response() # First' check for session cookie try: database = self.__database.connect() if "HTTP_COOKIE" in env: #args = post_parser.parse(data=env["HTTP_COOKIE"]) #if args: cookies = cookie.Cookie.restore(env["HTTP_COOKIE"]) for c in cookies: #cookie = cookie.Cookie(client_string = env["HTTP_COOKIE"]) user = database.users().find_session(c) if user: logging.debug(user) break # # Check there is a valid path # path = env["PATH_INFO"] # if path[0:len(self.__root)] != self.__root: # logging.error("Can't handle this path!") # response.set_status_code(response.BAD_REQUEST) # return path = env["PATH_INFO"][1:].split("/") # Special paths: "", "favicon.ico", "sitemap.xml", "robots.txt" special = ["favicon.ico", "sitemap.xml", "robots.txt"] if len(path) == 1 and path[0] in special: path.append(path[0]) path[0] = "static" # if not path[1]: # path[1] = "index.html" # if path[1].endswith(".html"): # response.set_body(html_format_file("protein", protein_name.upper()), "text/html") # return response try: logging.debug("Now serving " + str(path)) if len(path) == 1: if not path[0]: path[0] = "index.html" if path[0].endswith(".html"): response.set_html(path[0], user) else: module = importlib.import_module("server." + path[0]) factory = getattr(module, path[0].title()) server = factory() response = server.serve(env, path, user, database) assert response finally: pass except Exception as exc: logging.error("Exception in main: " + str(exc)) logging.error(traceback.format_exc()) logging.error("--------") finally: response.finalise(user) logging.debug(response.get_status_code()) if database: database.close() return self.__server.serve(start_response, response)