def clear_db(): ''' Obsługa kliknięcia "Estimate vocabulary size". Szacuje liczbę słów znaną przez użytkownika. :return: None ''' ans = messagebox.askyesno( "", "Are you sure you want to clear info about user?") if ans: DATABASE.clear()
def easy_clicked(): ''' Obsługa kliknięcia w przycisk "Easy". :return: None ''' if 0 <= INDEX < LEN: word = WORDS[INDEX] DATABASE.modify_word(word, FREQLIST.rank(word), True, True) next_word()
def hard_clicked(): ''' Obsługa kliknięcia w przycisk "Hard". :return: None ''' if 0 <= INDEX < LEN: word = WORDS[INDEX] DATABASE.modify_word(word, FREQLIST.rank(word), False, False) if TO_LEARN and DICT.correct(word) is not None: WORDS_TO_LEARN.append(word) next_word()
def create_app(): app = Flask(__name__) app.config['SECRET_KEY'] = secrets.token_urlsafe(64) app.config['SQLALCHEMY_DATABASE_URI'] = 'sqlite:///.database/trello.db' app.config['SQLALCHEMY_TRACK_MODIFICATIONS'] = False DATABASE.app = app DATABASE.init_app(app) login_manager.init_app(app) with app.test_request_context(): DATABASE.create_all() return app
def main(): GPIO.cleanup() GPIO.setmode(GPIO.BCM) #Relais als Ausgang schalten GPIO.setup(RELAIS, GPIO.OUT) #Eimersensor als Eingang schalten GPIO.setup(SENSOR_BUCKET_PIN,GPIO.IN) #Datenbank initialisieren db = DATABASE() # Aktuelle Luftfeuchtigkeit holen humidity = db.getLatestHumidity() # Checken ob Wasser im Eimer ist if isBucketEmpty(): db.saveBucketEmpty() else: db.saveStatus("OK") # Giessen wenn Luftfeuchtigkeit unter 90 % if humidity < HUMIDITY_LIMIT: db.saveWatering(WATERING_TIME) GPIO.output(RELAIS, GPIO.HIGH) time.sleep(WATERING_TIME) GPIO.output(RELAIS, GPIO.LOW) else: GPIO.output(RELAIS, GPIO.LOW)
def next_word(): ''' Pokazuje następne słowo do nauczenia. :return: None ''' global UTILITY_FUNC, PR, INDEX, LEN, WORDS, TO_LEARN, WORDS_TO_LEARN INDEX += 1 if INDEX < LEN: word = WORDS[INDEX] corr = DICT.correct(word) if corr is None: corr = word WORD_STR.set(corr) STAT_STR.set("%d/%d" % (INDEX + 1, LEN)) WORDINFO_STR.set("rank = %d, p = %f, frequency = %f, value = %f" % (FREQLIST.rank(word), PR(word), FREQLIST.freq(word), UTILITY_FUNC(word))) else: WORD_STR.set('') STAT_STR.set('') WORDINFO_STR.set('') filemenu.entryconfig("Open", state="normal") filemenu.entryconfig("Test vocabulary", state="normal") filemenu.entryconfig("Clear info about user", state="normal") filemenu.entryconfig("Estimate vocabulary size", state="normal") btn_easy['state'] = 'disabled' btn_hard['state'] = 'disabled' if WORDS_TO_LEARN: homedir = expanduser("~") initialfile = datetime.datetime.now().strftime( "%d-%m-%y %H-%M") + '.apkg' filename = asksaveasfilename( initialfile=initialfile, initialdir=homedir + "/Desktop", title="Save APKG file", filetypes=(("Anki files", "*.apkg"), ), defaultextension='.apkg', ) if filename: card.write_apkg(WORDS_TO_LEARN, filename) for word in WORDS_TO_LEARN: DATABASE.modify_word(word, FREQLIST.rank(word), False, True) elif TO_LEARN: messagebox.showinfo("", "All words are known.")
def save_card(bot, update, user_data): card_number = update.message.text check_card = re.match(r'\d{10,20}', card_number) message = 'Ок, карта {} сохранена 👌'.format(card_number) if check_card is None: message = 'Введен неверный номер карты 😞' from_user = update.message.from_user user_id = str(from_user['id']) try: with DATABASE.atomic(): user = User.get(User.user_id == user_id) check_sum = user_id + card_number card = Card.create(card_number=card_number, user=user, check_sum=check_sum) card.save() except IntegrityError: message = 'Пользователь c такой картой уже существует 😞' except DoesNotExist: user = User.create(user_id=user_id, first_name=from_user['first_name'], last_name=from_user['last_name']) user.save() update.message.reply_text(message) return cancel(None, update, None)
class Members(db.Model): __tablename__ = "members" id = db.Column(db.Integer, primary_key=True) table_id = db.Column(db.Integer, db.ForeignKey('tables.id'), nullable=False) user_id = db.Column(db.Text, db.ForeignKey('users.email'), nullable=False) # Can be either 'creator', 'admin', 'editor' or 'visitor' role = db.Column(db.String(20), nullable=False) def get_table_id(self): return self.table_id def get_member_id(self): return self.user_id def get_member_role(self): return self.role def set_member_role(self, role): self.role = role def to_dict(self): return { 'id': self.id, 'table_id': self.table_id, 'member_email': self.user_id, 'member_role': self.role, }
def __init__(self, reduced_database_source="bar", reduced_collection_source="raw_vector01_redu", folder_contains_imgs="/data/bar03/screenshot01/", traind_ipca_model_path="/data/bar03/ipcav08.pkl", index_to_name_file="/data/bar03/moive_name_list_new.txt"): reduced_database = DATABASE() reduced_database.database_chose(reduced_database_source) reduced_database.collection_chose(reduced_collection_source) data_from_database = reduced_database.get_data().astype("float32") self.compare_data = data_from_database[:, :-2] self.compare_target = data_from_database[:, -2:] self.folder_contains_imgs = folder_contains_imgs self.img_path_many = self._Img_List() self.model_path_ipca = traind_ipca_model_path with open(self.model_path_ipca, 'rb') as file_id: self._Ipca_loaded = pickle.load(file_id) file = open(index_to_name_file, "r") # And for reading use lines = file.read().split() file.close() self.index_to_name = lines
class Tasks(db.Model): __tablename__ = "tasks" id = db.Column(db.Integer, primary_key=True) description = db.Column(db.Text, nullable=False) column_id = db.Column(db.Integer, db.ForeignKey('columns.id')) def get_id(self): '''Return the task's id.''' return self.id def get_description(self): '''Return the task's description.''' return self.description def to_dict(self): return {'id': self.id, 'description': self.description, 'column_id': self.column_id}
def main(): GPIO.cleanup() GPIO.setmode(GPIO.BCM) #Relais als Ausgang schalten GPIO.setup(RELAIS, GPIO.OUT) #Eimersensor als Eingang schalten GPIO.setup(SENSOR_BUCKET_PIN,GPIO.IN) #Feuchtigkeitssensor als Eingang schalten GPIO.setup(SOIL_MOSITURE_SENSOR,GPIO.OUT) # mcp Chip initialisieren mcp3008 = MCP3008() #Datenbank initialisieren db = DATABASE() ch = 0 #db.saveSoilMoisture(3) #db.saveBucketEmpty() #db.saveStatus("OK1") #sys.exit() while True: # Bodensensor Strom anschalten GPIO.output(SOIL_MOSITURE_SENSOR,GPIO.HIGH) time.sleep(3) # Bodensensor lesen #value = mcp3008.readAnalogData(ch) value = getAverangeMositure(mcp3008,ch) time.sleep(1) # Bodensensor abschalten GPIO.output(SOIL_MOSITURE_SENSOR,GPIO.LOW) # Bodenfeuchtigkeit speichern db.saveSoilMoisture(value) # Checken ob Wasser im Eimer ist if isBucketEmpty(): db.saveBucketEmpty() else: db.saveStatus("OK") # Giessen wenn Trockenheitsgrenze ueberschritten wird if value > SOIL_MOISTURE_WATERING_VALUE_MIN and value < SOIL_MOISTURE_WATERING_VALUE_MAX: db.saveWatering(WATERING_TIME) GPIO.output(RELAIS, GPIO.HIGH) time.sleep(WATERING_TIME) GPIO.output(RELAIS, GPIO.LOW) else: GPIO.output(RELAIS, GPIO.LOW) # time.sleep(1) time.sleep(TIMER_SOIL_MOISTURE)
def delete_card(bot, update, user_data): card_number = update.message.text try: with DATABASE.atomic(): card = Card.get(Card.card_number == card_number) card.delete_instance() message = 'Ок, карта {} удалена 👌'.format(card.card_number) except DoesNotExist: message = 'То, что мертво, умереть не может.' update.message.reply_text(message) return cancel(None, update, None)
def connectdb(thread=False): # Create a connection to InfluxDB if thread=True, otherwise it will create a dummy data instance global db global cp global ue_data if thread: db = DUMMY() else: ins.populatedb( ) # temporary method to populate db, it will be removed when data will be coming through KPIMON to influxDB db = DATABASE('UEData') db.read_data("liveUE") ue_data = db.data.values.tolist( ) # needs to be updated in future when live feed will be coming through KPIMON to influxDB cp = CAUSE(db)
def get_saved_cards(update): cards_keyboard = [] from_user = update.message.from_user user_id = str(from_user['id']) try: with DATABASE.atomic(): user = User.get(User.user_id == user_id) if len(user.cards) == 0: return None for card in user.cards: cards_keyboard.append([card.card_number]) cards_keyboard.append(['Отмена']) cards_markup = ReplyKeyboardMarkup(cards_keyboard, one_time_keyboard=True, resize_keyboard=True) return cards_markup except DoesNotExist: return None
def random_unknown_word(x, y, max_a): ''' Zwraca losowe nieznane użytkownikowi słowo na liście frekwencyjnej z przedziału [x, y).\n Gdy ciężko takie słowo wylosować zwracane jest jakieś zupełnie losowe słowo. :param x: lewy kraniec przedziału :param y: prawy koniec przedziału :param max_a: maksymalna ilość prób wylosowania słowa z przedziału [x, y) :return: losowe nieznane użytkownikowi słowo na liście frekwencyjnej z przedziału [x, y) ''' a = 0 word = None while max_a is None or a < max_a: rank = random.randint(x, y - 1) word = FREQLIST.word(rank) if not DATABASE.exists(word) and DICT.exists(word): break else: word = None a += 1 return word
def select(stream, db=DATABASE): ''' Zwraca listę słów posortowanych według wartości funkcji użyteczności dla podanego strumienia znakowego. :param stream: strumień znakowy :param db: baza danych zawierająca informacje o słownictwie użytkownika :return: lista słów posortowanych według wartości funkcji użyteczności ''' words = myparser.parse(stream) temp_fl = freqlist.FreqList() temp_fl.load(stream=stream) fl = freqlist.DynMixedFreqList([(freqlist.FREQLIST, 0.5), (temp_fl, 0.5)]) utility_fun = get_utility_func(db=db, fl=fl) pr = get_pr_func(db=db) mean_word = [] for word in words: if DICT.correct(word) is not None and DATABASE.known_now(word) == False: mean_word.append((utility_fun(word), word, pr(word), )) mean_word.sort(reverse=True) # print(mean_word) return [word for (_, word, _) in mean_word]
def train(thread=False): """ Main function to perform training on input data """ if thread: db = DUMMY() else: db = DATABASE('UEData') db.read_data('train') ps = PREPROCESS(db.data) ps.process() df = ps.data mod = modelling(df) mod.read_test(db) scores = [] for of in np.arange(0.01, 0.4, 0.01): scores.append(mod.isoforest(outliers_fraction=of)) opt_f1 = scores.index(max(scores)) + 1 mod.isoforest(outliers_fraction=opt_f1 * 0.01, push_model=True) print("Optimum value of contamination : {}".format(opt_f1 * 0.01)) print('Training Ends : ')
class JsonFy: def __init__(self): self.__read = DATABASE() def json_data(self, tempo_coleta): pcdData = [] data = self.__read.select_DB(horas_de_coleta=tempo_coleta) host_geradores = defaultdict(list) for row_db in data: hostname_db, data_hora_db, angulo_db, temperatura_db = row_db host_geradores[hostname_db].append({ "timestamp": datetime.timestamp(data_hora_db), "hostname": hostname_db, "temperatura_ar": temperatura_db, "angulo": angulo_db, }) return host_geradores
from database import DATABASE db = DATABASE()
# if numpy_data: # return np.array(data_list_from_db) # else: # return data_list_from_db # # def insert_data(self, d2_arrary_data, d2_target): # dimension_of_data = d2_arrary_data.shape[1] # df_data = pd.DataFrame(data=d2_arrary_data, columns=range(dimension_of_data)) # df_target = pd.DataFrame(data=d2_target, columns=["movie_name", "second"]) # data_target = df_data.join(df_target) # insert_result = self.collection.insert_many(json.loads(data_target.to_json(orient="records"))) # return insert_result # from sklearn.decomposition import PCA, IncrementalPCA data_base = DATABASE() data_base.collections_of_eachdatabase data_base.database_chose("bar") data_base.collection_chose("raw_vector01") print("data_base.collection =", data_base.collection) def Explain_Ratio(numpy_array, percentage=0.95, first=50): numpy_array = np.array(numpy_array).flatten() sum_ = 0 for index in range(len(numpy_array)): sum_ += numpy_array[index] if sum_ >= percentage: return index + 1, (index + 1) / len(numpy_array), len( numpy_array), numpy_array[:first].sum(
def atualizabanco(): dados = request.get_json() DATABASE().insert_DB(**dados) return dados
from database import DATABASE from model3 import MODEL_JPG_VECTOR if __name__ =="__main__": print(" begining ".center(60,"=")) folder_path = "/data/bar04/output" data_in_out = DATABASE() data_in_out.database_chose("bar") data_in_out.collection_chose("raw_vector02") data_to_mongod = MODEL_JPG_VECTOR(chunk=400,folder_path = folder_path,database=data_in_out,) data_to_mongod.Jpg_To_Vector_DataBase(to_database=True) # print(data_to_mongod.img_path_many.__len__()) # data = data_in_out.get_data()
from database import DATABASE import time print(DATABASE().collections_of_eachdatabase) bar = DATABASE() bar.database_chose("bar") bar.collection_chose("raw_vector01_redu") print(bar.collection.count()) print(DATABASE) # while True: # print( bar.collection.count() ) # time.sleep(60)
class Users(db.Model, flask_login.UserMixin): __tablename__ = "users" email = db.Column(db.Text, primary_key=True) username = db.Column(db.Text, nullable=False) password_hash = db.Column(db.Text, nullable=False) tables = db.relationship('Tables', backref='owner', cascade='all,delete', lazy=True) membership = db.relationship('Members', backref='membership', lazy=True) def set_password(self, password): '''Set the user's password.''' self.password_hash = generate_password_hash(password) def check_password(self, password): '''Check if the provided password and the user's password match.''' return check_password_hash(self.password_hash, password) def get_id(self): '''Return the user's email.''' return self.email def get_name(self): '''Return the user's name.''' return self.username def get_table_by_id(self, id): ''' Return corresponding table, mostly used when retrieveing a table shared with the user''' if self.membership: table, _ = self.get_tables_shared_with_me() for t in table: if t.id == id: return (t, 'Found') return (None, 'Not found') return (None, 'Not found') def get_table_by_name(self, name): '''Return the table that matches the name provided.''' table = Tables.query.filter_by(name=name, creator=self.email).first() if table: return (table, "Table '{}' found".format(name)) table = Tables.query.filter_by(name=name).first() if table and table.get_member_by_email(self.email): return (table, "Table '{}' found".format(name)) return (None, "Table '{}' not found".format(name)) def get_private_tables(self): '''Return a list of the user's private tables.''' if self.tables: table = [t for t in self.tables if not t.shared] if table: return (table, "Found") return (None, "You don't have any private table yet") return (None, "You don't have any private table yet") def get_tables_shared_with_others(self): '''Return a list of the user's shared tables.''' if self.tables: table = [t for t in self.tables if t.shared] if table: return (table, "Found") return (None, "You did not share any table yet") return (None, "You did not share any table yet") def get_tables_shared_with_me(self): '''Return a list of the tables shared with the user.''' table = [] if self.membership: for m in self.membership: t = Tables.query.filter_by(id=m.get_table_id()).first() if t and t.creator != self.email: table.append(t) if table: return (table, "Found") return (None, "No table shared with you") def add_table(self, name): '''Create a new table if it doesn't already exists.''' if name: table = Tables(name=name, creator=self.email, shared=False) if Tables.query.filter_by(name=name).first() is None: db.session.add(table) db.session.commit() return (table, "Table '{}' successfully created".format(name)) return (None, "A table with name: '{}' already exists".format(name)) return (None, "Looks like you did not give us a table name") def remove_table_by_name(self, name): '''Remove the table from the list of the user's tables.''' table = db.session.query(Tables).filter( Tables.name == name, Tables.creator == self.email).first() if table: db.session.delete(table) db.session.commit() return True return False def to_dict(self): return {'email': self.email, 'username': self.username}
import sys sys.path.insert(0, '..') import constants as c from database import DATABASE db = DATABASE() db.Print()
import numpy as np import subprocess import os # np.set_printoptions(precision=20) from database import DATABASE bar3 = DATABASE() bar3.database_chose("bar3") bar3.collection_chose("bar3") class MODEL_JPG_VECTOR(object): def __init__(self, chunk=1500, img_path_many=None, folder_path=None, database=bar3): self.database = database from keras.models import Model self._Model = Model from keras.preprocessing import image self._image = image from keras.applications.xception import Xception as key_model self._key_model = key_model from keras.applications.xception import preprocess_input, decode_predictions self._preprocess_input = preprocess_input self._decode_predictions = decode_predictions base_model_4 = key_model(weights='imagenet', include_top=False) self._base_model_4 = base_model_4
(answer.id, len(users))) sys.stdout.flush() def create_directory(directory): try: os.mkdir(directory, 0o700) except OSError as error: if error.errno != errno.EEXIST: raise if __name__ == '__main__': # Configuring Database DATABASE.connect() create_tables() parser = argparse.ArgumentParser(description='Quora Crawling Bot') parser.add_argument('-n', '--max_crawl', nargs='?', default=1000, type=int, help='Number of maximum requests to make') parser.add_argument('--no_profile', action='store_true', help='Do not Crawl Profiles') parser.add_argument('--no_answer', action='store_true', help='Do not Crawl Answers')
fstream.write(resp) sys.stdout.write('\rDone Parsing Answer id %d (%d)' % (answer.id, len(users))) sys.stdout.flush() def create_directory(directory): try: os.mkdir(directory, 0o700) except OSError as error: if error.errno != errno.EEXIST: raise if __name__ == '__main__': # Configuring Database DATABASE.connect() create_tables() parser = argparse.ArgumentParser(description = 'Quora Crawling Bot') parser.add_argument('-n', '--max_crawl', nargs='?', default=1000, type=int, help='Number of maximum requests to make') parser.add_argument('--no_profile', action='store_true', help='Do not Crawl Profiles') parser.add_argument('--no_answer', action='store_true', help='Do not Crawl Answers') args = parser.parse_args() # Filling Database with Top Writers 2016 with open('top_writers_2016.json', 'r') as fstream: writer_list = json.load(fstream) with open('other_writers.json', 'r') as fstream:
from database import DATABASE as db from flask import Flask, g from movie.models import Movie, Genre from movie.views import movies_bp tables = [Movie, Genre] db.connect() for table in tables: print(table) try: db.create_table(table) except: continue db.close() server = Flask(__name__) server.register_blueprint(movies_bp) @server.before_request def before_request(): g.db = db g.db.connect() @server.after_request def after_request(response): g.db.close()
def __init__(self): self.__read = DATABASE()
import sys sys.path.insert(0, '../database') from database import DATABASE sys.path.insert(0, '..') import constants as c import pygraphviz as pgv import networkx as nx db = DATABASE() robots = db.Get_Robots() #robots = robots[-500:] phyloTree = pgv.AGraph() # bgcolor='green') #phyloTree.add_node(-1,label="", fixedsize=False, width=1,height=1) for robot in robots: parentID = db.From_Robot_Record_Get_Parent_ID(robot) childID = db.From_Robot_Record_Get_ID(robot) numYeses = db.Get_Robot_Num_Yeses(childID) numNos = db.Get_Robot_Num_Nos(childID) numEvals = db.Get_Robot_Num_Evaluations(childID)
sys.path.insert(0, '../database') from database import DATABASE sys.path.insert(0, '../pyrosim') import pyrosim sys.path.insert(0, '../TPR_3') sys.path.insert(0, '../environments') from environment0 import ENVIRONMENT0 import constants as c import pickle database = DATABASE() filename = '../data/robot0.p' s = pyrosim.Simulator(debug=False, play_paused=False, eval_time=c.evaluationTime) e = ENVIRONMENT0(s, [0, 0, 0], [0, 0, 0], c.noFade) e.Send_To_Simulator() r = pickle.load(open(filename, 'rb')) command = c.defaultCommand
class JsonFy: def __init__(self): self.__read = DATABASE() def json_data(self, tempo_coleta): pcdData = [] data = self.__read.select_DB(horas_de_coleta=tempo_coleta) host_geradores = defaultdict(list) for row_db in data: hostname_db, data_hora_db, temperatura_ar_db, temperatura_orvalho_db, umidade_db, pressao_local_db, correnteFaseA_db, correnteFaseB_db, correnteFaseC_db, correnteNeutro_db, statusEnergia_db = row_db host_geradores[hostname_db].append({ "timestamp": datetime.timestamp(data_hora_db), "hostname": hostname_db, "temperatura_ar": temperatura_ar_db, "temperatura_orvalho": temperatura_orvalho_db, "umidade": umidade_db, "pressao_local": pressao_local_db, "corrente_Fase_A": correnteFaseA_db, "corrente_Fase_B": correnteFaseB_db, "corrente_Fase_C": correnteFaseC_db, "corrente_Neutro": correnteNeutro_db, "status_Energia": statusEnergia_db }) return host_geradores def json_minMaxMed_data(self, dias): pcdData = [] data = self.__read.min_max_med_DB(dias) host_geradores2 = defaultdict(list) for row_db in data: hostname, data_hora_db, min_temperatura, max_temperatura, med_temperatura, min_temperatura_orvalho, max_temperatura_orvalho, med_temperatura_orvalho, min_umidade, max_umidade, med_umidade, min_pressao_local, max_pressao_local, med_pressao_local, min_corrente_fase_A, max_corrente_fase_A, med_corrente_fase_A, min_corrente_fase_B, max_corrente_fase_B, med_corrente_fase_B, min_corrente_fase_C, max_corrente_fase_C, med_corrente_fase_C, min_corrente_fase_Neutro, max_corrente_fase_Neutro, med_corrente_fase_Neutro, min_status_energia, max_status_energia, med_status_energia = row_db host_geradores2[hostname].append({ "timestamp": datetime.timestamp(data_hora_db), "hostname": hostname, "temperatura_ar": float(med_temperatura), "temperatura_ar_min": float(min_temperatura), "temperatura_ar_max": float(max_temperatura), "temperatura_orvalho": float(med_temperatura_orvalho), "temperatura_orvalho_min": float(min_temperatura_orvalho), "temperatura_orvalho_max": float(max_temperatura_orvalho), "umidade": float(med_umidade), "umidade_min": float(min_umidade), "umidade_max": float(max_umidade), "pressao_local": float(med_pressao_local), "pressao_local_min": float(min_pressao_local), "pressao_local_max": float(max_pressao_local), "max_corrente_fase_A": float(max_corrente_fase_A), "med_corrente_fase_A": float(med_corrente_fase_A), "min_corrente_fase_B": float(min_corrente_fase_B), "max_corrente_fase_B": float(max_corrente_fase_B), "med_corrente_fase_B": float(med_corrente_fase_B), "min_corrente_fase_C": float(min_corrente_fase_C), "max_corrente_fase_C": float(max_corrente_fase_C), "med_corrente_fase_C": float(med_corrente_fase_C), "min_corrente_fase_Neutro": float(min_corrente_fase_Neutro), "max_corrente_fase_Neutro": float(max_corrente_fase_Neutro), "med_corrente_fase_Neutro": float(med_corrente_fase_Neutro), "min_status_energia": float(min_status_energia), "max_status_energia": float(max_status_energia), "med_status_energia": float(med_status_energia), }) return host_geradores2 def json_minMaxMedHora_data(self, horas): pcdData = [] data = self.__read.min_max_med_hora_DB(horas) host_geradores3 = defaultdict(list) for row_db in data: hostname, datadia, hora, min_temperatura, max_temperatura, med_temperatura, min_temperatura_orvalho, max_temperatura_orvalho, med_temperatura_orvalho, min_umidade, max_umidade, med_umidade, min_pressao_local, max_pressao_local, med_pressao_local, min_corrente_fase_A, max_corrente_fase_A, med_corrente_fase_A, min_corrente_fase_B, max_corrente_fase_B, med_corrente_fase_B, min_corrente_fase_C, max_corrente_fase_C, med_corrente_fase_C, min_corrente_fase_Neutro, max_corrente_fase_Neutro, med_corrente_fase_Neutro, min_status_energia, max_status_energia, med_status_energia = row_db data_hora = f'{datadia} {hora}:00:00' host_geradores3[hostname].append({ "timestamp": datetime.timestamp( datetime.strptime(data_hora, '%Y-%m-%d %H:%M:%S')), "hostname": hostname, "temperatura_ar": float(med_temperatura), "temperatura_ar_min": float(min_temperatura), "temperatura_ar_max": float(max_temperatura), "temperatura_orvalho": float(med_temperatura_orvalho), "temperatura_orvalho_min": float(min_temperatura_orvalho), "temperatura_orvalho_max": float(max_temperatura_orvalho), "umidade": float(med_umidade), "umidade_min": float(min_umidade), "umidade_max": float(max_umidade), "pressao_local": float(med_pressao_local), "pressao_local_min": float(min_pressao_local), "min_corrente_fase_A": float(min_corrente_fase_A), "pressao_local_max": float(max_pressao_local), "max_corrente_fase_A": float(max_corrente_fase_A), "med_corrente_fase_A": float(med_corrente_fase_A), "min_corrente_fase_B": float(min_corrente_fase_B), "max_corrente_fase_B": float(max_corrente_fase_B), "med_corrente_fase_B": float(med_corrente_fase_B), "min_corrente_fase_C": float(min_corrente_fase_C), "max_corrente_fase_C": float(max_corrente_fase_C), "med_corrente_fase_C": float(med_corrente_fase_C), "min_corrente_fase_Neutro": float(min_corrente_fase_Neutro), "max_corrente_fase_Neutro": float(max_corrente_fase_Neutro), "med_corrente_fase_Neutro": float(med_corrente_fase_Neutro), "min_status_energia": float(min_status_energia), "max_status_energia": float(max_status_energia), "med_status_energia": float(med_status_energia), }) return host_geradores3
from database import DATABASE import pickle import faiss import numpy as np from keras.models import Model from keras.preprocessing import image from keras.applications.xception import Xception as key_model from keras.applications.xception import preprocess_input, decode_predictions base_model_4 = key_model(weights='imagenet', include_top=False) model = Model(inputs=base_model_4.input, outputs=base_model_4.get_layer(index=-3).output) reduced_database = DATABASE() reduced_database.database_chose("bar") reduced_database.collection_chose("raw_vector01_redu") data_from_database = reduced_database.get_data(movie_name=0).astype("float32") compare_data = data_from_database[:, :-2] compare_target = data_from_database[:, -2:] img_path = "/data/bar03/screenshot01/0_160.jpg" def Jpg_To_Vector(img_path): if isinstance(img_path, list): img_path = img_path[0] img = image.load_img(img_path, target_size=(299, 299)) x = image.img_to_array(img)