def inject(confFile="confFiles/sample.yaml", **kwargs): if kwargs.get('fiConf'): fiConf = kwargs.pop('fiConf') else: fiConf = config.config(confFile) fiFunc = globals()[fiConf["Type"]] return fiFunc(fiConf, **kwargs)
class ProtectView(generic.FormView): template_name = 'dba/newdb.html' conf = config(settings.DBA_CONFIG_FILE) form_class = ProtectForm success_url = '/dba/' def form_valid(self, form): print('valid') ProtectedDbList.objects.create(server=form.cleaned_data['server'], instance=form.cleaned_data['instance'], db_name=form.cleaned_data['db_name'], user=self.request.user, reason=form.cleaned_data['reason']) #return super(ProtectView, self).form_valid(form) p = {} p['hosts'] = form.cleaned_data['server'].split('.')[0] p['instances'] = form.cleaned_data['instance'] self.request.POST = p return DbListView.as_view()(self.request) def form_invalid(self, form): print('invalid') return super(ProtectView, self).form_invalid(form) def get_initial(self): initial = super(ProtectView, self).get_initial() initial.update(get_default_data()) initial['seite'] = 'Löschschutz' initial['server'] = self.request.POST.get('server') initial['db_name'] = self.request.POST.get('db_name') initial['instance'] = self.request.POST.get('instance') return initial
class ProtectForm(forms.Form): conf = config(settings.DBA_CONFIG_FILE) db_name = forms.CharField(widget=forms.HiddenInput()) server = forms.CharField(widget=forms.HiddenInput()) instance = forms.CharField(widget=forms.HiddenInput()) reason = forms.CharField(label='Grund') def __init__(self, *args, **kwargs): super(ProtectForm, self).__init__(*args, **kwargs) self.helper = FormHelper self.helper.form_method = 'post' self.helper.form_action = 'protect/' self.helper.form_style = 'inline' self.helper.label_class = 'left' self.helper.field_class = 'left' self.helper.field_template = 'field.html' self.helper.use_custom_control = True self.helper.layout = Layout( Fieldset( 'Datenbank vor Löschen schützen', 'db_name', 'server', 'instance', 'reason', ), ButtonHolder(Submit('submit', 'Senden')))
def validate_args(): if len(sys.argv) % 2 == 0: print(usage("Invalid number of arguments")) exit(1) conf_path = '' ui_path = '' mode = 'NORMAL' for i in range(1, len(sys.argv)-1, 2): arg_item = sys.argv[i] arg_val = sys.argv[i+1] if arg_item == "-c": conf_path = arg_val elif arg_item == "-i": ui_path = arg_val elif arg_item == "-m": if arg_val == "COLD": mode = arg_val else: print(usage("Currently only supports cold start mode.")) exit(1) conf = config(conf_path, mode=mode) ui = user_interface(conf.platform, conf.channel_name, ui_path) return conf, ui
def authentication(email, password): firebase = config() auth = firebase.auth() user = auth.sign_in_with_email_and_password(email, password) if user['idToken'] != None: return user['idToken'] else: error = "ERROR: User is not logged in" return error
async def init(loop): conf = config() app = web.Application(middlewares=[cors_middleware(allow_all=True)]) mongo = await setup_mongo(app, conf, loop) handler = SiteHandler(mongo) setup_routes(app, handler, PROJ_ROOT) host, port = conf['host'], conf['port'] return app, host, port
def refresh_user_token(email, password): firebase = config() auth = firebase.auth() user = auth.sign_in_with_email_and_password(email, password) user = auth.refresh(user['refreshToken']) if user['idToken'] != None: return user['idToken'] else: error = "ERROR: User is not logged in" return error
def __init__(self, ws): # Params self.parser = config.config() self.go = False self.stopped = False self.robotID = self.parser.get("Game", "robotID") self.basketColor = "" # Server address self.ws = ws # Start Thread self.w = Thread(name='refereeThread', target=self.listen) self.w.start()
def df_to_sql(df, name): params = config() try: engine = create_engine(**params) df.to_sql(name, engine) print("Database Created") except (Exception, psycopg2.Error) as error: print("Error while connecting to PostgreSQL:", error)
def main(args): # given the config argument, set up configuration file if args.config: from src.config import config config() return has_config = os.path.exists('config.json') and os.path.isfile( 'config.json') # if the configuration file does not exist run the set up anyway if not has_config: from src.config import config config() # given the etl argument, run the etl if args.etl: from src.etl import do_etl do_etl() return # given the export argument, export the sample or full data set if args.export: if args.export == 'sample': sample = True else: sample = False from src.export import export from src.db import build_connection con = build_connection('config.json') export(con, sample) con.close() return # given the model argument, run the model on the sample or full data set if args.model: if args.model == 'sample': fpath = 'data/sample_data' else: fpath = 'data/full_data' from src.model import run_model run_model(fpath) return
def create_user(email, password): firebase = config() auth = firebase.auth() # Make sure you have email/password Auth allowed on your dashboard user = auth.create_user_with_email_and_password(email, password) if user['idToken'] != None: # auth.send_email_verification(user['idToken']) auth.get_account_info(user['idToken']) return user['idToken'] else: error = "ERROR: User is not logged in" return error
def __init__(self, model, confFile, log_level="ERROR", **kwargs): # Logging setup logging.basicConfig() logging.getLogger().setLevel(log_level) logging.debug("Logging level set to {0}".format(log_level)) # Retrieve config params fiConf = config.config(confFile) self.Model = model # No more passing or using a session variable in TF v2 # Call the corresponding FI function fiFunc = getattr(self, fiConf["Target"]) fiFunc(model, fiConf, **kwargs)
def query(sql, n=1): """ query part and vendor data from multiple tables""" conn = None try: params = config() conn = psycopg2.connect(**params) cur = conn.cursor() cur.execute(sql) it = list(iter_row(cur, 10)) cur.close() except (Exception, psycopg2.DatabaseError) as error: print(error) finally: if conn is not None: conn.close() return it
class IndexView(generic.FormView): template_name = 'dba/index.html' conf = config(settings.DBA_CONFIG_FILE) seite = 'Nicht Benutzt' def get(self, request, *args, **kwargs): context = get_default_data() context['seite'] = self.seite return render(request, self.template_name, context) def post(self, request, *args, **kwargs): context = get_default_data() context['seite'] = self.seite return render(request, self.template_name, context)
def connect_to_db(app): """Connect the database to our Flask app.""" # Configure to PostgreSQL database #app.config['SQLALCHEMY_DATABASE_URI'] = 'postgresql:///pintest' from src.config import config conf = config() DB_URL = 'postgresql+psycopg2://{user}:{pw}@{url}/{db}'.format( user=conf['user'], pw=conf['password'], url=conf['host'], db=conf['database']) app.config['SQLALCHEMY_DATABASE_URI'] = DB_URL app.config['SQLALCHEMY_TRACK_MODIFICATIONS'] = False db.app = app db.init_app(app)
def insert_from_dict(t_name, p_dict): sql = f'insert into {t_name} (%s) values %s' columns = p_dict.keys() values = [p_dict[column] for column in columns] conn = None try: params = config() conn = psycopg2.connect(**params) cur = conn.cursor() cur.execute(sql, (AsIs(','.join(columns)), tuple(values))) conn.commit() cur.close() except (Exception, psycopg2.DatabaseError) as error: print(error) finally: if conn is not None: conn.close()
def execute_query(query): params = config() try: conn = psycopg2.connect(**params) cursor = conn.cursor() cursor.execute(query) print("Query Executed") except (Exception, psycopg2.Error) as error: print("Error while connecting to PostgreSQL:", error) if (conn): conn.commit() cursor.close() conn.close()
def update_sql_from_df(df, name): params = config() try: conn = psycopg2.connect(**params) cursor = conn.cursor() for index, row in df.iterrows(): update_query = f"INSERT INTO {name} VALUES ({row.game_id}, {row.name}, {row.p1}, {row.p2}, {row.winner}, {row.model_choice}, {row.model0}, {row.model1}, {row.model2}, {row.model3}, {row.model4}, {row.model5}, '{row.timestamp if type(row.timestamp) != int else datetime.datetime.fromtimestamp(int(str(row.timestamp)[:10]))}', '{row.ip_address}')" cursor.execute(update_query, name) print("Database Updated") except (Exception, psycopg2.Error) as error: print("Error while connecting to PostgreSQL:", error) finally: if (conn): conn.commit() cursor.close() conn.close()
def __init__(self, src=0): self.rs_config = config.config() realsense_config.configure() # create initial variables for use in methods self.running = True self.currentFrame = None # create and start the pipeline with a color image stream self.pipeline = rs.pipeline() self.config = rs.config() self.config.enable_stream(rs.stream.color, self.rs_config.get('Cam', 'Width'), self.rs_config.get('Cam', 'Height'), rs.format.bgr8, self.rs_config.get('Cam', 'Fps')) self.pipeline.start(self.config) # initialize the values for the frame related variables self.frames = self.pipeline.wait_for_frames() self.color_frame = self.frames.get_color_frame() self.currentFrame = np.asanyarray(self.color_frame.get_data()) Thread(name="camThread", target=self.commandThread).start()
def query_to_df(query="SELECT * FROM power_weather LIMIT 15"): params = config() try: conn = psycopg2.connect(**params) cursor = conn.cursor() cursor.execute(query) df = pd.DataFrame(cursor.fetchall()) print(cursor.description) df.columns = [i[0] for i in cursor.description] #df.set_index('id', drop=True, inplace=True) print('df Created') except (Exception, psycopg2.Error) as error: print("Error while connecting to PostgreSQL:", error) if (conn): cursor.close() conn.close() return df
def test_constructor(self): conf = config(os.path.abspath(__file__+ "/../../test/config_test.yaml")) self.assertEqual(conf.mode, 'NORMAL') self.assertEqual(conf.api_token, '12345678') self.assertEqual(conf.channel_name, 'TestingChannel') self.assertEqual(conf.log_file[0:-12], os.path.abspath(__file__ + '/./../../test/telex_test_'))
def save_data_timestamp(data, childName): firebase = config() db = firebase.database() db.child(childName).push(data) return
class NewDBView(generic.FormView): template_name = 'dba/newdb.html' conf = config(settings.DBA_CONFIG_FILE) form_class = NewDbForm success_url = '/dba/newdb/success' def form_valid(self, form): id = 0 dbt = general.connect_dbt(self.conf) ldap_user = ''.join( ["%0.2x" % int(x) for x in self.request.user.objid]) # DBT Datenbank Eintrag data = {} data['kunden_id'] = form.cleaned_data['kunden'] data['grund_id'] = 3 data['eingespielt_von'] = ''.join( ["%0.2x" % int(x) for x in self.request.user.objid]) data['eingespielt_am'] = int(datetime.now().timestamp()) if form.cleaned_data['passwort'] != '': form.cleaned_data['verschluesselt'] = 'j' data['passwort'] = form.cleaned_data['passwort'] data['ziel_db'] = form.cleaned_data['host_name'] if form.cleaned_data['host_driver'].upper() != 'MYSQL': data['ziel_db'] += '\\' + form.cleaned_data['instance_name'] data['ziel_db'] += ' - ' + form.cleaned_data['db_name'] if 'dev' in form.cleaned_data['server']: data['umgebung_dev'] = form.cleaned_data['u_name'] self.umgebung_anlegen(self.conf['dba']['lde']['dev'], 545, form) if 'beta' in form.cleaned_data['server']: data['umgebung_beta'] = form.cleaned_data['u_name'] self.umgebung_anlegen(self.conf['dba']['lde']['beta'], 472, form) if 'release' in form.cleaned_data['server']: data['umgebung_release'] = form.cleaned_data['u_name'] self.umgebung_anlegen(self.conf['dba']['lde']['release'], 203, form) data['createuser'] = ldap_user data['createtime'] = int(datetime.now().timestamp()) data['geplante_vern_am'] = int( datetime.now().timestamp()) + (14 * 86400) data['tatsaechliche_vern_am'] = 0 data['rueckmeldung_kunde_am'] = 0 data['ruecksendung_am'] = 0 data['bereitgestellt_am'] = int(datetime.now().timestamp()) id = mysql.write_data_single(dbt, 'Datenbank', data) # DBT Historie Eintrag hist = {} hist['kunde'] = form.cleaned_data['kunden'] hist['datenbank'] = id hist['alt'] = '' hist['neu'] = '' hist['aenderungsgrund'] = 'Neuanlage' hist['zusammenfassung'] = '' hist['benutzer'] = ldap_user hist['aenderungszeit'] = int(datetime.now().timestamp()) mysql.write_data_single(dbt, 'Historie', hist) self.import_db(form.cleaned_data) self.success_url += '/' + str(id) #return return super(NewDBView, self).form_valid(form) def umgebung_anlegen(self, db_file_name, id, form): lde_db = sqlite.create(db_file_name) print(repr(form.cleaned_data['u_name'].encode('cp1252'))) umgebung = sqlite.write_data_single(lde_db, 'umgebung', { 'umgebungs_name': form.cleaned_data['u_name'].encode('iso-8859-15') }) db = sqlite.query(lde_db, 'copy', [umgebung, id], commit=True) if form.cleaned_data['host_driver'].upper() == 'MYSQL': update = {'conf_value': form.cleaned_data['host_name']} elif form.cleaned_data['host_driver'].upper() == 'ORACLE': update = { 'conf_value': form.cleaned_data['host_name'] + '/' + form.cleaned_data['instance_name'] } else: update = { 'conf_value': form.cleaned_data['host_name'] + '\\' + form.cleaned_data['instance_name'] } sqlite.update(lde_db, 'lde_conf', { 'ind_umgebung': umgebung, 'conf_int_name': 'tmp_db_host' }, update) update = {'conf_value': form.cleaned_data['db_name']} sqlite.update(lde_db, 'lde_conf', { 'ind_umgebung': umgebung, 'conf_int_name': 'tablespace' }, update) update = {'conf_value': form.cleaned_data['host_driver'].upper()} sqlite.update(lde_db, 'lde_conf', { 'ind_umgebung': umgebung, 'conf_int_name': 'tmp_database_type' }, update) if form.cleaned_data['host_driver'].upper() == 'ORACLE': update = {'conf_value': form.cleaned_data['db_name'].lower()} sqlite.update(lde_db, 'lde_conf', { 'ind_umgebung': umgebung, 'conf_int_name': 'db_user' }, update) if form.cleaned_data['host_driver'].upper() == 'MYSQL': update = {'conf_value': 'root'} sqlite.update(lde_db, 'lde_conf', { 'ind_umgebung': umgebung, 'conf_int_name': 'db_user' }, update) update = { 'conf_value': form.cleaned_data['kunden_name'].lower().replace( 'ü', 'ue').replace('ä', 'ae').replace('ö', 'oe') } sqlite.update(lde_db, 'lde_conf', { 'ind_umgebung': umgebung, 'conf_int_name': 'kassenSchnittstelle' }, update) update = { 'conf_value': 'L:\\Dokumente\\_'.encode('iso-8859-15') + form.cleaned_data['kunden_name'].lower().encode('iso-8859-15') + '\\'.encode('iso-8859-15') } sqlite.update(lde_db, 'lde_conf', { 'ind_umgebung': umgebung, 'conf_int_name': 'dok_dir_client' }, update) def import_db(self, data): #asyncio.set_event_loop_policy(asyncio.WindowsSelectorEventLoopPolicy()) dblist = DbListApp(self.conf) dblist.host_name = data['host_name'] dblist.driver = data['host_driver'] dblist.instance_name = data['instance_name'] connection = dblist.get_db_connection() data['filename'] = data['quellen'].split('\\')[-1] dblist.db.import_db(connection, data) #asyncio.set_event_loop_policy(asyncio.WindowsProactorEventLoopPolicy()) def form_invalid(self, form): return super(NewDBView, self).form_invalid(form) def get_initial(self): initial = super(NewDBView, self).get_initial() initial.update(get_default_data()) initial['seite'] = 'Neue Datenbank' host_name = self.kwargs['host'] initial['instance_name'] = self.kwargs['instance'] #initial['form'] = self.form_class(self.kwargs) initial['backlink'] = '/dba/' initial['host_driver'] = [ x for x in self.conf['dba']['database']['hosts'] if host_name in x.values() ][0]['driver'] initial['host_name'] = [ x for x in self.conf['dba']['database']['hosts'] if host_name in x.values() ][0]['fqdn'] return initial def get_context_data(self, **kwargs): context = super().get_context_data(**kwargs) context.update(get_default_data()) context['seite'] = 'Neue Datenbank' host_name = self.kwargs['host'] context['instance_name'] = self.kwargs['instance'] #context['form'] = self.form_class(self.kwargs) context['backlink'] = '/dba/' context['host_driver'] = [ x for x in self.conf['dba']['database']['hosts'] if host_name in x.values() ][0]['driver'] context['host_name'] = [ x for x in self.conf['dba']['database']['hosts'] if host_name in x.values() ][0]['fqdn'] return context
class NewDbForm(forms.Form): conf = config(settings.DBA_CONFIG_FILE) db_name = forms.CharField(label='Datenbankname') u_name = forms.CharField(label='Umgebung') server = forms.MultipleChoiceField(label='Server', choices=[('dev', 'DEV'), ('beta', 'BETA'), ('release', 'RELEASE')], widget=forms.CheckboxSelectMultiple) kunden = forms.ChoiceField(label='Kunden') quellen = forms.ChoiceField(label='Quellen', widget=forms.RadioSelect) passwort = forms.CharField(label='Passwort zum Entpacken', required=False) host_name = forms.CharField(widget=forms.HiddenInput()) instance_name = forms.CharField(widget=forms.HiddenInput()) kunden_name = forms.CharField(widget=forms.HiddenInput()) host_driver = forms.CharField(widget=forms.HiddenInput()) def __init__(self, *args, **kwargs): super(NewDbForm, self).__init__(*args, **kwargs) dbt = general.connect_dbt(self.conf) kunden = mysql.query(dbt, 'get_kunden') k = [(0, 'Bitte auswählen')] for kunde in kunden: k.append((kunde[0], kunde[1])) self.fields['kunden'].choices = k filenames = [] instance = '' if 'initial' in kwargs: instance = kwargs['initial']['instance_name'] if len(args) > 0: instance = args[0]['instance'] driver = kwargs['initial']['host_driver'] dump_path = self.conf['dba']['dump'][driver] if driver == 'MSSQL': dump_path += instance + '\\' for root, d_names, f_names in os.walk(dump_path): for f in f_names: if f.split('.')[-1] in ['bak', 'sql', 'dmp']: fname = os.path.join(root, f).replace('/', '\\') filenames.append((fname, fname)) self.fields['quellen'].choices = filenames self.helper = FormHelper self.helper.form_method = 'post' self.helper.form_style = 'inline' self.helper.label_class = 'left' self.helper.field_class = 'left' self.helper.field_template = 'field.html' self.helper.use_custom_control = True self.helper.layout = Layout( Fieldset( 'Informationen', 'db_name', 'u_name', 'server', 'kunden', 'passwort', 'quellen', 'host_name', 'instance_name', 'kunden_name', 'host_driver', ), ButtonHolder(Submit('submit', 'Senden')))
class DbListView(generic.FormView): template_name = 'dba/index.html' conf = config(settings.DBA_CONFIG_FILE) seite = 'Übersicht' def get(self, request, *args, **kwargs): if not request.user.is_authenticated: settings.LOGIN_REDIRECT_URL = '/dba' return redirect('login') dblist = DbListApp(self.conf) host_list = dblist.get_hosts() context = get_default_data() context['seite'] = self.seite context['host_list'] = host_list return render(request, self.template_name, context) def post(self, request, *args, **kwargs): if not request.user.is_authenticated: print('user error') settings.LOGIN_REDIRECT_URL = '/dba' return redirect('login') print(request.POST) dblist = DbListApp(self.conf) host = request.POST.get('hosts') instance = request.POST.get('instances') host_list = dblist.get_hosts(host) context = get_default_data() context['host_list'] = host_list context['host_name'] = dblist.host_name context['instance_list'] = dblist.get_instance_list(host, instance) context['instance_name'] = dblist.instance_name if dblist.host_name is None: return render(request, self.template_name, context) show_list = True if (request.POST.get('drop')): if dblist.instance_name is None: instance_name = 'mysql' protected = ProtectedDbList.objects.filter( server=dblist.fqdn, instance=instance_name, db_name=request.POST.get('db_name')) if len(protected) < 1: print('delete ' + request.POST.get('db_name')) connection = dblist.get_db_connection() dblist.db.drop(connection, request.POST.get('db_name')) else: print('can not delete ' + request.POST.get('db_name')) show_list = True if (request.POST.get('remove_env')): dev_id = request.POST.get('devid') beta_id = request.POST.get('betaid') release_id = request.POST.get('releaseid') envid = request.POST.get('envid') envserver = request.POST.get('envserver') if dev_id and beta_id and release_id: if dev_id > 0: general.umgebung_loeschen(self.conf, 'dev', dev_id) if beta_id > 0: general.umgebung_loeschen(self.conf, 'beta', beta_id) if release_id > 0: general.umgebung_loeschen(self.conf, 'release', release_id) if envid and envserver: general.umgebung_loeschen(self.conf, envserver, envid) show_list = True if (request.POST.get('shrink')): connection = dblist.get_db_connection() dblist.db.query(connection, 'shrink', request.POST.get('db_name')) show_list = True if (request.POST.get('simple')): connection = dblist.get_db_connection() dblist.db.query_format(connection, 'simple', request.POST.get('db_name')) show_list = True if (request.POST.get('protect') == 'Sperren / Entsperren'): instance_name = dblist.instance_name if dblist.instance_name is None: instance_name = 'mysql' protected = ProtectedDbList.objects.filter( server=dblist.fqdn, instance=instance_name, db_name=request.POST.get('db_name'), user=request.user) if len(protected) == 0: # protect it print("protect db") request.method = 'GET' instance_name = dblist.instance_name if dblist.instance_name is None: instance_name = 'mysql' initial = { 'server': dblist.fqdn, 'instance': instance_name, 'db_name': request.POST.get('db_name'), 'user': request.user } request.POST = initial return ProtectView.as_view(form_class=ProtectForm)(request) elif len(protected) == 1: protected.delete() else: # something wrong print("more than one") protected.delete() if (request.POST.get('suchen') == 'Suchen' or show_list): context['seite'] = self.seite zeug = self.suchen(dblist) context['db_list'] = zeug[0] context['env_list'] = zeug[1] context['db_driver'] = dblist.driver return render(request, self.template_name, context) def suchen(self, dblist): dev = general.umgebungen_laden(self.conf, 'dev', dblist.host_name, dblist.instance_name) beta = general.umgebungen_laden(self.conf, 'beta', dblist.host_name, dblist.instance_name) release = general.umgebungen_laden(self.conf, 'release', dblist.host_name, dblist.instance_name) dbt = general.connect_dbt(self.conf) vernichten = general.load_dbt(dbt) db_tuples = dblist.get_db_list() db_list = [] found_dev = [] found_beta = [] found_release = [] for db in db_tuples: items = {} info = general.find_in_dbt(vernichten, dblist.instance_name, db[0]) env_dev = general.umgebung_suchen(dev, db[0]) env_beta = general.umgebung_suchen(beta, db[0]) env_release = general.umgebung_suchen(release, db[0]) items['umgebung'] = 'DEV: ' + env_dev[0][0] items['umgebung'] += "\r\n" + 'BETA: ' + env_beta[0][0] items['umgebung'] += "\r\n" + 'RELEASE: ' + env_release[0][0] items['devid'] = env_dev[0][1] for env in env_dev: found_dev.append(env[1]) items['betaid'] = env_beta[0][1] for env in env_beta: found_beta.append(env[1]) items['releaseid'] = env_release[0][1] for env in env_release: found_release.append(env[1]) items['name'] = db[0] items['size'] = db[1] items['log'] = db[2] items['sum'] = db[3] items['add'] = db[4] protected = None if dblist.instance_name is None: protected = ProtectedDbList.objects.filter(server=dblist.fqdn, instance='mysql', db_name=db[0]) else: protected = ProtectedDbList.objects.filter( server=dblist.fqdn, instance=dblist.instance_name, db_name=db[0]) #items['p_user'] = protected[0].user #items['p_reason'] = protected[0].reason if len(protected) > 0: items['p_user'] = protected[0].user items['p_reason'] = protected[0].reason items['p_count'] = len(protected) if info: if info[0] is None: items['delete'] = date.fromtimestamp(0) else: items['delete'] = date.fromtimestamp(info[0]) items['dbtid'] = info[2] items['delta'] = (items['delete'] - date.today()).days else: items['delete'] = 'nicht gefunden' items['delta'] = -9000 db_list.append(items) unused = [] for env in dev: if env[2] not in found_dev: i = { 'name': env[1].decode("cp1252"), 'id': env[2], 'server': 'dev' } unused.append(i) for env in beta: if env[2] not in found_beta: i = { 'name': env[1].decode("cp1252"), 'id': env[2], 'server': 'beta' } unused.append(i) for env in release: if env[2] not in found_release: i = { 'name': env[1].decode("cp1252"), 'id': env[2], 'server': 'release' } unused.append(i) return (db_list, unused)
# 无限循环 def loop(device): while True: user_answer = input("是否需要截图 y/n:\n") if user_answer == 'y': shot.screen_shot(adb, device, config.save_path, config.delete_shot) elif user_answer == 'n': exit(0) else: print("y无法识别你的答案,请重新输入!") pass if __name__ == '__main__': # 获取配置 config = config() # 对adb进行初始化 adb = adb() # 获取当前连接了多少台设备 count = len(adb.get_devices()) shot = screen_shot() if 0 < count <= 1: # 取第一个设备 loop(adb.get_devices()[0]) pass # 有多个设备的时候 else: illegal = True
def get_info(email, password): firebase = config() auth = firebase.auth() user = auth.get_account_info(email, password) return user
def test_init(self): #Initialization logging.basicConfig(level=logging.INFO, format='%(asctime)s - %(name)s - %(levelname)s - %(message)s') logger = logging.getLogger() conf = config(os.path.abspath(__file__ + "/../../test/config_test.yaml")) conf.mode = 'COLD' obj = db_client(logger, conf) if os.path.isfile(obj.db_file): os.remove(obj.db_file) self.assertTrue(obj.init()) ######################################################################## # Channels # Check if table is created obj.cursor.execute('''delete from %s where 1 = 1''' % obj.channels_table_name) channel_record = channel(channel_id=7, source_id=10, source_chat_id='123456', target_id=15, target_chat_id='654321', public=1, type=1) obj.insert(obj.channels_table_name, channel_record.str()) # Check if the row is inserted row = obj.selectone(obj.channels_table_name, "*") channel_record_from_row = channel.from_channel_record(row, False) self.assertEqual(channel_record_from_row.date, channel_record.date) self.assertEqual(channel_record_from_row.time, channel_record.time) self.assertEqual(channel_record_from_row.channel_id, channel_record.channel_id) self.assertEqual(channel_record_from_row.source_id, channel_record.source_id) self.assertEqual(channel_record_from_row.source_chat_id, channel_record.source_chat_id) self.assertEqual(channel_record_from_row.target_id, channel_record.target_id) self.assertEqual(channel_record_from_row.target_chat_id, channel_record.target_chat_id) self.assertEqual(channel_record_from_row.public, channel_record.public) self.assertEqual(channel_record_from_row.type, channel_record.type) # Update the row channel_record.public = 0 channel_record.type = 0 obj.insert_or_replace(obj.channels_table_name, channel_record.str()) # Check if the row is inserted row = obj.selectone(obj.channels_table_name, "*") channel_record_from_row = channel.from_channel_record(row, False) self.assertEqual(channel_record_from_row.channel_id, channel_record.channel_id) self.assertEqual(channel_record_from_row.source_id, channel_record.source_id) self.assertEqual(channel_record_from_row.source_chat_id, channel_record.source_chat_id) self.assertEqual(channel_record_from_row.target_id, channel_record.target_id) self.assertEqual(channel_record_from_row.target_chat_id, channel_record.target_chat_id) self.assertEqual(channel_record_from_row.public, channel_record.public) self.assertEqual(channel_record_from_row.type, channel_record.type) row = obj.selectone(obj.channels_table_name, "*", "targetchatid='654321' and sourceid=10") channel_record_from_row = channel.from_channel_record(row, False) self.assertEqual(channel_record_from_row.channel_id, channel_record.channel_id) self.assertEqual(channel_record_from_row.source_id, channel_record.source_id) self.assertEqual(channel_record_from_row.source_chat_id, channel_record.source_chat_id) self.assertEqual(channel_record_from_row.target_id, channel_record.target_id) self.assertEqual(channel_record_from_row.target_chat_id, channel_record.target_chat_id) self.assertEqual(channel_record_from_row.public, channel_record.public) self.assertEqual(channel_record_from_row.type, channel_record.type) ######################################################################## # User_states # Check if table is created obj.cursor.execute('''delete from %s where 1 = 1''' % obj.user_states_table_name) user_state_record = user_state(chat_id='1234', state=user_state.states.START, last_target_id=123, last_msg_id=456) obj.insert(obj.user_states_table_name, user_state_record.str()) # Check if the row is inserted row = obj.selectone(obj.user_states_table_name, "*") user_state_record_from_row = user_state.from_user_state_record(row, False) self.assertEqual(user_state_record_from_row.date, user_state_record.date) self.assertEqual(user_state_record_from_row.time, user_state_record.time) self.assertEqual(user_state_record_from_row.chat_id, user_state_record.chat_id) self.assertEqual(user_state_record_from_row.state, user_state_record.state) self.assertEqual(user_state_record_from_row.last_target_id, user_state_record.last_target_id) self.assertEqual(user_state_record_from_row.last_msg_id, user_state_record.last_msg_id) ######################################################################## # Messages # Check if table is created obj.cursor.execute('''delete from %s where 1 = 1''' % obj.messages_table_name) message_record = message(msg_id=50, channel_id=30, source_id=29, source_chat_id='111111', msg='Hello world') obj.insert(obj.messages_table_name, message_record.str()) # Check if the row is inserted row = obj.selectone(obj.messages_table_name, "*") message_record_from_row = message.from_message_record(row, False) self.assertEqual(message_record_from_row.date, message_record.date) self.assertEqual(message_record_from_row.time, message_record.time) self.assertEqual(message_record_from_row.msg_id, message_record.msg_id) self.assertEqual(message_record_from_row.channel_id, message_record.channel_id) self.assertEqual(message_record_from_row.source_id, message_record.source_id) self.assertEqual(message_record_from_row.source_chat_id, message_record.source_chat_id) self.assertEqual(message_record_from_row.msg, message_record.msg) ######################################################################## # Contaccts # Check if table is created obj.cursor.execute('''delete from %s where 1 = 1''' % obj.contacts_table_name) contact_record = contact(chat_id='123456', phone_number='21223422', first_name='David', last_name='Jones') obj.insert(obj.contacts_table_name, contact_record.str()) # Check if the row is inserted row = obj.selectone(obj.contacts_table_name, "*") contact_record_from_row = contact.from_contact_record(row, False) self.assertEqual(contact_record_from_row.date, contact_record.date) self.assertEqual(contact_record_from_row.time, contact_record.time) self.assertEqual(contact_record_from_row.chat_id, contact_record.chat_id) self.assertEqual(contact_record_from_row.phone_number, contact_record.phone_number) self.assertEqual(contact_record_from_row.first_name, contact_record.first_name) self.assertEqual(contact_record_from_row.last_name, contact_record.last_name) # Close the connection obj.close() # Remove the file os.remove(obj.db_file)
def inject(confFile="confFiles/sample.yaml", **kwargs): fiConf = config.config(confFile) fiFunc = globals()[fiConf["Type"]] return fiFunc(fiConf, **kwargs)
import urllib2, json, math import src.config as conf GEOIP_API = "http://www.telize.com/geoip/" replicas = conf.config().replica_map def get_location(ip_address): try: response = urllib2.urlopen(GEOIP_API + ip_address) blob = json.load(response) return blob except urllib2.HTTPError as e: print "Failed to get location, I am sorry master" return False def get_lat_long(ip_address): ip_response = get_location(ip_address) if ip_response: try: latip, lngip = (ip_response['latitude'], ip_response['longitude']) return (latip, lngip) except: print "Failed to get latitude, longitude from response" return False def get_closest(ip_address): latip, lngip = (None, None) llpair = get_lat_long(ip_address) if llpair: latip, lngip = llpair
import cv2 import numpy as np from src import config parser = config.config() kernel = np.ones((3, 3), np.uint8) MIN_BALL_AREA = parser.get("Params", "min_ball_area") MIN_BASKET_AREA = parser.get("Params", "min_basket_area") # Basket laius, kaugus W = 16 F = (59 * 151) / W filters = { 'Ball': { "min": parser.get("Ball", "min"), "max": parser.get("Ball", "max") }, 'blue': { "min": parser.get("BasketBlue", "min"), "max": parser.get("BasketBlue", "max") }, 'magenta': { "min": parser.get("BasketMagenta", "min"), "max": parser.get("BasketMagenta", "max") }, 'black': { "min": parser.get("BlackLines", "min"), "max": parser.get("BlackLines", "max") },
import urllib2, json, math import src.config as conf GEOIP_API = "http://www.telize.com/geoip/" replicas = conf.config().replica_map def get_location(ip_address): try: response = urllib2.urlopen(GEOIP_API + ip_address) blob = json.load(response) return blob except urllib2.HTTPError as e: print "Failed to get location, I am sorry master" return False def get_lat_long(ip_address): ip_response = get_location(ip_address) if ip_response: try: latip, lngip = (ip_response['latitude'], ip_response['longitude']) return (latip, lngip) except: print "Failed to get latitude, longitude from response" return False def get_closest(ip_address): latip, lngip = (None, None) llpair = get_lat_long(ip_address)
def main(): # Class define state = RobotState() parser = config.config() robot = serialCom() image_thread = vision.imageCapRS2() # Socket Conn conn = websocket.create_connection('ws://192.168.2.66:9090/') ws = Referee(conn) # Params distances = [] teamColor = "magenta" basketxs = [] finaldistance = 0 throwing = False counter = 0 temp_dist_centerX = 0 middle_px = parser.get('Cam', 'Width') / 2 # PID toBallSpeed = PID(0.015, 0.00001, 0, setpoint=460) # P=0.4 oli varem toBallSpeed.output_limits = (15, 75) # Motor limits toBallSpeed.sample_time = 0.01 basketCenterSpeed = PID(0.06, 0.00001, 0.003, setpoint=310) # 0.1, 0.000001, 0.001 basketCenterSpeed.output_limits = (-5, 5) # Motor limits basketCenterSpeed.sample_time = 0.01 while True: if ws.go: # True teamColor = ws.basketColor frame = image_thread.getFrame() if state.current is STATE.EMPTYING: if robot.recive.ir == 1: robot.setIr(1) robot.startThrow(100) robot.setServo(100) else: if state.timer_ms_passed() > 0.5: robot.setIr(0) state.change_state(STATE.WAITING) elif state.current is STATE.WAITING: # waiting robot.setIr(0) robot.setServo(0) robot.stopThrow() state.change_state(STATE.FINDING_BALL) # elif state.current is STATE.FINDING_BALL: imageProcessing.detectLine(frame) ballCnts = imageProcessing.getContours(frame) if len(ballCnts) > 0: ball_x, ball_y = imageProcessing.detectObj(frame, ballCnts) if ball_y > 415 and 310 < ball_x < 330: # 30 - 60 parser.get('Cam', 'Height') - 65 print('found ball') state.change_state(STATE.PICKING_UP_BALL) else: speed = max(50 - int(ball_y / 5), 20) robot.omniMovement(speed, middle_px, ball_x, ball_y) else: robot.left(10) # elif state.current is STATE.PICKING_UP_BALL: # picking up ball robot.forward(10) if state.timer_seconds_passed() > 1: robot.stopMoving() robot.setIr(0) robot.setServo(50) if state.timer_seconds_passed() > 8: robot.setServo(-100) # eject state.change_state( STATE.FINDING_BALL) # ball disappeared, restart elif robot.recive.ir == 1: state.change_state(STATE.FINDING_BASKET) pass # elif state.current is STATE.FINDING_BASKET: # finding basket # to add if basket too close go back a little basketCnts = imageProcessing.getBasketContours( frame, teamColor) if len(basketCnts) > 0: target_x, target_y, w, h = imageProcessing.detectObj( frame, basketCnts, False) basketCenteX, basketY = target_x + w / 2, target_y + h distance = imageProcessing.calc_distance(w) if len(distances) > 5: distances.pop(0) distances.append(distance) finaldistance = sum(distances) / len(distances) else: distances.append(distance) dist_from_centerX = 320 if target_x > -1: dist_from_centerX = middle_px - basketCenteX basketxs.append(dist_from_centerX) print("dist_from_centerX", dist_from_centerX) if 0 < dist_from_centerX < 30: if (int(dist_from_centerX) == int(temp_dist_centerX) ) and (dist_from_centerX != 320): counter += 1 else: temp_dist_centerX = dist_from_centerX counter = 0 else: print(-basketCenterSpeed(basketCenteX)) robot.rotate(-basketCenterSpeed(basketCenteX)) if finaldistance > 130: speed = max(50 - int(basketY / 5), 20) robot.omniMovement(speed, middle_px, basketCenteX, basketY) elif 0 < finaldistance < 60: robot.reverse(10) else: if counter > 3 or state.timer_seconds_passed() > 15: robot.stopMoving() state.change_state(STATE.DRIVING_TO_BASKET) counter = 0 else: robot.left(12) # elif state.current is STATE.DRIVING_TO_BASKET: # driving to basket if state.timer_ms_passed() > 0.5: state.current = STATE.STARTING_THROWER # elif state.current is STATE.STARTING_THROWER: # starting thrower # 0.180854 ja 14.205 oli varem throwSpeed = -0.000161064 * finaldistance**2 + 0.181854 * finaldistance + 15.205 robot.startThrow(throwSpeed) if state.timer_ms_passed() > 0.5: state.change_state(STATE.THROWING_BALL) # elif state.current is STATE.THROWING_BALL: # throwing ball robot.setIr(1) if state.timer_seconds_passed() + state.timer_ms_passed( ) > 1.5: robot.setIr(0) robot.setServo(0) robot.startThrow(0) state.change_state(STATE.FINDING_BALL) # else: raise Exception( f'State not implemented in main(): {state.current}') pass cv2.putText(frame, str(state.current), (10, 30), cv2.FONT_HERSHEY_DUPLEX, 1, cv2.COLOR_YUV420sp2GRAY) cv2.imshow('Processed', frame) k = cv2.waitKey(1) & 0xFF if k == ord("q"): break else: robot.stopMoving() state.change_state(STATE.EMPTYING) image_thread.setStopped(False) robot.stopThrow() robot.setStopped(False) cv2.destroyAllWindows()
document_dict["ner"].append( [denotation_to_idx[d_id] for d_id in sent_to_denotation[sent]]) document_dict['relations'].append(relation_list) return document_dict def batch_json_to_pure(json_file_path: str, save_file: str): json_file_list = os.listdir(json_file_path) wf = open(save_file, 'w', encoding='utf-8') for file_name in json_file_list: json_file = os.path.join(json_file_path, file_name) document_dict = json_to_pure(json_file) wf.write(f'{str(document_dict)}\n') wf.close() print(f'{save_file} save done.') if __name__ == '__main__': # json_file = '../data/AGAC_training/json/PubMed-18594199.json' from src.config import config args = config() # document_dict = json_to_pure(json_file) batch_json_to_pure(args.train_json_path, args.pure_train_file) batch_json_to_pure(args.test_json_path, args.pure_test_file)