def __init__(self, dbPath, dbName): self.database = dbPath + dbName self.dataPath = dbPath self.visits = Visits() self.guests = Guests() self.reports = Reports(self) self.teams = Teams() self.accounts = Accounts() self.devices = Devices() self.unlocks = Unlocks() # needs path since it will open read only self.customReports = CustomReports(self.database) self.certifications = Certifications() self.members = Members() self.logEvents = LogEvents() if not os.path.exists(self.database): if not os.path.exists(dbPath): os.mkdir(dbPath) with self.dbConnect() as c: self.migrate(c, 0) else: with self.dbConnect() as c: data = c.execute('PRAGMA schema_version').fetchone() if data[0] != SCHEMA_VERSION: self.migrate(c, data[0])
def create_wallet(cls, user_id: str) -> bool: "A method to initialize a users wallet" if not user_id in cls._wallets: cls._wallets[user_id] = Decimal('0') Reports.log_event(f"wallet for `{user_id}` created and set to 0") return True return False
def generate_reports(self): """ After all scan files are parsed, begin generating Excel Tabs """ logging.info('Generating Reports') reports = Reports(main_app.main_window) total_reports = list( filter(lambda x: x.startswith('rpt'), dir(reports))) index = 0 for report in total_reports: index += 1 status = f"Generating Report {report}" print(status) logging.info(status) if main_app.main_window: main_app.main_window.progressBar.setValue( int(100 * index / (len(total_reports)) * .9)) QtGui.QGuiApplication.processEvents() getattr(reports, report)() reports.close_workbook() status = f"Report Generated" logging.info(status) print(status) if main_app.main_window: main_app.main_window.statusBar().showMessage(status) main_app.main_window.progressBar.setValue(0) QtGui.QGuiApplication.processEvents()
def register_user(cls, new_user: dict[str, str]) -> str: "register a user" if not new_user["user_name"] in cls._users: # generate really complicated unique user_id. # Using the existing user_name as the id for simplicity user_id = new_user["user_name"] cls._users[user_id] = new_user Reports.log_event(f"new user `{user_id}` created") # create a wallet for the new user Wallets().create_wallet(user_id) # give the user a sign up bonus Reports.log_event(f"Give new user `{user_id}` sign up bonus of 10") Wallets().adjust_balance(user_id, Decimal(10)) return user_id return ""
def generate_reports(self): """ After all scan files are parsed, begin generating Excel Tabs """ reports = Reports(self.scan_results, self.data_mapping, self.contact_info, self.poam_conf, S2R.scans_to_reports) for report in filter(lambda x: x.startswith('rpt'), dir(reports)): print(report) getattr(reports, report)() QtWidgets.QApplication.processEvents() reports.close() if S2R.scans_to_reports: S2R.scans_to_reports.statusBar().showMessage("Report Generated")
def __init__(self, chat_id, bot ): conn = sqlite3.connect(dataBaseDjangoDir) cursor = conn.cursor() cursor.execute("""select * from usuarios_usuario""") conn.commit() query = (cursor.fetchall()) for user in query: if user[4] == chat_id: self.name = user[1] self.email = user[4] self.authorize = True self.help = Help(chat_id) self.sensiTags = SensiTags(bot) self.graphic = Graphics() self.report = Reports() self.chat_id = chat_id
def GET(self): web.header('Content-Type', 'text/html;charset=UTF-8') form = web.input(email="*****@*****.**", campaignId=None, starttime=None, endtime=None) logger.info("Received user " + form.email + " request to get campaign report") httpsSession = createHttpsSession(form.email) reportsPath = cf.get("apiservices", "reports") reporthandler = Reports(reportsPath, httpsSession, logger) result = reporthandler.query_all_campaigns(email=form.email, campaignId=form.campaignId, starttime=form.starttime, endtime=form.endtime) return result
def submit_entry(cls, user_id: str, entry: Decimal) -> bool: "Submit a new entry for the user in this game" now = int(time.time()) time_remaining = cls._start_time - now + cls._clock if time_remaining > 0: if Wallets.get_balance(user_id) > Decimal('1'): if Wallets.adjust_balance(user_id, Decimal('-1')): cls._entries.append((user_id, entry)) Reports.log_event( f"New entry `{entry}` submitted by `{user_id}`") return True Reports.log_event( f"Problem adjusting balance for `{user_id}`") return False Reports.log_event(f"User Balance for `{user_id}` to low") return False Reports.log_event("Game Closed") return False
def report_excel(request): log_start_time = datetime.utcnow() if not request.user.is_authenticated(): return HttpResponseRedirect('/ui/login/?next=/ui/') log_entry = LogEntry() log_entry.user = request.user log_entry.timestamp = log_start_time log_entry.post_data = request.POST if request.POST.has_key('chkReporter') \ and request.POST.has_key('hdnResultType') \ and request.POST.has_key('txtStartDate') \ and request.POST.has_key('txtEndDate'): start_date = request.POST.get('txtStartDate') end_date = request.POST.get('txtEndDate') reporters = request.POST.get('chkReporter').split(',') reporter_type = request.POST.get('hdnResultType') else: return HttpResponse('insufficient parameters') filename = 'wqm_reporters_%s_%s.xls' % (start_date, end_date) if reporter_type == 'NAME': samples = Sample.objects.filter(reporter_name__in=reporters, date_taken__gte=start_date, date_taken__lte=end_date).order_by('date_taken') log_entry.event_type = 'rep_reporter_name' elif reporter_type == 'TEL': samples = Sample.objects.filter(taken_by__connections__identity__in=reporters, date_taken__gte=start_date, date_taken__lte=end_date).order_by('date_taken') log_entry.event_type = 'rep_reporter_tel' else: return HttpResponse('Unknown reporter type supplied') # Create the HttpResponse object with the appropriate XLS header info. response = HttpResponse(mimetype="application/ms-excel") response['Content-Disposition'] = 'attachment; filename=%s' % filename wb = Reports.get_basic_for_samples(samples) wb.save(response) log_entry.set_processing_time(log_start_time) log_entry.save() return response
def reports_btn(self): root2 = Toplevel(self.master) myGui = Reports(root2)
async def _get_html(self, speed=1): """ :param speed: 翻页间隔时间,秒 :return: 返回爬取页面的HTML内容 """ sql = "select shop_id from shop_info where shop_id!='88888888'" # 获取所有的店铺ID shop_infos = mysql.get_data(sql=sql, dict_result=True) shop_ids = [] for shop_info in shop_infos: page_control = Format._read(shop_id=shop_info['shop_id'], flag="total_page") # 获得存储在本地的店铺总的页码数量 if not page_control: page_control = 1000 # 如果没有获取到页码总数,给个1000的总数 shop_ids.append(shop_info['shop_id']) # 将店铺ID存储起来用于后面重置翻页数据 url = self.start_url.replace("shop", "shop" + shop_info["shop_id"]) # 获得到店铺首页url地址 await self.page.goto(url) await self._jump_to_search_page() page_num = Format._read(shop_info['shop_id'], "page_num") # 读取存储在本地的page_num while page_num < page_control: start_time = time.time() # 本页面开始的时间存入变量 try: # if page_num: await self._goto_last_page_num(page_num + 1) await asyncio.sleep(5) frames = self.page.frames for f in frames: if await f.J("#TPL_username_1"): yield 0, 0 frame = await self.login.get_nc_frame(frames=frames) if frame: await self.login.slider(self.page, 1) except Exception as e: print(e) await asyncio.sleep(5) continue try: await self.page.waitForSelector(".shop-hesper-bd.grid") except errors.TimeoutError: break except Exception as e: print(e) continue Format._write(shop_id=shop_info['shop_id'], flag="page_num", value=page_num + 1) # 将下次需要爬取的页码存入本地的配件中 page_num = Format._read(shop_info['shop_id'], "page_num") # 读取下一次要爬取的页码 yield await self.page.content(), shop_info['shop_id'] # 返回页面HTML内容和 page_control = Format._read(shop_id=shop_info['shop_id'], flag="total_page") # 获得存储在本地的店铺总的页码数量 await asyncio.sleep(speed) # 翻页间隔时间 spent_time_this_page = time.time() - start_time # 计算本页完成时间 spent_time = Format._read(shop_id=shop_info['shop_id'], flag="spent_time") # 读取上一次存储在本地的时间 Format._write(shop_id=shop_info['shop_id'], flag="spent_time", value=spent_time + spent_time_this_page) # 将本页面完成时间加上后并存储在本地 is_mail = Format._read(shop_info['shop_id'], "mail") if not is_mail: Reports().report(shop_info['shop_id'].split(" ")) for shop_id in shop_ids: Format._del(shop_id=shop_id, flag="page_num") # 重置翻页的数据 Format._del(shop_id=shop_id, flag="total_page") # 重置总页码数据 Format._del(shop_id=shop_id, flag="mail") # 重置邮件标记 Format._del(shop_id=shop_id, flag="spent_time") # 重置完成时间
def report_preview(request, domain_id): log_start_time = datetime.utcnow() if not request.user.is_authenticated(): return HttpResponseRedirect('/ui/login/?next=/ui/') try: # attempt load up the requested domain if the user has access to it domain = Domain.objects.filter( membership__member_type = ContentType.objects.get_for_model(User), membership__member_id = request.user.id, membership__is_active=True, # Looks in membership table is_active=True, id = domain_id)[0] # Looks in domain table except IndexError: # if it wasn't loaded it either doesn't exist (in which case the user is poking around with the url) # or the user doesn't have access to it. Either way, best to just display access denied so people # messing with URLs get as little info as possible. #TODO: redirect to an access denied page return HttpResponse('access denied - you don\'t have access to this domain id') log_entry = LogEntry() log_entry.user = request.user log_entry.timestamp = log_start_time log_entry.post_data = request.POST if request.POST.has_key('chkReporter') \ and request.POST.has_key('hdnResultType') \ and request.POST.has_key('txtStartDate') \ and request.POST.has_key('txtEndDate'): start_date = request.POST.get('txtStartDate') end_date = request.POST.get('txtEndDate') reporters = request.POST.getlist('chkReporter') reporter_type = request.POST.get('hdnResultType') else: return HttpResponse('insufficient parameters') filename = 'wqm_reporters_%s_%s_%s.xls' % (domain.name.replace(' ', '_') .replace('\\','_').replace('//','_').replace('?','_').replace("'","_"), start_date, end_date) if reporter_type == 'NAME': samples = Sample.objects.filter(reporter_name__in=reporters, date_taken__gte=start_date, date_taken__lte=end_date).order_by('date_taken') log_entry.event_type = 'rep_prev_reporter_name' elif reporter_type == 'TEL': samples = Sample.objects.filter(taken_by__connections__identity__in=reporters, date_taken__gte=start_date, date_taken__lte=end_date).order_by('date_taken') log_entry.event_type = 'rep_prev_reporter_tel' else: return HttpResponse('Unknown reporter type supplied') report_html = Reports.get_report_html(samples) template = loader.get_template('ui-report-preview.html') context = Context({ 'domain' : domain, 'user' : request.user, 'report_table' : report_html, 'start_date' : start_date, 'end_date' : end_date, 'result_type' : reporter_type, 'reporters' : ','.join(reporters) }) response = HttpResponse(template.render(context)) log_entry.set_processing_time(log_start_time) log_entry.save() return response
class Auth: name = '' chat_id = None authorize = False help = None tags = None alarms = None email = None def __init__(self, chat_id, bot ): conn = sqlite3.connect(dataBaseDjangoDir) cursor = conn.cursor() cursor.execute("""select * from usuarios_usuario""") conn.commit() query = (cursor.fetchall()) for user in query: if user[4] == chat_id: self.name = user[1] self.email = user[4] self.authorize = True self.help = Help(chat_id) self.sensiTags = SensiTags(bot) self.graphic = Graphics() self.report = Reports() self.chat_id = chat_id def authUser(self): return self.authorize def unauthorized(self, bot): conn = sqlite3.connect(dataBaseDjangoDir) cursor = conn.cursor() cursor.execute("""select * from usuarios_usuario""") conn.commit() query = (cursor.fetchall()) msg = 'Ei, meu nome Sensi!\n' msg = msg + 'Infelizmente vc não tem permissão para acessar meus dados.\n' msg = msg + '\nEntre em contato com uma das pessoas abaixo para se cadastrar no sistema:\n\n' for user in query: msg = msg + '*->* ' msg = msg + '*' + user[1]+ '* - *' + str(user[3]) +'*\n' msg = msg + '\nAvise eles que seu chat id é: *' + str(self.chat_id) +'*' bot.send_message(self.chat_id, msg, parse_mode="markdown") def infoUsers(self, bot): msg = 'Ei, ' + self.name + '!\n' msg = msg + 'Aqui está a lista de usuários do meu sistema:\n\n' conn = sqlite3.connect(dataBaseDjangoDir) cursor = conn.cursor() cursor.execute("""select * from usuarios_usuario""") conn.commit() query = (cursor.fetchall()) for user in query: msg = msg + '*->* nome: *' + user[1] + '*\n' msg = msg + ' e-mail: *' + user[2] + '*\n' msg = msg + ' telefone: *' + str(user[3]) + '*\n' msg = msg + ' chat id: *' + str(user[4]) + '*\n\n' msg = msg + 'Precisando de mais alguma coisa? É só me chamar :)' bot.send_message(self.chat_id, msg, parse_mode="markdown") def infoSystem(self, bot): msgSystem = self.name + self.help.infoSystem() bot.send_message(self.chat_id, msgSystem, parse_mode="markdown") def alarmsInfo(self, bot): msgAlarms = self.name + self.sensiTags.alarms.getInfo() bot.send_message(self.chat_id, msgAlarms, parse_mode="markdown") def infoTags(self, bot): msgTags = self.name + self.sensiTags.getInfo() bot.send_message(self.chat_id, msgTags , parse_mode="markdown" ) def lastReg(self, bot): lastRegister = self.name + self.sensiTags.lastReg() bot.send_message(self.chat_id, lastRegister , parse_mode="markdown" ) def reboot(self, bot): conn = sqlite3.connect(dataBaseDjangoDir) cursor = conn.cursor() cursor.execute("""select * from usuarios_usuario""") conn.commit() query = (cursor.fetchall()) for user in query: if user[1] != self.name: msg ="*" + user[1] + "*, o usuário *"+self.name+"* pediu para o sistema ser reiniciado. Todos os usuários foram notificados.\n\nJá já estou de volta!" bot.send_message(user[4], msg , parse_mode="markdown" ) msg = self.name + ", vc pediu para o sistema ser reiniciado. Todos os usuários foram notificados.\n\nJá já estou de volta!" bot.send_message(self.chat_id, msg, parse_mode="markdown") os.system("sudo reboot") def graphicsOneDay(self, bot): conn = sqlite3.connect(dataBaseDjangoDir) cursor = conn.cursor() cursor.execute("""SELECT * FROM tags_tag""") conn.commit() query = (cursor.fetchall()) # trata se não existir SensiTags if len(query) > 0: msgGraphics ="Olá *" + self.name +"*"+ self.graphic.getInfo() + "do último dia. Lembrando que os gráficos devem demorar alguns segundos para chegar!" bot.send_message(self.chat_id, msgGraphics, parse_mode="markdown") self.graphic.makeAndSendGraphicAll(288, bot, self.chat_id) else: bot.send_message(self.chat_id, "Sensi aqui!\nParece que o seu sistema não possui SensiTags Cadastradas.", parse_mode="markdown") def graphics3Day(self, bot): conn = sqlite3.connect(dataBaseDjangoDir) cursor = conn.cursor() cursor.execute("""SELECT * FROM tags_tag""") conn.commit() query = (cursor.fetchall()) #trata se não existir SensiTags if len(query)>0: msgGraphics ="Olá *" + self.name +"*"+ self.graphic.getInfo() + "dos últimos 3 dias. Lembrando que os gráficos devem demorar alguns minutinhos para chegar :)" bot.send_message(self.chat_id, msgGraphics, parse_mode="markdown") self.graphic.makeAndSendGraphicAll(700, bot, self.chat_id) else: bot.send_message(self.chat_id, "Sensi aqui!\nParece que o seu sistema não possui SensiTags Cadastradas.", parse_mode="markdown") def graphicsOneWeek(self, bot): conn = sqlite3.connect(dataBaseDjangoDir) cursor = conn.cursor() cursor.execute("""SELECT * FROM tags_tag""") conn.commit() query = (cursor.fetchall()) #trata se não existir SensiTags if len(query)>0: msgGraphics ="Olá *" + self.name +"*"+ self.graphic.getInfo() + "dos últimos 7 dias. Lembrando que os gráficos devem demorar alguns minutinhos para chegar :)" bot.send_message(self.chat_id, msgGraphics, parse_mode="markdown") self.graphic.makeAndSendGraphicAll(2016, bot, self.chat_id) else: bot.send_message(self.chat_id, "Sensi aqui!\nParece que o seu sistema não possui SensiTags Cadastradas.", parse_mode="markdown") def getHelp(self, bot): bot.send_message(self.chat_id, self.help.helpMessage(), parse_mode="markdown") def reportOneDayAll(self, bot): conn = sqlite3.connect(dataBaseDjangoDir) cursor = conn.cursor() cursor.execute("""SELECT * FROM tags_tag""") conn.commit() query = (cursor.fetchall()) # trata se não existir SensiTags if len(query) > 0: msgGraphics = "Ei, *" + self.name + "*!\nEstou te enviando o relatório completo de suas SensiTags dos últimos 1 dias. Lembrando que os isso pode demorar alguns minutinhos para chegar :)" bot.send_message(self.chat_id, msgGraphics, parse_mode="markdown") self.report.sendReportOneDayAll(bot, self.chat_id) else: bot.send_message(self.chat_id, "Sensi aqui!\nParece que o seu sistema não possui SensiTags Cadastradas.", parse_mode="markdown") def report3DaysAll(self, bot): conn = sqlite3.connect(dataBaseDjangoDir) cursor = conn.cursor() cursor.execute("""SELECT * FROM tags_tag""") conn.commit() query = (cursor.fetchall()) # trata se não existir SensiTags if len(query) > 0: msgGraphics = "Ei, *" + self.name + "*!\nEstou te enviando o relatório completo de suas SensiTags dos últimos 3 dias. Lembrando que os isso pode demorar alguns minutinhos para chegar :)" bot.send_message(self.chat_id, msgGraphics, parse_mode="markdown") self.report.sendReport3DaysAll(bot, self.chat_id) else: bot.send_message(self.chat_id, "Sensi aqui!\nParece que o seu sistema não possui SensiTags Cadastradas.", parse_mode="markdown") def report7DaysAll(self, bot): conn = sqlite3.connect(dataBaseDjangoDir) cursor = conn.cursor() cursor.execute("""SELECT * FROM tags_tag""") conn.commit() query = (cursor.fetchall()) # trata se não existir SensiTags if len(query) > 0: msgGraphics = "Ei, *" + self.name + "*!\nEstou te enviando o relatório completo de suas SensiTags dos últimos 7 dias. Lembrando que os isso pode demorar alguns minutinhos para chegar :)" bot.send_message(self.chat_id, msgGraphics, parse_mode="markdown") self.report.sendReport7DaysAll(bot, self.chat_id) else: bot.send_message(self.chat_id, "Sensi aqui!\nParece que o seu sistema não possui SensiTags Cadastradas.", parse_mode="markdown")
import schedule from settings import config from reports import Reports # O o_reports = Reports(config['o']['source'], config['o']['destination'], config['archive']) # Z z_reports = Reports(config['z']['source'], config['z']['destination'], config['archive']) # R r_reports = Reports(config['r']['source'], config['r']['destination'], config['archive']) # Schedule schedule.every(10).minutes.do(o_reports.move_all) # -------------------------------------------------------- schedule.every().day.at('03:00').do(o_reports.create_week_archive) schedule.every().day.at('03:10').do(z_reports.create_week_archive) schedule.every().day.at('03:20').do(r_reports.create_week_archive) # -------------------------------------------------------- schedule.every().day.at('05:00').do(r_reports.move_period) # -------------------------------------------------------- schedule.every().day.at('06:00').do(z_reports.move_or_copy) schedule.every().day.at('08:00').do(z_reports.move_or_copy) schedule.every().day.at('12:00').do(z_reports.move_or_copy) schedule.every().day.at('14:00').do(z_reports.move_or_copy) schedule.every().day.at('16:00').do(z_reports.move_or_copy) if __name__ == '__main__': while True: schedule.run_pending()
from flask import request, redirect, Flask, flash, render_template, send_from_directory, url_for, jsonify #pip install flask from werkzeug.utils import secure_filename import os,datetime,math from customer import Customer from item import Item from payment import Payment from transaction import Transaction from goldprice import getTodaysGoldPrice from reports import Reports import util # from util import encrypt reports = Reports() trans = Transaction() payment = Payment() item = Item() app = Flask(__name__) users = {'*****@*****.**': {'password': '******'}} app.secret_key = 'super secret string' customer = Customer() UPLOAD_FOLDER = os.curdir+'\\uploads' ALLOWED_EXTENSIONS = {'txt', 'pdf', 'png', 'jpg', 'jpeg', 'gif'} app.config['UPLOAD_FOLDER'] = UPLOAD_FOLDER app.config['MAX_CONTENT_LENGTH'] = 16 * 1024 * 1024 app.config['SERVERNAME'] = "reddy:5000" @app.route('/') def home(): return render_template("home.html",reports=get_reports()) @app.route('/uploads/<filename>') def uploaded_file(filename):
parser.add_argument('--settings', dest='settings', action='store', default='settings', help='settings file') parser.add_argument('--reports', dest='reports', action='store', default=None, help='show reports') parser.add_argument('--no-progress', dest='print_progress', action='store_false', default=True, help='show progress') parser.add_argument('--print-keys', dest='print_keys', action='store_true', default=False, help='print keys') parser.add_argument('--groups', dest='groups', action='store', default=None, help='filter keys to groups list separated by comma(,)') args = parser.parse_args() settings_file = args.settings or 'settings' settings = __import__(settings_file, {}, {}, []) p = Parser(settings, {'print_progress': args.print_progress, 'print_keys': args.print_keys}) if args.input_file: p.parse(args.input_file, int(args.limit_lines)) if args.use_file: p.save_data(args.use_file) r = Reports(settings, {'groups': args.groups and args.groups.split(',')}, p.get_data()) else: r = Reports(settings, {'groups': args.groups and args.groups.split(',')}, args.use_file) r.main(args.reports) #import memcache #mc = memcache.Client(['127.0.0.1:11211'], debug=0) #print mc.get_stats()
def _get_html(self): for shop_id in self._get_shop_id(): start_time = time.time() curls = self._get_curls(shop_id) if not curls: continue curl = random.choice(curls) page_num, used_page_nums, total_page = self._get_page_num(shop_id) session = requests.Session() while page_num: url, params, cookies, headers = self.format_request_params( curl['curl'], page_num) while 1: try: proxy = Format._read("1", "proxy") print(proxy) if not proxy: self._set_proxy() proxies = {"https": "https://{}".format(proxy)} r = session.get(url=url, params=params, cookies=cookies, headers=headers, proxies=proxies, stream=True) except requests.exceptions.ProxyError: self._set_proxy() session = requests.Session() continue except requests.exceptions.InvalidURL: self._set_proxy() continue except requests.exceptions.SSLError: self._set_proxy() continue else: break html = r.text.replace("\\", "") html = re.sub("jsonp\d+\(\"|\"\)", "", html) yield html, shop_id, curl, total_page, page_num spent_time = int(time.time() - start_time) used_page_nums.append(page_num) used_page_nums.sort() tspi = { # tb_search_page_info "used_page_nums": ",".join([str(x) for x in used_page_nums]), "spent_time": spent_time, "last_date": datetime.date.today() } MySql.cls_update(db_setting=TEST_SERVER_DB_TEST, t="tb_search_page_info", set=tspi, c={"shop_id": shop_id}) page_num, used_page_nums, total_page = self._get_page_num( shop_id) sql = "UPDATE tb_master SET flag='XiaJia',update_date='{}' WHERE shop_id='{}' AND update_date<'{}'".format( datetime.date.today(), shop_id, datetime.date.today()) # print(sql) MySql.cls_update(db_setting=TEST_SERVER_DB_TEST, sql=sql) reports = Reports() reports.report([ids for ids in self._get_shop_id()])
def re(self, event=""): self.withdraw() Reports(self, self.main_root)
class Engine(object): def __init__(self, dbPath, dbName): self.database = dbPath + dbName self.dataPath = dbPath self.visits = Visits() self.guests = Guests() self.reports = Reports(self) self.teams = Teams() self.accounts = Accounts() self.devices = Devices() self.unlocks = Unlocks() # needs path since it will open read only self.customReports = CustomReports(self.database) self.certifications = Certifications() self.members = Members() self.logEvents = LogEvents() if not os.path.exists(self.database): if not os.path.exists(dbPath): os.mkdir(dbPath) with self.dbConnect() as c: self.migrate(c, 0) else: with self.dbConnect() as c: data = c.execute('PRAGMA schema_version').fetchone() if data[0] != SCHEMA_VERSION: self.migrate(c, data[0]) def dbConnect(self): return sqlite3.connect(self.database, detect_types=sqlite3.PARSE_DECLTYPES) def migrate(self, dbConnection, db_schema_version): if db_schema_version < SCHEMA_VERSION: self.visits.migrate(dbConnection, db_schema_version) self.members.migrate(dbConnection, db_schema_version) self.guests.migrate(dbConnection, db_schema_version) self.teams.migrate(dbConnection, db_schema_version) self.customReports.migrate(dbConnection, db_schema_version) self.certifications.migrate(dbConnection, db_schema_version) self.accounts.migrate(dbConnection, db_schema_version) self.devices.migrate(dbConnection, db_schema_version) self.unlocks.migrate(dbConnection, db_schema_version) self.logEvents.migrate(dbConnection, db_schema_version) dbConnection.execute('PRAGMA schema_version = ' + str(SCHEMA_VERSION)) elif db_schema_version != SCHEMA_VERSION: # pragma: no cover raise Exception("Unknown DB schema version" + str(db_schema_version) + ": " + self.database) def injectData(self, dictValues): areas = { "visits": self.visits, "members": self.members, "guests": self.guests, "teams": self.teams, "customReports": self.customReports, "certifications": self.certifications, "accounts": self.accounts, "devices": self.devices, "unlocks": self.unlocks, "logEvents": self.logEvents } for (key, member) in areas.items(): if key in dictValues: with self.dbConnect() as dbConnection: member.injectData(dbConnection, dictValues[key]) def getGuestLists(self, dbConnection): all_guests = self.guests.getList(dbConnection) building_guests = self.reports.guestsInBuilding(dbConnection) guests_not_here = [ guest for guest in all_guests if guest not in building_guests ] return (building_guests, guests_not_here)
def adjust_balance(cls, user_id: str, amount: Decimal) -> Decimal: "A method to adjust a user balance up or down" cls._wallets[user_id] = cls._wallets[user_id] + Decimal(amount) Reports.log_event(f"Balance adjustment for `{user_id}`. " f"New balance = {cls._wallets[user_id]}") return cls._wallets[user_id]
def get_balance(cls, user_id: str) -> Decimal: "A method to check a users balance" Reports.log_event( f"Balance check for `{user_id}` = {cls._wallets[user_id]}") return cls._wallets[user_id]
def report(request): log_start_time = datetime.utcnow() if not request.user.is_authenticated(): return HttpResponseRedirect('/ui/login/?next=/ui/') sample_point_ids = [] # create a log entry log_entry = LogEntry() log_entry.user = request.user log_entry.timestamp = log_start_time log_entry.post_data = request.POST #check if the post was from an info window (single sample point) if request.POST.has_key('btnInfoWindow') \ and request.POST.has_key('sample_point_id') \ and request.POST.has_key('txtInfoStartDate') \ and request.POST.has_key('txtInfoEndDate'): sample_point_ids.append(request.POST['sample_point_id']) start_date = request.POST.get('txtInfoStartDate') end_date = request.POST.get('txtInfoEndDate') report_type = 'FULL' elif request.POST.has_key('btnSidePanel')\ and request.POST.has_key('sample_point') \ and request.POST.has_key('txtSideStartDate') \ and request.POST.has_key('txtSideEndDate') \ and request.POST.has_key('radReportType'): report_type = request.POST.get('radReportType') start_date = request.POST.get('txtSideStartDate') end_date = request.POST.get('txtSideEndDate') sample_point_ids = request.POST.getlist('sample_point') else: return HttpResponse('insufficient parameters') if report_type == 'SITE_COUNT': filename = Reports.get_filename(sample_point_ids, start_date, end_date, 'site-test-count') log_entry.event_type = 'rep_site_test_count' elif report_type == 'REPORTER_COUNT': filename = Reports.get_filename(sample_point_ids, start_date, end_date, 'reporter-test-count') log_entry.event_type = 'rep_test_count' else: filename = Reports.get_filename(sample_point_ids, start_date, end_date) log_entry.event_type = 'rep_full' # Create the HttpResponse object with the appropriate XLS header info. response = HttpResponse(mimetype="application/ms-excel") response['Content-Disposition'] = 'attachment; filename=%s' % filename if report_type == 'SITE_COUNT': wb = Reports.render_excel(Reports.get_test_counts(sample_point_ids, start_date, end_date)) elif report_type == 'REPORTER_COUNT': wb = Reports.render_excel(Reports.get_reporter_test_counts(sample_point_ids, start_date, end_date)) else: wb = Reports.get_basic(sample_point_ids, start_date, end_date) wb.save(response) log_entry.set_processing_time(log_start_time) log_entry.save() return response
def get_history() -> dict: "get the game history" return Reports.get_history()
from reports import Reports import torch # testing constants MAX_EPISODE = 5000 # stop the training early and test the results # don't move this- it creates circular dependencies. report = Reports() # flags set_seed = True # Program run constants SEED = 0 DEVICE = torch.device("cuda" if torch.cuda.is_available() else "cpu") print('Device: {}'.format(DEVICE)) num_frames = 300000 VIDEO_INTERVAL = 100 # change to 1 to record all videos NUM_FRAMES_STACKED = 4 XYZ_GOAL = [.2, .1, 1.2] # More specific goal numbers [0.231, 0.105, 1.261] SOLVED_DISTANCE = 1.0 # WRITE_TO_FILE = True REPORT_INTERVAL = 1 # write all the reports SIZE = (512, 512) LR = 1e-2 # Other LR values, was 1e-3 or 3e-4 # prioritized replay params PRIORITY = False # True runs with priority replay ALPHA = .6 # alpha param for priority replay buffer BETA = .4 # initial value of beta BETA_ITERS = None # number of iterations over which beta will be annealed from initial value