def __init__(self): """ Constructor """ DatabaseClient.__init__(self) self.conn = None self.lock = threading.Lock()
def main(): start = time.time() print("Starttime: %s" % str(datetime.datetime.now())) dbClient = DatabaseClient() # for some reason we have to do this once (maybe to establish connection but dunno) dbClient.getLatestTweetId('audi_etron', 1, 1) # maybe wait for connection? time.sleep(1) # 40 tweets every 3 seconds = 12.000 tweets per 15 minutes populateTweetsInDatabase( 'audi_etron', 'audi etron OR audi e-tron OR audi e tron', 30, 30, dbClient) populateTweetsInDatabase('audi', 'audi', 30, 30, dbClient) populateTweetsInDatabase( 'google_stadia', 'google stadia OR stadia', 30, 30, dbClient) populateTweetsInDatabase('google', 'google', 30, 30, dbClient) populateTweetsInDatabase( 'volkswagen', 'vw OR volkswagen', 30, 30, dbClient) populateTweetsInDatabase( 'volkswagen_id3', 'vw id.3 OR volkswagen id.3 OR vw id3 OR volkswagen id3 OR volkswagen id 3', 30, 30, dbClient) populateTweetsInDatabase( 'mercedes', 'mercedes OR mercedes-benz', 30, 30, dbClient) populateTweetsInDatabase( 'mercedes_eqc', 'mercedes eqc OR mercedes-benz eqc OR benz eqc', 30, 30, dbClient) print('Script took ' + str(time.time() - start) + ' seconds to execute.') print("Endtime: %s" % str(datetime.datetime.now()))
def __init__(self): """ Constructor """ DatabaseClient.__init__(self) self.context = zmq.Context() self.conn = self.context.socket(zmq.PUB) self.lock = threading.Lock()
def __init__(self, logger): """ Constructor """ DatabaseClient.__init__(self) self.conn = None self.cursor = None self.lock = threading.Lock() self.logger = logger
def __init__(self, dir=os.getcwd()): """ Constructor """ DatabaseClient.__init__(self) self.lock = threading.Lock() self.file_mapping = dict() if dir is None or dir == '': raise Exception("FileClient does not accept empty directory.") self.file_directory = dir
def __init__(self, app, client="", token=""): super(GUI, self).__init__() self.messages_to_play = [] self.database_client = DatabaseClient() self.local_socket_client = LocalClient(self.database_client) self.socket_client = None if token: if client == 'Streamlabs': self.socket_client = StreamlabsClient(self.database_client, token) if client == 'StreamElements': self.socket_client = StreamElementsClient( self.database_client, token) self.app = app self.setupUi(self) self.setWindowTitle("bart3s tts") self.setFixedWidth(600) self.setFixedHeight(600) self.logs = [] self.logs2 = [] self.max_log_lines = 100 self.max_log2_lines = 100 self.connected = False self.current_audio_length = 0 self.files = [] self.ClientSkipAudio.clicked.connect(self.skip_wav) self.ClientStopBtn.setDisabled(True) self.ClientSkipAudio.setDisabled(True) self.ClientRemoveAudio.clicked.connect(self.delete_first_message) self.ClientRemoveAudio.setEnabled(True) self.log_window.ensureCursorVisible() self.log_window2.ensureCursorVisible() self.volumeSlider.valueChanged.connect(self.change_volume) pygame.mixer.quit() pygame.mixer.init(frequency=22050, size=-16, channels=1) self.channel = pygame.mixer.Channel(0) self.generated_audio_path = "generated_audio/" if not os.path.exists(self.generated_audio_path): os.makedirs(self.generated_audio_path) self.ClientStartBtn.clicked.connect(self.start) self.ClientStopBtn.clicked.connect(self.stop) self.threadpool = QThreadPool() self.threadpool.setMaxThreadCount(3) print("Multithreading with maximum {} threads".format( self.threadpool.maxThreadCount())) self.signals = GUISignals() self.tts_engine = TextToSpeechEngine(self.generated_audio_path)
class Application: def __init__(self): self.keywords = ["numpy", "scikit", "tensorflow", "pytorch", "matlab"] self.github_fetcher = GithubFetcher(self.keywords) self.paper_fetcher = PaperFetcher() self.db = DatabaseClient() def get_paper_stats(self): # Returns the (paper, conference, libraries) tuple of the most recently # processed data. Not guranteed to be fresh. rows = self.db.get_all_papers_stats() formatted_result = [] for row in rows: column_names = ['paper_title', 'conference_name'] + self.keywords zipped = zip(column_names, row) formatted_result.append(zipped) return formatted_result def get_conference_stats(self): # Returns the (conference, library_count) tuple for each conference. # Not guranteed to be fresh. rows = self.db.get_all_conference_stats() formatted_result = [] for row in rows: column_names = ['conference_name'] + self.keywords zipped = zip(column_names, row) formatted_result.append(zipped) return formatted_result def start(self, response): if response == "0": # Run the offline pipeline. self.paper_fetcher.start() self.github_fetcher.start() self.aggregator.start() elif response == "1": results = self.get_paper_stats() for result in results: print "=================================" print result elif response == "2": results = self.get_conference_stats() for result in results: print "=================================" print result else: print "Not a valid response"
def __init__(self, api_socket, db_client=DatabaseClient()): """ Constructor :param exchange_name: Exchange name :param exchange_api: Exchange API :param db_client: Database client """ self.db_client = db_client self.api_socket = api_socket
def get_cloud_data(keyword): for i in range(0, 5): try: dbClient = DatabaseClient() tweets = list(dbClient.getAllDocuments(keyword)) print( "Currently there are %s tweets stored in the database collection '%s'." % (str(len(tweets)), keyword)) max_id = max(list(map(lambda tweet: int(tweet['id_str']), tweets))) print("Id of latest fetched tweet is %s." % str(max_id)) with open(keyword + '_data.json', 'w+') as f: # f.write(json.dumps(tweets, default=json_util.default, indent=4)) json.dump(tweets, f, default=json_util.default, indent=4) return tweets except: print("A Database Error... Wait 10sec an try again") time.sleep(10)
def main(): main = 'volkswagen' extension = 'volkswagen_id3' dbClient = DatabaseClient() termFrequencyMain = calculateTermFrequency(dbClient, main) termFrequencyMain.pop(main, None) fDist = FreqDist(termFrequencyMain) fDist.plot(35) termFrequencyExtension = calculateTermFrequency(dbClient, extension) # pretty output termFrequencyExtension.pop(main, None) termFrequencyExtension.pop('id3', None) fDist = FreqDist(termFrequencyExtension) fDist.plot(35) meanDifference = calculateMeanFractionalDifference(termFrequencyMain, termFrequencyExtension) print('Mean difference in frequency as measure for product fit: ' + str(meanDifference))
from database_client import DatabaseClient from datetime import datetime, timedelta import matplotlib.dates import matplotlib.pyplot as plt import json dbClient = DatabaseClient() def calculateVisibilityForToday(): # get fraction for the live timeframe (3 days currently) threeDaysAgo = datetime.now() - timedelta(days=3) tweetsMainLast3daysCount = len(list(filter(lambda tweet: datetime.strptime( tweet['created_at'], '%a %b %d %H:%M:%S +0000 %Y') >= threeDaysAgo, dbClient.getAllDocuments("mercedes")))) tweetsExtensionLast3daysCount = len(list(filter(lambda tweet: datetime.strptime( tweet['created_at'], '%a %b %d %H:%M:%S +0000 %Y') >= threeDaysAgo, dbClient.getAllDocuments("mercedes_eqc")))) fraction = tweetsExtensionLast3daysCount / tweetsMainLast3daysCount print("visibility of extension is: " + str(fraction)) def calculateGraphOverTime(main, extension, fit): # get all tweets for main brand and extension twoWeeksAgo = datetime.now() - timedelta(days=14) # only take tweets from last 14 days tweetsMainLastTwoWeeks = list(filter(lambda tweet: datetime.strptime( tweet['created_at'], '%a %b %d %H:%M:%S +0000 %Y') > twoWeeksAgo, dbClient.getAllDocuments(main)))
def parseAthlete(url): try: client = DatabaseClient() client.connect("localhost", 27017) page = urllib2.urlopen(url) soup = BeautifulSoup(page.read(), "lxml") div = soup.findAll("div", {"class": "L8"}) athlete_id = url.replace( "http://www.athletic.net/TrackAndField/Athlete.aspx?AID=", "") name = soup.find("h2", {"class": "mTop10"}) school = soup.find("h1", {"class": "mTop10"}) name = name.contents[1] school = school.a.contents[0] athlete = Athlete(athlete_id, name) for i in div: season = i.h4.span.contents[0] season_obj = Season(str(school), season) print(season) panel = i.findAll("div", {"class": "panel-body"}) for j in panel: h5 = j.findAll('h5') table = j.findAll("tbody") for y in range(0, len(table)): event = h5[y].contents[0] print(event) db_item = DBItem(str(event)) tr = table[y].findAll("tr") for l in tr: td = l.findAll("td") for x in range(len(td)): if td[x].find('a') != None: string = td[x].find('a').contents[0] if "<i" not in str(string): print(string) if x == 1: db_item.add_time(str(string)) elif x == 2: db_item.add_day(str(string)) elif x == 3: db_item.add_meet(str(string)) elif td[x].find('i') != None: string = td[x].find('i').contents[0] print(string) if x == 1: db_item.add_time(str(string)) elif x == 2: db_item.add_day(str(string)) elif x == 3: db_item.add_meet(str(string)) else: string = td[x].contents[0] print(string) if x == 1: db_item.add_time(str(string)) elif x == 2: db_item.add_day(str(string)) elif x == 3: db_item.add_meet(str(string)) season_obj.add_event(db_item) athlete.add_season(season_obj) strn = json.dumps(athlete, default=jdefault) client.insert(json.loads(strn)) except: print("error")
def __init__(self, db=DatabaseClient()): self.db = db
from database_client import DatabaseClient db_client = DatabaseClient() msgs = db_client.get_all_generated_messages() for i, m in enumerate(msgs): print(m.get('text'))
from flask import jsonify from pprint import pprint from random import choice import json import random from database_client import DatabaseClient, get_current_epoch_datetime from bson.objectid import ObjectId import pymongo # These remain constant throughout every game TILE_UNKNOWN = 0 TILE_HIT = 1 TILE_MISS = 2 app = Flask(__name__) db = DatabaseClient() def get_auth_error_json(): """Return the authention error (JSON format)""" return jsonify({ "status": "error", "error-id": 5, "description": "Invalid auth key." }) def get_other_player(current_player, player_list): """Return the name of the opponent of the given player, given the current player and the list of both players""" return player_list[1] if current_player == player_list[0] else player_list[ 0]
import base64 from fastapi import FastAPI, HTTPException, Request, Response from fastapi.middleware.cors import CORSMiddleware from fastapi.responses import Response, FileResponse, StreamingResponse import pandas as pd import cv2 from database_client import DatabaseClient from models.cluster_labels import ClusterLabels # Create web app and database connection app = FastAPI() db_client = DatabaseClient( user="******", database="db", host=os.environ.get("DB_HOST", "localhost"), password=os.environ["DB_PASSWORD"], ) signal.signal(signal.SIGINT, db_client.close) signal.signal(signal.SIGTERM, db_client.close) app.add_middleware( CORSMiddleware, allow_origins=["*"], allow_credentials=True, allow_methods=["*"], allow_headers=["*"], ) # Username to use if no name was given by http basic auth DEFAULT_USER = "******"
#!/usr/bin/env python # coding=UTF-8 import time import os from poloniex import Poloniex from database_client import DatabaseClient from bottle import route, run, template from trade_bot import TradeBot poloniex = Poloniex() bot = TradeBot() db = DatabaseClient(bot) @route('/clear/<currency>') def clear(currency): return bot.clear(currency) @route('/force_buy/<currency>') def update(currency): return bot.force(currency, 'Buy') @route('/force_sell/<currency>') def update(currency): return bot.force(currency, 'Sell') @route('/update.json')
def __init__(self): self.keywords = ["numpy", "scikit", "tensorflow", "pytorch", "matlab"] self.github_fetcher = GithubFetcher(self.keywords) self.paper_fetcher = PaperFetcher() self.db = DatabaseClient()
class GUI(QMainWindow, Ui_MainWindow): def __init__(self, app, client="", token=""): super(GUI, self).__init__() self.messages_to_play = [] self.database_client = DatabaseClient() self.local_socket_client = LocalClient(self.database_client) self.socket_client = None if token: if client == 'Streamlabs': self.socket_client = StreamlabsClient(self.database_client, token) if client == 'StreamElements': self.socket_client = StreamElementsClient( self.database_client, token) self.app = app self.setupUi(self) self.setWindowTitle("bart3s tts") self.setFixedWidth(600) self.setFixedHeight(600) self.logs = [] self.logs2 = [] self.max_log_lines = 100 self.max_log2_lines = 100 self.connected = False self.current_audio_length = 0 self.files = [] self.ClientSkipAudio.clicked.connect(self.skip_wav) self.ClientStopBtn.setDisabled(True) self.ClientSkipAudio.setDisabled(True) self.ClientRemoveAudio.clicked.connect(self.delete_first_message) self.ClientRemoveAudio.setEnabled(True) self.log_window.ensureCursorVisible() self.log_window2.ensureCursorVisible() self.volumeSlider.valueChanged.connect(self.change_volume) pygame.mixer.quit() pygame.mixer.init(frequency=22050, size=-16, channels=1) self.channel = pygame.mixer.Channel(0) self.generated_audio_path = "generated_audio/" if not os.path.exists(self.generated_audio_path): os.makedirs(self.generated_audio_path) self.ClientStartBtn.clicked.connect(self.start) self.ClientStopBtn.clicked.connect(self.stop) self.threadpool = QThreadPool() self.threadpool.setMaxThreadCount(3) print("Multithreading with maximum {} threads".format( self.threadpool.maxThreadCount())) self.signals = GUISignals() self.tts_engine = TextToSpeechEngine(self.generated_audio_path) @pyqtSlot(str) def draw_text(self, text): obj = text[0:4] msg = text[5:] if obj == "Log1": if len(self.logs2) > self.max_log2_lines: self.logs2.pop(0) self.logs2.append(msg) log_text = "\n".join(self.logs2) self.log_window.setPlainText(log_text) self.log_window.verticalScrollBar().setValue( self.log_window.verticalScrollBar().maximum()) if obj == "Log2": self.log_window2.setPlainText(msg) if obj == "Sta1": self.statusbar.setText(msg) @pyqtSlot(int) def print_elapsed(self, val): pass def thread_complete(self): pass def print_output(self, s): pass def closeEvent(self, event): global _running if _running: event.ignore() else: self.local_socket_client.disconnect() if self.socket_client: self.socket_client.disconnect() event.accept() def start(self): global _running _mutex1.lock() _running = True _mutex1.unlock() self.connected = True worker = Worker(self.execute_this_fn, self.channel) worker.signals.result.connect(self.print_output) worker.signals.finished.connect(self.thread_complete) worker.signals.textready.connect(self.draw_text) self.threadpool.start(worker) worker2 = Worker(self.play_audio_fn, self.channel) worker2.signals.result.connect(self.print_output) worker2.signals.finished.connect(self.thread_complete) worker2.signals.textready.connect(self.draw_text) self.threadpool.start(worker2) def stop(self): global _running _mutex1.lock() _running = False _mutex1.unlock() self.skip_wav() def execute_this_fn(self, channel, progress_callback, elapsed_callback, text_ready): self.ClientStartBtn.setDisabled(True) self.ClientStopBtn.setEnabled(True) self.ClientSkipAudio.setEnabled(True) text_ready.emit("Log1:TTS engine started!") while True: _mutex1.lock() if _running == False: _mutex1.unlock() break else: _mutex1.unlock() while self.database_client.is_messages_collection_not_empty( ) and self.connected: message = self.database_client.get_first_message_in_queue() text_ready.emit("Log2:{} donated!\nID: {}\n{}".format( message.name, message.messageId, message.text)) try: start_time = time.time() generated_audio = self.tts_engine.generate_audio(message) if generated_audio: text_ready.emit( "Sta1:Generating message: {} took: {} seconds.". format(message.messageId, str(round((time.time() - start_time), 2)))) generated_audio.messageId = message.messageId self.messages_to_play.append(generated_audio) self.database_client.add_generated_message(message) else: text_ready.emit( "Sta1:Message: {}\nwas automatically skipped!". format(message.messageId)) self.database_client.delete_message(message.messageId) except: self.connected = False text_ready.emit("Log1:\nCan't connect to TTS server!") self.stop() text_ready.emit("Log2:") time.sleep(0.5) self.ClientStartBtn.setEnabled(True) self.ClientStopBtn.setDisabled(True) self.ClientSkipAudio.setDisabled(True) text_ready.emit("Log1:TTS engine stopped!") return "Return value of execute_this_fn" def play_audio_fn(self, channel, progress_callback, elapsed_callback, text_ready): while True: _mutex1.lock() if _running == False: _mutex1.unlock() break else: _mutex1.unlock() while self.messages_to_play: if not channel.get_busy() and self.current_audio_length == 0: time.sleep(1) generated_audio = self.messages_to_play.pop(0) name = generated_audio.message.name text = generated_audio.message.text messageId = generated_audio.message.messageId files = generated_audio.files text_ready.emit( "Log1:------------------------------------------------------------------------------------\n" ) text_ready.emit("Log1:{} donated!".format(name)) text_ready.emit("Log1:ID: {}".format(messageId)) text_ready.emit("Log1:{}".format(text)) self.current_audio_length = generated_audio.length self.files = files while self.current_audio_length > 0: if not channel.get_busy() and len(self.files) > 0: self.playback_wav(self.files.pop(0)) time.sleep(0.5) return "Return value of play_audio_fn" def playback_wav(self, file): voice = file.voice wav = file.text if voice == "satan:": pygame.mixer.quit() pygame.mixer.init(frequency=11000, size=-16, channels=1) self.channel = pygame.mixer.Channel(0) else: pygame.mixer.quit() pygame.mixer.init(frequency=22050, size=-16, channels=1) self.channel = pygame.mixer.Channel(0) sound = pygame.mixer.Sound(wav) if voice == "keanu:": self.channel.set_volume(self.volumeSlider.value() / 100) else: self.channel.set_volume((self.volumeSlider.value() / 100) * 0.9) self.channel.queue(sound) self.current_audio_length -= 1 self.ClientSkipAudio.setEnabled(True) def skip_wav(self): if self.channel.get_busy(): self.files = [] self.channel.stop() self.channel = pygame.mixer.Channel(0) self.current_audio_length = 0 def delete_first_message(self): if self.database_client.is_messages_collection_not_empty(): message = self.database_client.get_first_message_in_queue() self.database_client.delete_message(message.messageId) def change_volume(self): value = self.volumeSlider.value()
def __init__(self, keywords, db = DatabaseClient()): self.g = GithubSearchClient("a77d4b49fac3f43fa1d1df585ea62aa6fc17401c") self.keywords = keywords self.db = db