def saveDayBar(): for inst in TickController.inst_current_tick.keys(): tick = TickController.inst_current_tick[inst] print(tick) DatabaseController.insert_DayBar(tick) #update all indicators!!! inst_thread[inst].InitIndicator()
def archive(): db = DatabaseController() q = request.args.get('q') search = False if q: search = True page = request.args.get(get_page_parameter(), type=int, default=1) all_archived_members = db.get_row(DatabaseTables.CLAN, 'aktivan', 0, return_all=True) pagination = Pagination(page=page, per_page=ARCHIVED_MEMBERS_PER_PAGE, total=len(all_archived_members), search=search, record_name='members', css_framework='foundation') start_page = (page - 1) * ARCHIVED_MEMBERS_PER_PAGE end_page = (page - 1) * ARCHIVED_MEMBERS_PER_PAGE + ARCHIVED_MEMBERS_PER_PAGE members_list = {} for i, member in enumerate(sorted(all_archived_members, key=lambda x: x[10])): if start_page <= i < end_page: members_list[member[0]] = (member[Utilities.UserDBIndex.IME], member[Utilities.UserDBIndex.PREZIME], member[Utilities.UserDBIndex.NADIMAK], member[Utilities.UserDBIndex.DATUM_UCLANJENJA], member[Utilities.UserDBIndex.BROJ_ISKAZNICE], member[Utilities.UserDBIndex.EMAIL], db.get_member_primary_section(member[0]), member[Utilities.UserDBIndex.DATUM_DEAKTIVACIJE]) elif i >= end_page: break return render_template('/members/archive.html', members_list=members_list, pagination=pagination)
def member_already_joined(member_id, section_name): db = DatabaseController() possible_sections = [x for x in db.get_all_members_sections(member_id)] for section in possible_sections: if section == section_name: return True return False
def get_member_info(member_id): db = DatabaseController() member = db.get_table_row(DatabaseTables.CLAN, int(member_id)) member_info = (member[1], member[2], member[3]) date_joined = member[7] section = member[10] return member_info, date_joined, section
def add_activity_type(): db = DatabaseController() if request.method == 'POST': name = request.form['name'] description = request.form['description'] try: section = request.form['section'] except HTTPException: section = session["section"] error = None if not name: error = 'Username is required.' if not description: description = '-' if error is None: entry_values = (name, description, section) db.add_activity_type_entry(entry_values) flash("Tip aktivnosti %s je uspješno dodan!" % name, 'success') return redirect(url_for('index')) flash(error, 'danger') return render_template('/activities/add_type.html')
def activate(member_id=None): if request.method == 'POST': db = DatabaseController() db.activate_member(member_id) flash('Član je uspješno aktiviran', 'success') return "1"
def login(): if request.method == 'POST': username = request.form['username'] password = request.form['password'] db = DatabaseController() error = None user = db.get_row(DatabaseTables.KORISNICKI_RACUNI, 'username', username) if user is None: error = 'Incorrect username or password.' elif not check_password_hash(user[2], password): # user[2] - password error = 'Incorrect username or password.' if error is None: session.clear() session["user_id"] = user[0] # user[0] - id session["username"] = user[1] # user[1] - username session["access_level"] = int(user[3]) # user[3] - access level session["section"] = user[4] # user[4] - sekcija return redirect(url_for('index')) flash(error) return render_template('index.html')
def list_activity_types(): db = DatabaseController() q = request.args.get('q') search = False if q: search = True page = request.args.get(get_page_parameter(), type=int, default=1) if session['access_level'] == AccessLevels.ADMIN: activities = db.get_all_rows_from_table(DatabaseTables.TIP_AKTIVNOSTI) else: activities = db.get_all_section_activitiy_types() pagination = Pagination(page=page, per_page=ACTIVITY_TYPES_PER_PAGE, total=len(activities), search=search, record_name='members', css_framework='foundation') activities_list = {} start_page = (page - 1) * ACTIVITY_TYPES_PER_PAGE end_page = (page - 1) * ACTIVITY_TYPES_PER_PAGE + ACTIVITY_TYPES_PER_PAGE for i, activity in enumerate(sorted(activities, key=lambda x: x[1])): if start_page <= i < end_page: activities_list[activity[0]] = activity[1:] elif i >= end_page: break return render_template("/activities/list_types.html", list_records=activities_list, pagination=pagination)
def get_member_activities(member_id, activity_types, start_date=None, end_date=None): db = DatabaseController() member_activities = db.get_all_activities_for_member(member_id, start_date, end_date) member_hours_by_activity_type = {} member_hours_by_activity_type_weighted = {} member_attendance = {} for activity in member_activities: if activity[0] not in member_hours_by_activity_type: member_hours_by_activity_type[activity[0]] = activity[2] else: member_hours_by_activity_type[activity[0]] += activity[2] if activity[0] not in member_hours_by_activity_type_weighted: member_hours_by_activity_type_weighted[activity[0]] = activity[2] * activity[3] else: member_hours_by_activity_type_weighted[activity[0]] += (activity[2] * activity[3]) if activity[0] not in member_attendance: member_attendance[activity[0]] = 1 else: member_attendance[activity[0]] += 1 # Dodaj 0 sati na tipove na koje član nije došao for _type in activity_types: if _type not in member_hours_by_activity_type: member_hours_by_activity_type[_type] = 0 if _type not in member_hours_by_activity_type_weighted: member_hours_by_activity_type_weighted[_type] = 0 if _type not in member_attendance: member_attendance[_type] = 0 return member_hours_by_activity_type, member_hours_by_activity_type_weighted, member_attendance
def list_activities(): db = DatabaseController() q = request.args.get('q') search = False if q: search = True page = request.args.get(get_page_parameter(), type=int, default=1) activities = db.get_full_activity_info() pagination = Pagination(page=page, per_page=ACTIVITIES_PER_PAGE, total=len(activities), search=search, record_name='members', css_framework='foundation') activities_list = {} start_page = (page - 1) * ACTIVITIES_PER_PAGE end_page = (page - 1) * ACTIVITIES_PER_PAGE + ACTIVITIES_PER_PAGE for i, activity in enumerate( sorted(activities, reverse=True, key=lambda x: x[3])): if start_page <= i < end_page: activities_list[activity[0]] = activity[1:] elif i >= end_page: break return render_template("/activities/list.html", list_records=activities_list, pagination=pagination)
def _get_activity_types(section): db = DatabaseController() all_types = db.get_all_rows_from_table(DatabaseTables.TIP_AKTIVNOSTI) activity_types = {} for _type in sorted(all_types, key=lambda x: x[1]): if _type[3] == 'svi' or _type[3] == section: activity_types[_type[0]] = _type[1] return activity_types
class DatabaseBuilder2: def __init__(self): self.db = DatabaseController('../res/mysql_data.cfg') self.cin = Cinematerial() def run(self): netflix_code = constants.services['netflix'] for genre in constants.genre_codes: code = constants.genre_codes[genre] filename = 'netflix_{}.txt'.format(genre) self.build('movie_lists/{}'.format(filename), netflix_code + code) def get_poster(self, film_name, imdb_id): self.cin.get_poster(film_name, imdb_id); def build_top_100(self): imdb = MyMDb() film_count = 10100000 for f in listdir('C:/Users/David/Desktop/imdb_top_100/'): film_id = film_count imdb_id = f.split('.')[0] info = imdb.get_film_info_ii(imdb_id) self.db.insert_film('imdb_top_100', film_id, info) film_count = film_count + 1 def build(self, input_file, start_film_id): imdb = MyMDb() films = {} film_count = 0 try: movie_list = open(input_file, 'r', encoding='utf-8') except: print('ERROR: Could not open file: ', input_file) sys.exit() with movie_list: print('Reading From: ', input_file) for movie in movie_list: if movie in films: print('Skipping {} - Already in Database'.format(movie)) else: films[movie] = True film_id = start_film_id + film_count info = imdb.get_film_info(movie) print(film_id) film_count = film_count + 1 self.insert_film(film_id, info) self.get_poster(movie, info.imdb_id) def insert_film(self, film_id, film_info): try: self.db.insert_film('netflix', film_id, film_info) except: print('ERROR: Failed to insert: ', film_info.name)
def sendOrder(self, order): global mutex mutex.acquire() Strategy.traderSpi.ReqOrderInsert(order, Strategy.traderSpi.inc_request_id()) DatabaseController.insert_SendOrder(order.to_dict()) # dict will change bytes to str print ('sendOrder = ' + order.to_dict()['InstrumentID'] + ' dir = ' + order.to_dict()['Direction'] + ' price = '+ str(order.to_dict()['LimitPrice']) + ' strategy = ' + self.__module__) time.sleep(1) mutex.release()
def sendOrder(self, order): global mutex mutex.acquire() Strategy.traderSpi.ReqOrderInsert(order, Strategy.traderSpi.inc_request_id()) DatabaseController.insert_SendOrder(order) print 'sendOrder = ' + order.InstrumentID + ' dir = ' + order.Direction + ' strategy = ' + self.__module__ time.sleep(1) mutex.release()
def __Login_Event__(self, event): self.__saveLoginConfig() self.__DBController = DatabaseController() self.__DBController.setConnectArgue( self.__IPInputString.GetLineText(0), self.__PortInputString.GetLineText(0), self.__UserInputString.GetLineText(0), self.__PasswordInputString.GetLineText(0)) if self.__DBController.open() == True: self.Show(False) else: fail = wx.MessageDialog(self, self.__DBController.getErrorMessage(), "登录失败", wx.ICON_ERROR) fail.ShowModal()
def erase_member(member_id): if request.method == 'POST': db = DatabaseController() if not db.entry_exists(DatabaseTables.CLAN, member_id): error = 'Neuspješno brisanje. Zapis ne postoji u bazi.' flash(error, 'danger') else: db.remove_entry(DatabaseTables.CLAN, member_id) flash('Član uspješno izbrisan', 'success') return "1"
def remove_activity_type(activity_type_id): if request.method == 'POST': db = DatabaseController() if not db.entry_exists(DatabaseTables.TIP_AKTIVNOSTI, activity_type_id): error = 'Neuspješno brisanje. Zapis ne postoji u bazi.' flash(error, 'danger') else: db.remove_entry(DatabaseTables.TIP_AKTIVNOSTI, activity_type_id) flash('Tip aktivnosti uspješno izbrisana', 'success') return "1"
class IDumpParser(object): __metaclass__ = ABCMeta def __init__(self): self.dump_id = '' self.dump_url = '' self.dbAccess = DatabaseController() def parse(self, url, withSaving=True): self.dump_url = url if withSaving: self.saveDump() return self.extractInfosFromDump(withSaving) def extractInfosFromDump(self,withSaving): rawDump = self.getRawDump() regexExprs = [r"\b[A-Za-z0-9._%+-]+@[A-Za-z0-9.-]+\.[A-Za-z]{2,6}\b", r"\n[A-Za-z0-9._%+-]+@[A-Za-z0-9.-]+\.[A-Za-z]{2,6}\n"] aggregatedMatches = [] for expr in regexExprs: p = re.compile(expr) matches = p.findall(repr(rawDump)) aggregatedMatches.extend(matches) if withSaving: self.saveMails(aggregatedMatches) return aggregatedMatches @abstractmethod def getRawDump(self): pass def saveMails(self, mails): for mail in mails: self.saveMail(mail) def saveMail(self, mail): dumpItem = {'mail': mail, 'dump_id': self.dump_id} self.dbAccess.insertDumpItem(dumpItem) def saveDump(self): self.dump_id = self.dbAccess.insertDump(self.dump_url) def getDumpUrl(self): return self.dump_url
def get_max_possible_activities(activity_types, section, start_date, end_date=None): db = DatabaseController() activities_after_member_joined = db.get_all_activities_after_date(section, start_date, end_date) activity_types_count = {} for activity in activities_after_member_joined: if activity[0] not in activity_types_count: activity_types_count[activity[0]] = 1 else: activity_types_count[activity[0]] += 1 for _type in activity_types: if _type not in activity_types_count: activity_types_count[_type] = 0 return activity_types_count
class DumpFinder(object): def __init__(self, url): self.url = url self.dbAccess = DatabaseController() def checkIfAlreadyProcessed(self,url): return self.dbAccess.dumpExists(url) def getOldDumpsUrls(self): return self.dbAccess.getDumpsUrls() @abstractmethod def getNewDumpsUrls(self): raise NotImplementedError()
def list_activity_members(activity_id): db = DatabaseController() activity_members = db.get_activity_members(activity_id) activity_name = db.get_table_row(DatabaseTables.AKTIVNOST, int(activity_id))[1] activity_date = get_croatian_date_format( db.get_table_row(DatabaseTables.AKTIVNOST, int(activity_id))[3]) members_list = {} for member in sorted(activity_members, reverse=True, key=lambda x: x[3]): members_list[member[0]] = member[1:] return render_template("/activities/list_activity_members.html", members_list=members_list, activity_name=activity_name, activity_date=activity_date, activity_id=activity_id)
def run(self): Strategy.strategy_state[self.tick['InstrumentID']] = True daybar_list = Indicators.getDayBarList(self.tick['InstrumentID']) if not daybar_list: print ('Need one bar at least in database') threading.Thread.__init__(self) Strategy.strategy_state[self.tick['InstrumentID']] = False return last_daybar = daybar_list[-1] #open, high, low, close, volume last_high = last_daybar[1] last_low = last_daybar[2] b_sendorder, s_sendorder = DatabaseController.getSendOrderCount(self.tick['InstrumentID']) if self.tick['LastPrice'] > last_high : # close short and open long if s_sendorder > 0 : self.PrepareOrder(self.tick['InstrumentID'], D_Buy, OF_Close, s_sendorder, self.tick['UpperLimitPrice']) # LastPrice elif b_sendorder < self.volume : self.PrepareOrder(self.tick['InstrumentID'], D_Buy, OF_Open, self.volume-b_sendorder, self.tick['UpperLimitPrice']) if self.tick['LastPrice'] < last_low : # close long and open short if b_sendorder > 0: self.PrepareOrder(self.tick['InstrumentID'], D_Sell, OF_Close, s_sendorder, self.tick['LowerLimitPrice']) # LastPrice elif s_sendorder < self.volume : self.PrepareOrder(self.tick['InstrumentID'], D_Sell, OF_Open, self.volume-s_sendorder, self.tick['LowerLimitPrice']) # in case restart/reuse thread since python not support threading.Thread.__init__(self) Strategy.strategy_state[self.tick['InstrumentID']] = False
def load_logged_in_user(): user_id = session.get('user_id') if user_id is None: g.user = None else: g.user = DatabaseController().get_row(DatabaseTables.KORISNICKI_RACUNI, 'id', user_id)
def edit_activity_member_hours(activity_id): db = DatabaseController() if session['access_level'] == AccessLevels.ADMIN: all_members = db.get_activity_members(activity_id) else: all_members = db.get_activity_members(activity_id, section_specific=True) members_list = {} for member in all_members: members_list[member[0]] = member[1:] activity_name = db.get_table_row(DatabaseTables.AKTIVNOST, int(activity_id))[1] activity_date = get_croatian_date_format( db.get_table_row(DatabaseTables.AKTIVNOST, int(activity_id))[3]) if request.method == 'POST': changed = False for member_id, member_data in members_list.items(): member_name, member_last_name, member_hours, member_factor = member_data hours_worked = request.form["hoursworked%s" % member_id] factor = request.form["factor%s" % member_id] if not hours_worked or float(hours_worked) == 0: db.remove_member_activity_entry(activity_id, member_id) changed = True elif float(hours_worked) != member_hours or float( factor) != member_factor: entry_values = (float(hours_worked), float(factor), member_id, activity_id) db.edit_member_activity_entry(entry_values) changed = True else: pass if changed: flash("Sati volontiranja uspješno izmjenjeni", 'success') else: flash("Sati volontiranja su ostali isti", "info") return redirect(url_for('index')) return render_template('/activities/edit_member_hours.html', members_list=members_list, activity_name=activity_name, activity_date=activity_date, activity_id=activity_id)
def answer_operation_response(intent, session): card_title = "Choose number" speech_output = "" reprompt_text = "Oops. That is an invalid number. Please, choose a number from one to ten." should_end_session = False print(session) session_attributes = session['attributes'] response = int(intent['slots']['number']['value']) #The number entered by the user is a result of an operation if response == session_attributes['expected_result']: session_attributes['grade'] += 1 session_attributes['iterations'] -= 1 if session_attributes['iterations'] == 0: #If the number of questions are over, finish it grade = session_attributes['grade'] username = session_attributes['user']['name'] userId = session['user']['userId'] '''Update the user's general score in the database''' databaseController = DatabaseController() databaseController.update_score(userId, username, grade) '''Get the new user's score''' new_score = int(session_attributes['user']['total_score'] + grade) speech_output = """I hope you enjoyed playing with me, {}. Your grade was {} of 10! Your general score is {}. Say play again to start over or exit to quit.""".format( username, grade, new_score) should_end_session = False return build_response( session_attributes, build_speechlet_response(card_title, speech_output, reprompt_text, should_end_session)) expected_result, speech_output = get_random_operation(session_attributes) session_attributes['expected_result'] = int(expected_result) return build_response( session_attributes, build_speechlet_response(card_title, speech_output, reprompt_text, should_end_session))
def get_interval_member_activity(start_date=None, end_date=None, section=None): db = DatabaseController() if section is None: section = session['section'] if start_date is None: start_date = datetime.date.today().replace(day=1) if end_date is None: end_date = start_date + relativedelta(months=+1, days=-1) members_activity = db.get_period_activity(start_date=start_date, end_date=end_date) total_activity = {} total_activity_weight = {} for member in members_activity: key = member[0] # Prikaži člana ako je član tvoje sekcije ili ako si admin test = db.get_all_members_sections(key) if section in test or session['access_level'] == AccessLevels.ADMIN: if key not in total_activity: total_activity[key] = 0 total_activity_weight[key] = 0 total_activity[key] += member[3] # Beztežinski sati total_activity_weight[key] += (member[3] * member[4]) # Množi sate sa faktorom if session['access_level'] == AccessLevels.ADMIN: members = db.get_all_rows_from_table(DatabaseTables.CLAN) else: members = db.get_all_members() members_list = {} for member in members: if db.is_member_active(member[0]): key = member[0] if key not in total_activity: member_hours = 0 member_hours_w = 0 else: member_hours = total_activity[key] member_hours_w = total_activity_weight[key] members_list[member[0]] = member[1:4] + (member_hours, member_hours_w) + (db.get_member_primary_section(member[0]),) if session["access_level"] >= AccessLevels.SAVJETNIK: sorted_list = sorted(members_list.items(), reverse=True, key=lambda x: (x[1][3], x[1][4])) # Sati -> Težinski -> Prezime else: # Sekcija -> Sati -> Težinski sorted_list = sorted(members_list.items(), reverse=True, key=lambda x: (x[1][-1], x[1][3], x[1][4])) sorted_members = {} for k, v in sorted_list: section_tmp = Utilities.sections[v[-1]] if section_tmp not in sorted_members: sorted_members[section_tmp] = {} sorted_members[section_tmp][k] = v[:-1] return sorted_members
def section_stats(): db = DatabaseController() if request.method == 'POST': if request.form['start_date'] == '': start = datetime.date.today() + relativedelta(months=-1) start_year, start_month, start_day = start.year, start.month, start.day else: start_year, start_month, start_day = [int(x) for x in request.form['start_date'].split('-')] if request.form['end_date'] == '': current_date = datetime.date.today() end_year = current_date.year end_month = current_date.month end_day = current_date.day else: end_year, end_month, end_day = [int(x) for x in request.form['end_date'].split('-')] else: current_date = datetime.date.today() end_year = current_date.year end_month = current_date.month end_day = current_date.day start = datetime.date(end_year, end_month, end_day) + relativedelta(months=-1) start_year, start_month, start_day = start.year, start.month, start.day start_date = datetime.date(start_year, start_month, start_day) end_date = datetime.date(end_year, end_month, end_day) start_monthd = start_date.strftime("%m") # monthd - formatiran mjesec kao dvoznamenkasti broj (zbog defult inputa) end_monthd = end_date.strftime("%m") section_event_count = {} for section in Utilities.sections: section_events = db.get_all_volunteering_events(section, start_date, end_date) section_event_count[section] = len(section_events) months = (start_month, end_month) monthds = (start_monthd, end_monthd) years = (start_year, end_year) days = (start_day, end_day) return render_template('/statistics/section_stats.html', days=days, months=months, monthds=monthds, sections=Utilities.sections, years=years, section_count=section_event_count)
def index(): db = DatabaseController() start_date = datetime.datetime.today().replace(day=1).date() end_date = datetime.datetime.today().replace(month=datetime.datetime.today().month % 12 + 1, day=1).date() members_activity = db.get_period_activity(start_date, end_date) total_activity = {} member_names = {} for member in members_activity: key = member[0] if key not in total_activity: total_activity[key] = 0 total_activity[key] += member[3] # Beztežinski sati member_names[key] = "%s %s" % (member[1], member[2]) sorted_list = sorted(total_activity.items(), reverse=True, key=lambda x: x[1]) sorted_activity = {} for k, v in sorted_list: sorted_activity[k] = v return render_template("index.html", list_records=sorted_activity, names=member_names)
def edit_activity_type(type_id): db = DatabaseController() activity_type = db.get_row(DatabaseTables.TIP_AKTIVNOSTI, 'id', type_id) if request.method == 'POST': name = request.form['name'] description = request.form['description'] try: section = request.form['section'] except HTTPException: section = session["section"] error = None if not name: error = 'Name is required.' if not description: description = '-' if activity_type[1] != name and db.activity_type_exists(name): error = 'Tip aktivnosti %s već postoji u bazi podataka' % name if error is None: entry_values = (name, description, section) db.edit_activity_type(type_id, entry_values) flash("Tip aktivnosti %s je uspješno izmjenjen!" % name, 'success') return redirect(url_for('index')) flash(error, 'danger') return render_template('/activities/edit_type.html', activity_type=activity_type[1:], activity_type_id=activity_type[0], sections=Utilities.sections_and_teams)
def add_activity(): db = DatabaseController() if request.method == 'POST': name = request.form['name'] description = request.form['description'] activity_start_date = request.form['date'] type = request.form['type'] try: section = request.form['section'] except HTTPException: section = session["section"] error = None if not name: error = 'Username is required.' if not description: description = '-' if not activity_start_date: error = 'Date is required' if not type: error = 'Activity type value is required.' if error is None: activity_start_date = get_date_object(activity_start_date) entry_values = (name, description, activity_start_date, section, type) if db.activity_exists(name, activity_start_date, section): flash( "Aktivnost sa istim imenom i datumom za ovu sekciju već postoji u bazi", "info") return redirect(url_for('activities.add_activity')) db.add_activity_entry(entry_values) activity_id = db.get_last_row_id() flash("Aktivnost %s je uspješno dodana!" % name, 'success') if request.form['action'] == "member_to_activity": flash( "Preusmjeren si na formu za dodavanje članova koji su došli na aktivnost.", 'info') return redirect( url_for('activities.add_members_to_activity', activity_id=activity_id)) return redirect(url_for('index')) flash(error, 'danger') activity_types = {} for row in db.get_all_rows_from_table(DatabaseTables.TIP_AKTIVNOSTI): activity_types[row[0]] = (row[1], row[3]) return render_template('/activities/add.html', activity_types=activity_types)
def add_members_to_activity(activity_id): db = DatabaseController() if session[ "access_level"] >= AccessLevels.SAVJETNIK: # Ako je razina ovlasti savjetnik ili manja, dohvati matičnu sekciju samo all_members = db.get_all_members() else: all_members = db.get_all_members_admin( ) # Za admina dohvati sve članove members_list = {} for member in all_members: member_id = member[0] if db.is_member_active(member_id) and not db.member_activity_exists( member_id, activity_id): members_list[member[0]] = member[1:] if session["access_level"] >= AccessLevels.SAVJETNIK: sorted_list = sorted( members_list.items(), key=lambda x: x[1][1]) # Sort po prezimenu ako je unutar sekcije else: sorted_list = sorted( members_list.items(), key=lambda x: (x[1][-1], x[1][1])) # Sort po sekciji prvo pa prezimenu sorted_members = {} for k, v in sorted_list: sorted_members[k] = v if request.method == 'POST': for member_id, _ in sorted_members.items(): if request.form.get('checkbox%s' % member_id): hours_worked = request.form["hoursworked%s" % member_id] factor = request.form["factor%s" % member_id] if float(hours_worked) != 0: if not db.member_activity_exists(member_id, activity_id): db.add_member_activity_entry( (member_id, activity_id, hours_worked, factor)) flash("Volonterski sati su uspješno izmjenjeni!", "success") return redirect("/activities/list") return render_template("/activities/add_members_to_activity.html", activity_id=activity_id, members_list=sorted_members)
def __init__(self, threadid, filepath, sliceStart, sliceEnd): threading.Thread.__init__(self) self.sliceStart = sliceStart self.sliceEnd = sliceEnd self.threadid = threadid self.itemsToInsert = [] self.dbCtrl = DatabaseController() self.dump_id = self.dbCtrl.insertDump('Adobe 2013 Mega dump') self.lineCounter = 0 try: self.file = open(filepath, 'r') except IOError, e: print('opening failed: ' + e)
class ThreadedUploader: def __init__(self, queueSize=4500): self.stopped = False self.queue = Queue(maxsize=queueSize) self.db_updater = DatabaseController() self.s3 = S3Controller() def start(self): thread = Thread(target=self.work, args=()) thread.daemon = True thread.start() return self def work(self): while True: if self.stopped: return if self.queue.empty(): time.sleep(2) continue # upload stuff (frame, attr) = self.queue.get() now = datetime.datetime.now().strftime("%Y%m%dT%H%M%S") frame_name = "{}_{}_{}.jpg".format(attr['job_id'], attr['frame_no'], now) self.db_updater.insertOutput(attr['job_id'], attr['vid_time'], attr['frame_no'], attr['ssim'], frame_name) jpg_byte = cv2.imencode('.jpg', frame)[1].tostring() self.s3.upload(frame_name, jpg_byte, 'image/jpg') def put(self, frame, attr): self.queue.put((frame, attr)) def stop(self): self.stopped = True
def __init__(self): self.dump_id = '' self.dump_url = '' self.dbAccess = DatabaseController()
def main(self, argv): # # 1. Argument parsing # self.logger.debug("The total numbers of args passed to the script: %d " % len(argv)) self.logger.debug("Args: " + str(argv)) # TODO: flesh out argument parsing and help, -h # Parse command line arguments sDescription = "no description yet" sEpilog = "Returns exit code 0 on success, non-zero on error.\n\n" \ "Use app.conf to change script configuration.\n" \ "Use logging.conf to change logging information." parser = argparse.ArgumentParser(formatter_class=argparse.RawDescriptionHelpFormatter, description=sDescription, epilog=sEpilog) parser.add_argument('-host', help='hostname to ping') parser.add_argument('-f', '--file', help='file containing list of hosts to ping') parser.add_argument('-c', '--conf', default='app.conf', help='application config file to use (default: %(default)s)') args = parser.parse_args() self.logger.debug("Parsed args: " + str(args)) appConfFile = os.path.join(os.path.dirname(__file__), args.conf) if not os.path.isfile(appConfFile): self.logger.error(appConfFile + " not found.") return hostnames = [] if args.host: hostnames.append(args.host) # Also get the list of hosts from a file if args.file: if not os.path.isfile(args.file): self.logger.error("File not found: " + args.file) return else: with open(args.file, 'r') as file: for line in file: line = line.strip() if line: hostnames.append(line) # # 2. Controller setup # # Get the configuration parameters self.configController = ConfigController() self.configController.loadConfiguration(appConfFile) # Establish a database connection self.databaseController = DatabaseController(True) self.databaseController.connect(self.configController.getDbConnectString()) self.devices = self.databaseController.getDevices() # Get a ping controller instance self.pingController = PingController() self.pingCount = self.configController.getPingCount() # Setup email controller self.emailConf = self.configController.getEmailTuple() self.emailController = EmailController(self.emailConf.username, self.emailConf.password, self.emailConf.server, self.emailConf.port, self.emailConf.sender_name) # # 3. Script main run # # Finally we use the list of hostnames self.logic(hostnames) self.databaseController.disconnect() return 0
def OnRtnTrade(self, pTrade): logger.info('OnRtnTrade %s' % str(pTrade)) DatabaseController.insert_RtnOrder(pTrade)
class Controller: def __init__(self): self.logger = logging.getLogger(__name__) self.devices = {} self.configController = None self.databaseController = None self.pingController = None self.emailController = None self.emailConf = None self.pingCount = None return def __del__(self): return def main(self, argv): # # 1. Argument parsing # self.logger.debug("The total numbers of args passed to the script: %d " % len(argv)) self.logger.debug("Args: " + str(argv)) # TODO: flesh out argument parsing and help, -h # Parse command line arguments sDescription = "no description yet" sEpilog = "Returns exit code 0 on success, non-zero on error.\n\n" \ "Use app.conf to change script configuration.\n" \ "Use logging.conf to change logging information." parser = argparse.ArgumentParser(formatter_class=argparse.RawDescriptionHelpFormatter, description=sDescription, epilog=sEpilog) parser.add_argument('-host', help='hostname to ping') parser.add_argument('-f', '--file', help='file containing list of hosts to ping') parser.add_argument('-c', '--conf', default='app.conf', help='application config file to use (default: %(default)s)') args = parser.parse_args() self.logger.debug("Parsed args: " + str(args)) appConfFile = os.path.join(os.path.dirname(__file__), args.conf) if not os.path.isfile(appConfFile): self.logger.error(appConfFile + " not found.") return hostnames = [] if args.host: hostnames.append(args.host) # Also get the list of hosts from a file if args.file: if not os.path.isfile(args.file): self.logger.error("File not found: " + args.file) return else: with open(args.file, 'r') as file: for line in file: line = line.strip() if line: hostnames.append(line) # # 2. Controller setup # # Get the configuration parameters self.configController = ConfigController() self.configController.loadConfiguration(appConfFile) # Establish a database connection self.databaseController = DatabaseController(True) self.databaseController.connect(self.configController.getDbConnectString()) self.devices = self.databaseController.getDevices() # Get a ping controller instance self.pingController = PingController() self.pingCount = self.configController.getPingCount() # Setup email controller self.emailConf = self.configController.getEmailTuple() self.emailController = EmailController(self.emailConf.username, self.emailConf.password, self.emailConf.server, self.emailConf.port, self.emailConf.sender_name) # # 3. Script main run # # Finally we use the list of hostnames self.logic(hostnames) self.databaseController.disconnect() return 0 # TODO: need a better function name than "logic"... def logic(self, hostnames): self.logger.debug("Hostnames: " + str(hostnames)) # list of ping result tuples for failed pings failedPingResults = [] # list of ping result tuples for successful pings successfulPingResults = [] # list of ping result tuples from the database latestPingResults = self.databaseController.getLatestPingResults() # list of ping result tuples for successful pings that were previously failures failsuccessPingResults = [] for hostname in hostnames: # If this is a new device then add it to the database if hostname not in self.devices: self.logger.debug("Found new device: " + hostname) device = Device(None, hostname, 1) newDevice = self.databaseController.addDevice(device) self.devices[hostname] = newDevice deviceId = self.devices[hostname].device_id pingResult = self.pingController.ping(hostname, self.pingCount, deviceId) if pingResult: successfulPingResults.append(pingResult) else: # New ping result with is_success=False pingResult = PingResult(device_id=deviceId, is_success=False) failedPingResults.append(pingResult) self.databaseController.addPingResult(pingResult) # Check if this device was previously down but is now up for pingResult in successfulPingResults: if pingResult.device_id in latestPingResults: prevIsSuccess = latestPingResults[pingResult.device_id].is_success datePinged = latestPingResults[pingResult.device_id].date_pinged now = datetime.datetime.now() minutesDownFor = math.ceil((now-datePinged).total_seconds()/60) if prevIsSuccess is not 1: device = self.getDeviceById(pingResult.device_id) self.logger.debug("Host '" + str(device.hostname) + "' was previously down for up to " + str(minutesDownFor) + " minutes but is now up.") failsuccessPingResults.append(pingResult) # Check if this device was previously down and is still down # Copy failedPingResults into failedPingResultsCopy to avoid loop issues while deleting elements... # TODO: probably a better way of doing this failedPingResultsCopy = list(failedPingResults) for pingResult in failedPingResultsCopy: if pingResult.device_id in latestPingResults: prevIsSuccess = latestPingResults[pingResult.device_id].is_success if prevIsSuccess is not 1: device = self.getDeviceById(pingResult.device_id) self.logger.debug("Host '" + str(device.hostname) + "' was previously down and is still down.") failedPingResults.remove(pingResult) # Send an email if failedPingResults or failsuccessPingResults: if not self.emailConf.enabled: self.logger.debug("Email is disabled. Skipping email...") else: self.logger.debug("Email is enabled: " + str(self.emailConf.enabled)) subject = 'FoscamPing Email Controller' timeNow = time.strftime('%Y-%m-%d %H:%M:%S') text = '' for failedPingResult in failedPingResults: device = self.getDeviceById(failedPingResult.device_id) text += timeNow + ' - Failed to ping: ' + device.hostname + "\n" for pingResult in failsuccessPingResults: device = self.getDeviceById(pingResult.device_id) datePinged = latestPingResults[pingResult.device_id].date_pinged now = datetime.datetime.now() minutesDownFor = math.ceil((now-datePinged).total_seconds()/60) text += timeNow + ' - Previously down for up to ' + str(minutesDownFor) + ' minutes but is now up: ' + device.hostname + "\n" self.emailController.sendEmail(self.emailConf.send_to, subject, text) return def getDeviceById(self, device_id): """ Helper function to get a Device tuple by device_id :param device_id: device_id to search for. :return: Device tuple if found, else None. """ for hostname in self.devices: # if device.device_id == device_id: if self.devices[hostname].device_id == device_id: return self.devices[hostname] self.logger.error("Device id not found" + str(device_id)) return None
def __init__(self, url): self.url = url self.dbAccess = DatabaseController()