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)
