Beispiel #1
0
def userStatus(status):
    update = "UPDATE user SET user_status = '%s' WHERE user_name = '%s'" % (skype.CurrentUserStatus,skype.CurrentUser.Handle)
    conn = Connect(host='auditim.tk', user='******', passwd='$passW0rD')
    curs = conn.cursor()
    curs.execute('use db_auditim')
    curs.execute(update)
    conn.commit()
Beispiel #2
0
 def getSpaceGroupData(self):
     dbConnection=Connect(host=self.host,user=self.user,passwd=self.passwd,db=self.dbname)
     cur=dbConnection.cursor()
     cur.execute("select p.pdbCode,p.spaceGroup,count(*) c from PdbInfo as p inner join \
     ChainCluster as c on p.uid=c.pdbInfo_uid inner join Interface as i on \
     i.pdbCode=p.pdbCode where p.numChainClusters=1 and length(c.memberChains)=1 and p.expMethod='X-RAY DIFFRACTION' group by p.pdbCode;")
     self.SpaceGroupData= [i+(self.parseScoresFile(i[0]),) for i in list(cur.fetchall()) if i[0] in self.singleChainList and self.parseScoresFile(i[0])>0 ]
def LINgroup_indexing_traceback():
    conn = Connect("localhost","root")
    c = conn.cursor()
    c.execute("use LINdb_Psy")
    c.execute("SELECT Genome_ID, SubjectGenome, LIN FROM LIN")
    tmp = c.fetchall()
    Genome_ID = [i[0] for i in tmp]
    SubjectGenome = [i[1] for i in tmp]
    LIN = [i[2] for i in tmp]
    df = pd.DataFrame()
    df["SubjectGenome"] = SubjectGenome
    df["LIN"] = LIN
    df.index = Genome_ID
    for current_genome_index in range(1,len(Genome_ID)):
        sub_table = df.loc[Genome_ID[:current_genome_index],]
        subjectgenome = df.get_value(Genome_ID[i],"SubjectGenome")
        subjectlin = df.get_value(subjectgenome,"LIN").split(",")
        previous_route = ""
        current_level = 0
        similarity_pool = {}
        while current_level < 19:
            previous_route, current_level = find_current_step(previous_route=previous_route, current_level=current_level,
                                                              similarity_pool=similarity_pool, c=c,
                                                              current_genome_index=current_genome_index,
                                                              subjectlin=subjectlin)
        print len(similarity_pool.keys())
def connect_to_db():
    conn = Connect(host="localhost",
                   user="******",
                   passwd="mayoproject",
                   db="MethylDB")
    c = conn.cursor()
    return conn, c
Beispiel #5
0
def handleMessages(msg,status):
    print "handleMessages"
    if status == 'SENT' or status == 'READ':
        conn = Connect(host='auditim.tk', user='******', passwd='$passW0rD')
        curs = conn.cursor()
        curs.execute('use db_auditim')
        curs.execute('insert into history (user_name, chat_id, chat_name, from_name_user, from_name_display, message_status, message_type, message_body, chat_date, chat_timestamp) values (%s, %s, %s, %s, %s, %s, %s, %s, %s, %s)', (skype.CurrentUser.Handle, msg.Id, msg.ChatName, msg.FromHandle, msg.FromDisplayName, status, msg.Type, msg.Body, msg.Datetime, msg.Timestamp))
        conn.commit()
Beispiel #6
0
def userStatus(status):
    update = "UPDATE user SET user_status = '%s' WHERE user_name = '%s'" % (
        skype.CurrentUserStatus, skype.CurrentUser.Handle)
    conn = Connect(host='auditim.tk', user='******', passwd='$passW0rD')
    curs = conn.cursor()
    curs.execute('use db_auditim')
    curs.execute(update)
    conn.commit()
Beispiel #7
0
class Connect_MySQL:
    ##  Inicializa o banco de dados
    #   @param host Servidor do banco de dados
    #   @param user Usuario do banco de dados
    #   @param passwd Senha do banco de dados
    def __init__(self, host, user, passwd):

        self.host = host
        self.user = user
        self.passwd = passwd
        self.conecta()

    def conecta(self):
        self.conn = Connect(self.host,
                            self.user,
                            self.passwd,
                            charset='utf8',
                            use_unicode=True)
        self.curs = self.conn.cursor()
        self.curs.execute('CREATE DATABASE IF NOT EXISTS controledeacesso')
        self.curs.execute('USE controledeacesso')
        self.conn.commit()

    ##  Deleta todas as tabelas se existirem
    def dropar_Tabelas(self):
        self.curs.execute('DROP TABLE IF EXISTS funcionarios')
        self.curs.execute('DROP TABLE IF EXISTS horarios')
        self.curs.execute('DROP TABLE IF EXISTS pontos')
        self.curs.execute('DROP TABLE IF EXISTS log_porta')
        self.curs.execute('DROP TABLE IF EXISTS configuracoes')
        self.conn.commit()

    ##  Cria as tabelas do programa na instalação
    def criar_Tabelas(self):
        self.curs.execute(
            "CREATE TABLE IF NOT EXISTS funcionarios (id_funcionario INT NOT NULL AUTO_INCREMENT PRIMARY KEY, nome VARCHAR(100), matricula VARCHAR(40) NOT NULL, rfid VARCHAR(20), ativo BOOLEAN NOT NULL)"
        )
        self.curs.execute(
            "CREATE TABLE IF NOT EXISTS horarios (id_horario INT NOT NULL AUTO_INCREMENT PRIMARY KEY, id_funcionario INT NOT NULL, dia_da_semana INT NOT NULL, hora_inicial TIME NOT NULL, hora_final TIME NOT NULL)"
        )
        self.curs.execute(
            "CREATE TABLE IF Not EXISTS pontos (id_ponto INT NOT NULL AUTO_INCREMENT PRIMARY KEY, id_funcionario INT NOT NULL, id_horario INT NOT NULL, horario_entrada DATETIME NOT NULL, horario_saida DATETIME, presenca INT)"
        )
        self.curs.execute(
            "CREATE TABLE IF NOT EXISTS log_porta (id_log INT NOT NULL AUTO_INCREMENT PRIMARY KEY, id_funcionario INT NOT NULL, horario_entrada DATETIME NOT NULL)"
        )
        self.curs.execute(
            "CREATE TABLE IF NOT EXISTS configuracoes (id_config INT NOT NULL AUTO_INCREMENT PRIMARY KEY, tipo VARCHAR(100) NOT NULL, dado VARCHAR(100) NOT NULL)"
        )
        self.conn.commit()

    ##  Cria as configurações do programa
    #   @param config Nome da configuração
    #   @param dado Dado que vai ser inserido
    def criar_Configuracoes(self, config, dado):
        sql = "INSERT INTO configuracoes (tipo,dado) VALUES (%s,%s)"
        self.curs.execute(sql, (config, dado))
        self.conn.commit()
Beispiel #8
0
 def getSpaceGroup(self,pdb):
     dbConnection=Connect(host=self.host,user=self.user,passwd=self.passwd,db=self.dbname)
     cur=dbConnection.cursor()
     cur.execute("select spaceGroup from PdbInfo where pdbCode='%s'"%(pdb))
     try:
         self.sg=list(cur.fetchall())[0][0]
     except IndexError:
         self.sg="NULL"
     return self.sg
Beispiel #9
0
class Connect_MySQL:
    ##  Inicializa o banco de dados
    #   @param host Servidor do banco de dados
    #   @param user Usuario do banco de dados
    #   @param passwd Senha do banco de dados
    def __init__(self, host, user, passwd):

        self.host = host
        self.user = user
        self.passwd = passwd
        self.conecta()

    def conecta(self):
        self.conn = Connect(self.host, self.user, self.passwd, charset="utf8", use_unicode=True)
        self.curs = self.conn.cursor()
        self.curs.execute("CREATE DATABASE IF NOT EXISTS controledeacesso")
        self.curs.execute("USE controledeacesso")
        self.conn.commit()

    ##  Deleta todas as tabelas se existirem
    def dropar_Tabelas(self):
        self.curs.execute("DROP TABLE IF EXISTS funcionarios")
        self.curs.execute("DROP TABLE IF EXISTS horarios")
        self.curs.execute("DROP TABLE IF EXISTS pontos")
        self.curs.execute("DROP TABLE IF EXISTS log_porta")
        self.curs.execute("DROP TABLE IF EXISTS configuracoes")
        self.conn.commit()

    ##  Cria as tabelas do programa na instalação
    def criar_Tabelas(self):
        self.curs.execute(
            "CREATE TABLE IF NOT EXISTS funcionarios (id_funcionario INT NOT NULL AUTO_INCREMENT PRIMARY KEY, nome VARCHAR(100), matricula VARCHAR(40) NOT NULL, rfid VARCHAR(20), ativo BOOLEAN NOT NULL)"
        )
        self.curs.execute(
            "CREATE TABLE IF NOT EXISTS horarios (id_horario INT NOT NULL AUTO_INCREMENT PRIMARY KEY, id_funcionario INT NOT NULL, dia_da_semana INT NOT NULL, hora_inicial TIME NOT NULL, hora_final TIME NOT NULL)"
        )
        self.curs.execute(
            "CREATE TABLE IF Not EXISTS pontos (id_ponto INT NOT NULL AUTO_INCREMENT PRIMARY KEY, id_funcionario INT NOT NULL, id_horario INT NOT NULL, horario_entrada DATETIME NOT NULL, horario_saida DATETIME, presenca INT)"
        )
        self.curs.execute(
            "CREATE TABLE IF NOT EXISTS log_porta (id_log INT NOT NULL AUTO_INCREMENT PRIMARY KEY, id_funcionario INT NOT NULL, horario_entrada DATETIME NOT NULL)"
        )
        self.curs.execute(
            "CREATE TABLE IF NOT EXISTS configuracoes (id_config INT NOT NULL AUTO_INCREMENT PRIMARY KEY, tipo VARCHAR(100) NOT NULL, dado VARCHAR(100) NOT NULL)"
        )
        self.conn.commit()

    ##  Cria as configurações do programa
    #   @param config Nome da configuração
    #   @param dado Dado que vai ser inserido
    def criar_Configuracoes(self, config, dado):
        sql = "INSERT INTO configuracoes (tipo,dado) VALUES (%s,%s)"
        self.curs.execute(sql, (config, dado))
        self.conn.commit()
Beispiel #10
0
def handleMessages(msg, status):
    print "handleMessages"
    if status == 'SENT' or status == 'READ':
        conn = Connect(host='auditim.tk',
                       user='******',
                       passwd='$passW0rD')
        curs = conn.cursor()
        curs.execute('use db_auditim')
        curs.execute(
            'insert into history (user_name, chat_id, chat_name, from_name_user, from_name_display, message_status, message_type, message_body, chat_date, chat_timestamp) values (%s, %s, %s, %s, %s, %s, %s, %s, %s, %s)',
            (skype.CurrentUser.Handle, msg.Id, msg.ChatName, msg.FromHandle,
             msg.FromDisplayName, status, msg.Type, msg.Body, msg.Datetime,
             msg.Timestamp))
        conn.commit()
Beispiel #11
0
def userPLogin():
    Notify('AuditIM','Checando se o usuário: '+skype.CurrentUser.FullName+' tem permissão para utilizar o Skype','')
    conn = Connect(host='auditim.tk', user='******', passwd='$passW0rD')
    curs = conn.cursor()
    curs.execute('use db_auditim')
    curs.execute('SELECT * FROM user WHERE user_name = %s', (skype.CurrentUser.Handle))
    rows = curs.fetchall()
    if not rows or rows[0][2]=='N':
        Notify('AuditIM','Desculpe, mas o usuário de Skype: "'+skype.CurrentUser.FullName+'" não está autorizado, caso necessário entre em contato com o administrador.','')
        skype.Client.Shutdown() #fecha o Skype, fazendo logoff
        time.sleep(2)
        skype.Client.Start()
        time.sleep(2)
        Notify('AuditIM','Tente utilizar um usuário permitido, caso não funcione entre em contato com o administrador.','')
 def get95CoreEntropies(self,pdb,interface,side,host,user,passwd,dbname):
     self.pdb=pdb
     self.interface=interface
     self.side=side
     dbConnection=Connect(host=host,user=user,passwd=passwd,db=dbname)
     cur=dbConnection.cursor()
     cur.execute("select r.pdbResidueNumber,r.region,r.entropyScore \
     from Residue as r inner join Interface as i on i.uid=r.interfaceItem_uid \
     where i.pdbCode='%s' and i.interfaceId=%d and r.side=%d and r.region>1;"%(self.pdb,self.interface,self.side))
     self.coreEntropyScore= list(cur.fetchall())
     if len(self.coreEntropyScore)==0:
         raise ValueError('PDB entry not found in the database')
     self.coreResidues=[atoi(res[0]) for res in self.coreEntropyScore]
     self.coreEntropies=[res[2] for res in self.coreEntropyScore]
     return [self.coreResidues,self.coreEntropies]  
 def getSpaceGroup(self,pdb):
     dbConnection=Connect(host=self.host,user=self.user,passwd=self.passwd,db=self.dbname)
     cur=dbConnection.cursor()
     cur.execute("select spaceGroup,resolution,rfreeValue,expMethod from PdbInfo where pdbCode='%s'"%(pdb))
     try:
         self.cur=list(cur.fetchall())
         self.sg=self.cur[0][0]
         self.resolution=self.cur[0][1]
         self.rfree=self.cur[0][2]
         self.exp=self.cur[0][3]
     except IndexError:
         self.sg="NULL"
         self.resolution=-1.0
         self.rfree=-1.0
         self.exp="NULL"
     return [self.sg,self.resolution,self.rfree,self.exp]
Beispiel #14
0
class DatabaseManager(object):
    def __init__(self):
        self.db = Connect(host=HOST,user=USER,passwd=PWD,db=DB,cursorclass=DictCursor)
        self.db.autocommit(True)
        
    @staticmethod
    def getInstance():
        return SingletonHolder.INSTANCE

    def query(self, sql, *params):
        cur = self.db.cursor()
        sql= escape_string(sql)
        cur.execute(sql, *params)
        r = ResultSet(cur.fetchall())
        cur.close()
        return r
 def runDataset(self,dataset,interface, side, cifrepo, host, user, passwd, dbname, n, coreSize, sampleSize, outfolder):
     p=analyzeSurface()
     db=Connect(host=host,user=user,passwd=passwd,db=dbname)
     cur = db.cursor()
     cur.execute("select pdbCode,chain1 from dc_%s where h1>30 and h2>30 and repchain1=repchain2"%(dataset))
     pdblist=cur.fetchall()
     pdbl=[pdb[0] for pdb in list(pdblist)]
     chains=[pdb[1] for pdb in list(pdblist)]
     for pdb in set(pdbl):
         try:
             p.scanSurface(pdb,chains[pdbl.index(pdb)],interface, side, cifrepo, host, user, passwd, dbname, n, coreSize, sampleSize, outfolder)
         except ValueError:
             print pdb
             pass
             
         except IOError:
             print pdb
             pass
Beispiel #16
0
def gerenciaContatos():
	print "gerencia contatos inicio"
	contatos = skype.Friends
	query = "SELECT * FROM contact WHERE user_name = '%s'" % (skype.CurrentUser.Handle)
	conn = Connect(host='auditim.tk', user='******', passwd='$passW0rD')
	curs = conn.cursor()
	curs.execute('use db_auditim')
	curs.execute(query)
	rows = curs.fetchall()
	for row in rows:
		print "contato no banco de dados: ", row[1]
		for contato in contatos:
			print "contato no Skype: ", contato.Handle
	    		if contato.Handle == row[1]:
				if row[3] == 'False':
		    			contato.IsBlocked = ''
				else:
		    			contato.IsBlocked = 'True'
	print "gerencia contatos fim"
Beispiel #17
0
def gerenciaContatos():
    print "gerencia contatos inicio"
    contatos = skype.Friends
    query = "SELECT * FROM contact WHERE user_name = '%s'" % (
        skype.CurrentUser.Handle)
    conn = Connect(host='auditim.tk', user='******', passwd='$passW0rD')
    curs = conn.cursor()
    curs.execute('use db_auditim')
    curs.execute(query)
    rows = curs.fetchall()
    for row in rows:
        print "contato no banco de dados: ", row[1]
        for contato in contatos:
            print "contato no Skype: ", contato.Handle
            if contato.Handle == row[1]:
                if row[3] == 'False':
                    contato.IsBlocked = ''
                else:
                    contato.IsBlocked = 'True'
    print "gerencia contatos fim"
Beispiel #18
0
def userPLogin():
    Notify(
        'AuditIM', 'Checando se o usuário: ' + skype.CurrentUser.FullName +
        ' tem permissão para utilizar o Skype', '')
    conn = Connect(host='auditim.tk', user='******', passwd='$passW0rD')
    curs = conn.cursor()
    curs.execute('use db_auditim')
    curs.execute('SELECT * FROM user WHERE user_name = %s',
                 (skype.CurrentUser.Handle))
    rows = curs.fetchall()
    if not rows or rows[0][2] == 'N':
        Notify(
            'AuditIM', 'Desculpe, mas o usuário de Skype: "' +
            skype.CurrentUser.FullName +
            '" não está autorizado, caso necessário entre em contato com o administrador.',
            '')
        skype.Client.Shutdown()  #fecha o Skype, fazendo logoff
        time.sleep(2)
        skype.Client.Start()
        time.sleep(2)
        Notify(
            'AuditIM',
            'Tente utilizar um usuário permitido, caso não funcione entre em contato com o administrador.',
            '')
Beispiel #19
0
from MySQLdb import Connect
conn = Connect(host='localhost', user='******', passwd='python')
curs = conn.cursor()
try:
    curs.execute('drop database testpeopledb')
except:
    pass  # did not exist

curs.execute('create database testpeopledb')
curs.execute('use testpeopledb')
curs.execute('create table people (name char(30), job char(10), pay int(4))')

curs.execute('insert people values (%s, %s, %s)', ('Bob', 'dev', 50000))
curs.execute('insert people values (%s, %s, %s)', ('Sue', 'dev', 60000))

curs.execute('select * from people')
for row in curs.fetchall():
	print row

curs.execute('select * from people')
colnames = [desc[0] for desc in curs.description]
while True:
    print '-' * 30
    row = curs.fetchone()
    if not row: break
    for (name, value) in zip(colnames, row):
        print '%s => %s' % (name, value)

conn.commit()   # save inserted records
Beispiel #20
0
def build_db():
    conn = Connect('localhost', 'root')
    c = conn.cursor()
    c.execute('CREATE DATABASE IF NOT EXISTS LINdb_Psy')
    c.execute('USE LINdb_Psy')
    c.execute('CREATE TABLE Genome (Genome_ID int NOT NULL AUTO_INCREMENT,'
              'Interest_ID int NOT NULL,'
              'Submission_ID int NOT NULL,'
              'FilePath text NOT NULL,'
              'GenomeName text NOT NULL,'
              'PRIMARY KEY (Genome_ID))')
    c.execute('CREATE TABLE Interest (Interest_ID int NOT NULL AUTO_INCREMENT,'
              'InterestName varchar(255) NOT NULL,'
              'Attribute_IDs text NOT NULL,'
              'PRIMARY KEY (Interest_ID))')
    c.execute('CREATE TABLE Attribute (Attribute_ID int NOT NULL AUTO_INCREMENT,'
              'AttributeName varchar(255) NOT NULL,'
              'PRIMARY KEY (Attribute_ID))')
    c.execute('CREATE TABLE LIN (LIN_ID int NOT NULL AUTO_INCREMENT,'
              'Genome_ID int NOT NULL,'
              'Scheme_ID int NOT NULL,'
              'SubjectGenome int NOT NULL,'
              'ANI DOUBLE NOT NULL,'
              'LIN text NOT NULL,'
              'PRIMARY KEY (LIN_ID))')
    c.execute('CREATE TABLE Scheme (Scheme_ID int NOT NULL AUTO_INCREMENT,'
              'Cutoff text(255) NOT NULL,'
              'LabelNum int NOT NULL,'
              'PRIMARY KEY (Scheme_ID))')
    c.execute('CREATE TABLE Submission (Submission_ID int NOT NULL AUTO_INCREMENT,'
              'User_ID int NOT NULL,'
              'Time text NOT NULL,'
              'PRIMARY KEY (Submission_ID))')
    c.execute(
        'CREATE TABLE User (User_ID int NOT NULL AUTO_INCREMENT,FirstName varchar(255) NOT NULL,LastName varchar(255) '
		'NOT NULL,Institute varchar(255) NOT NULL,RegistrationDate text NOT NULL,Username varchar(255) NOT NULL,'
		'Password text NOT NULL,Email text NOT NULL,PRIMARY KEY (User_ID))')
    c.execute(
        "CREATE TABLE AttributeValue (AttributeValue_ID int NOT NULL AUTO_INCREMENT,Genome_ID int NOT NULL,"
		"Interest_ID int NOT NULL, Attribute_ID int not null,AttributeValue text not null,User_ID int not null,"
		"Private boolean not null,PRIMARY KEY (AttributeValue_ID))")
    c.execute("CREATE TABLE Genome_to_Attribute (Genome_to_Attribute_ID int NOT NULL AUTO_INCREMENT, "
              "Genome_ID INT NOT NULL, Genus text, Species text,Subspecies__Pathovar text, Strain text, Type_strain text,"
              " GPS_Coordinates text, Date_of_isolation text,"
              "NCBI_Accession text, Country text, Link_to_peer_reviewed_paper text,Host_of_isolation__Environmental_source text,"
              "Disease text, Infectious_disease_name text,"
              "Host text, PRIMARY KEY (Genome_to_Attribute_ID))")
    c.execute(
        "CREATE TABLE Description (Description_ID int not null auto_increment, LIN_group text NOT NULL ,"
		"Description_Item_ID int not null, DescriptionValue text not null, User_ID INT NOT NULL , PRIMARY KEY (Description_ID))")
    c.execute(
        "CREATE TABLE Description_Items (Description_Item_ID int not null auto_increment, Description_Item_Name text "
		"not null, PRIMARY KEY (Description_Item_ID))")
    c.execute(
        "CREATE TABLE LIN_to_Description (LIN_to_Description_ID int NOT NULL AUTO_INCREMENT, LIN_group text NOT NULL, "
		"Genus text, Species text, Nickname text, Comment text, URL text, PRIMARY KEY(LIN_to_Description_ID))")
    ### INITIALIZATION
    # c.execute("insert into User (LastName, FirstName, Institute, RegistrationDate, Username, Password, Email) values
    #  ('Tian', 'Long', 'Virginia Tech', '2015-5-17', 'longtian', '123456', '*****@*****.**')")
    # Attributes
    # General entries
    c.execute("INSERT INTO Attribute (AttributeName) values ('Genus')")
    c.execute("INSERT INTO Attribute (AttributeName) values ('Species')")
    c.execute("INSERT INTO Attribute (AttributeName) values ('Subspecies/Pathovar')")
    c.execute("INSERT INTO Attribute (AttributeName) values ('Strain')")
    c.execute("INSERT INTO Attribute (AttributeName) values ('Type strain')")
    c.execute("INSERT INTO Attribute (AttributeName) values ('GPS Coordinates')")
    c.execute("INSERT INTO Attribute (AttributeName) values ('Date of isolation')")
    c.execute("INSERT INTO Attribute (AttributeName) values ('NCBI Accession')")
    c.execute("INSERT INTO Attribute (AttributeName) values ('Country')")
    c.execute("INSERT INTO Attribute (AttributeName) values ('Link to peer-reviewed paper')")
    # For Plant pathogen
    c.execute("INSERT INTO Attribute (AttributeName) values ('Host of isolation/Environmental source')")
    c.execute("INSERT INTO Attribute (AttributeName) VALUES ('Disease')")
    # For Virus
    c.execute("INSERT INTO Attribute (AttributeName) values ('Infectious disease name')")
    c.execute("INSERT INTO Attribute (AttributeName) values ('Host')")
    # Interest
    c.execute(
        "INSERT INTO Interest (InterestName, Attribute_IDs) values ('Plant pathogen','1,2,3,4,5,6,7,8,9,10,11,12')")
    c.execute(
        "INSERT INTO Interest (InterestName, Attribute_IDs) values ('Human & Animal viruses','1,2,4,5,6,7,9,10,13,14')")
    # Scheme
    c.execute("INSERT INTO Scheme (Cutoff, LabelNum) values ('70,75,80,85,90,95,96,97,98,99.99999', 10)")
    c.execute(
        "INSERT INTO Scheme (Cutoff, LabelNum) values ('60,70,80,85,90,95,98,99,99.5,99.6,99.7,99.8,99.9,99.91,99.92,"
		"99.93,99.94,99.95,99.96,99.97,99.98,99.99,99.999,99.9999', 24)")
    c.execute(
        "INSERT INTO Scheme (Cutoff, LabelNum) values ('60,70,75,80,85,90,95,98,98.5,99,99.25,99.5,99.75,99.9,99.925,"
		"99.95,99.975,99.99,99.999,99.9999', 20)")
    # Description Items
    c.execute("INSERT INTO Description_Items (Description_Item_Name) values ('Genus')")
    c.execute("INSERT INTO Description_Items (Description_Item_Name) values ('Species')")
    c.execute("INSERT INTO Description_Items (Description_Item_Name) values ('Nickname')")
    c.execute("INSERT INTO Description_Items (Description_Item_Name) values ('Comment')")
    c.execute("INSERT INTO Description_Items (Description_Item_Name) values ('URL')")

    # # Enter one genome to start

    # Start with Genome of DC3000, which is GCA_000007805.1.fasta
    c.execute("insert into User (LastName, FirstName, Institute, RegistrationDate, Username, Password, Email) values "
              "('Tian', 'Long', 'Virginia Tech', '2016-10-21', '*****@*****.**', '123456', '*****@*****.**')")
    c.execute("INSERT INTO Submission (User_ID, Time) VALUES (1,'2016-11-02')")
    c.execute(
        "INSERT INTO Genome (Interest_ID, Submission_ID, FilePath, GenomeName) VALUES (1, 1, '/home/linproject/Workspace/Psy_166/init/GCA_000007805.fasta', 'GCA_000007805')")
    c.execute(
        "INSERT INTO AttributeValue (Genome_ID, Interest_ID, Attribute_ID, AttributeValue, User_ID, Private) VALUES (1, 1, 1, 'Pseudomonas', 1, False)")
    c.execute(
        "INSERT INTO AttributeValue (Genome_ID, Interest_ID, Attribute_ID, AttributeValue, User_ID, Private) VALUES (1, 1, 2, 'syringae', 1, False)")
    c.execute(
        "INSERT INTO AttributeValue (Genome_ID, Interest_ID, Attribute_ID, AttributeValue, User_ID, Private) VALUES (1, 1, 3, 'pv. tomato', 1, False)")
    c.execute(
        "INSERT INTO AttributeValue (Genome_ID, Interest_ID, Attribute_ID, AttributeValue, User_ID, Private) VALUES (1, 1, 4, 'DC3000', 1, False)")
    c.execute(
        "INSERT INTO AttributeValue (Genome_ID, Interest_ID, Attribute_ID, AttributeValue, User_ID, Private) VALUES (1, 1, 5, 'No', 1, False)")
    c.execute(
        "INSERT INTO AttributeValue (Genome_ID, Interest_ID, Attribute_ID, AttributeValue, User_ID, Private) VALUES (1, 1, 6, '49.5,-2.5', 1, False)")
    c.execute(
        "INSERT INTO AttributeValue (Genome_ID, Interest_ID, Attribute_ID, AttributeValue, User_ID, Private) VALUES (1, 1, 7, 'NA', 1, False)")
    c.execute(
        "INSERT INTO AttributeValue (Genome_ID, Interest_ID, Attribute_ID, AttributeValue, User_ID, Private) VALUES (1, 1, 8, 'AE016853', 1, False)")
    c.execute(
        "INSERT INTO AttributeValue (Genome_ID, Interest_ID, Attribute_ID, AttributeValue, User_ID, Private) VALUES (1, 1, 9, 'United Kingdom', 1, False)")
    c.execute(
        "INSERT INTO AttributeValue (Genome_ID, Interest_ID, Attribute_ID, AttributeValue, User_ID, Private) VALUES (1, 1, 10, '10.1073/pnas.1731982100', 1, False)")
    c.execute(
        "INSERT INTO AttributeValue (Genome_ID, Interest_ID, Attribute_ID, AttributeValue, User_ID, Private) VALUES (1, 1, 11, 'Solanum lycopersicum', 1, False)")
    c.execute(
        "INSERT INTO AttributeValue (Genome_ID, Interest_ID, Attribute_ID, AttributeValue, User_ID, Private) VALUES (1, 1, 12, 'Plant rot, Speck disease', 1, False)")
    c.execute(""
              "INSERT INTO LIN (Genome_ID, Scheme_ID, SubjectGenome, ANI, LIN) VALUES (1, 3, 1, 1, '0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0')")
    conn.commit()
Beispiel #21
0
def extract():
    print("{} Descriptor Extractor:             [{}]".format(memory_usage_psutil(), color(FEATURE_DETECTOR_ALG.upper(), fontcolor=FONT_COLOR, bold=True)))

    # Pega lista de imagens
    images_list = make_image_list(DATASET_PATH)
    print("{} Images:                           [{}]".format(memory_usage_psutil(), color(len(images_list), fontcolor=FONT_COLOR, bold=True)))

    # Connect to DATABASE
    print("{} Connecting to the MySQL database...".format(memory_usage_psutil()), end=' ')
    try:
        DB_CONN = Connect(DATABASE_SETTINGS["host"], DATABASE_SETTINGS["user"], DATABASE_SETTINGS["password"], DATABASE_SETTINGS["database"])
        DB_CURSOR = DB_CONN.cursor()
    except Exception as e:
        raise e
    cprint("OK\n", fontcolor=FONT_COLOR, bold=True)

    # Tenta apagar tabela antiga de imagens
    print("{} Dropping the existing image table...".format(memory_usage_psutil()), end=' ')
    try:
        DB_CURSOR.execute("DROP TABLE {};".format(DATABASE_SETTINGS["table"]))
    except Exception as e:
        pass
    cprint("OK\n", fontcolor=FONT_COLOR, bold=True)

    print("{} Creating image table...".format(memory_usage_psutil()), end=' ')
    try:
        DB_CURSOR.execute('''
        CREATE TABLE {}
        (
        _id INT PRIMARY KEY,
        _path VARCHAR(255) NOT NULL UNIQUE,
        _descriptors JSON
        );'''.format(DATABASE_SETTINGS["table"]))
    except Exception as e:
        raise e
    cprint("OK\n", fontcolor=FONT_COLOR, bold=True)

    # Instancia classe de extração de descritores
    des_extract = DescriptorExtractor()
    print("{} Extracting Descriptors".format(memory_usage_psutil()))

    for i in tqdm(iterable=range(0, len(images_list)), ncols=90, unit='images'):
        # Extract image descriptors
        des = des_extract.extract(img_name=images_list[i], feature_detector_alg=FEATURE_DETECTOR_ALG)
        # Insert a img to images collection
        if des:
            if FEATURE_DETECTOR_ALG in BINARY_FEATURE_DETECTOR_ALG_LIST:
                try:
                    DB_CURSOR.execute('''
                        INSERT INTO {}
                        VALUES ({}, '{}', '{}')
                        ;
                        '''.format(
                            DATABASE_SETTINGS["table"], # Nome da tabela
                            int(images_list[i].split('/')[-1]), #ID da imagem em INT
                            images_list[i], # Caminho até a imagem
                            dumps([to_bit_string(elem) for elem in des]) # bit-string-descriptors em JSON
                            )
                    )
                except Exception as e:
                    raise e
            elif FEATURE_DETECTOR_ALG in NUMERICAL_FEATURE_DETECTOR_ALG_LIST:
                try:
                    DB_CURSOR.execute('''
                        INSERT INTO {}
                        VALUES ({}, '{}', '{}')
                        ;
                        '''.format(
                            DATABASE_SETTINGS["table"], # Nome da tabela
                            i, #int(images_list[i].split('/')[-1]), #ID da imagem em INT
                            images_list[i], # Caminho até a imagem
                            dumps([elem for elem in des]) # array-descriptors em JSON
                            )
                    )
                except Exception as e:
                    raise e


            else:
                raise Exception("Algoritmo não foi adicionado à lista de algoritmos válidos!")
        des = None
        del des

    print("{} Descriptors:                      [{}]".format(memory_usage_psutil(), color(des_extract.size, fontcolor=FONT_COLOR, bold=True)))

    print("{} Descriptors per image:            [{}]".format(memory_usage_psutil(), color(des_extract.size/len(images_list), fontcolor=FONT_COLOR, bold=True)))

    images_list = None
    del images_list, des_extract

    # Confirma alterações no BD
    print("{} Writing data in the database...".format(memory_usage_psutil()), end=' ')
    try:
        DB_CONN.commit()
    except Exception as e:
        raise e
    cprint("OK\n", fontcolor=FONT_COLOR, bold=True)

    # Fecha conexão
    print("{} Closing the connection to the database...".format(memory_usage_psutil()), end=' ')
    try:
        DB_CONN.close()
    except Exception as e:
        raise e
    cprint("OK\n", fontcolor=FONT_COLOR, bold=True)
def connect_to_db():
    conn = Connect("127.0.0.1", "LINbase", "Latham@537")
    c = conn.cursor()
    c.execute("use LINdb_NCBI_RefSeq_test")
    return conn, c
Beispiel #23
0
def connect_to_db():
    conn = Connect("localhost", "root")
    c = conn.cursor()
    c.execute("use LINdb_NCBI_RefSeq")
    return conn, c
def connect_to_db(from_db):
    conn = Connect("localhost", "root")
    c = conn.cursor()
    c.execute("use {0}".format(from_db))
    return conn, c
Beispiel #25
0
class Model:
    def __init__(self):
        self._conn = None
        self._cursor = None

    def connect(self, host, user, password, database):
        '''
        Método para conectar-se à Base de Dados

        Args:
            host : str
                Nome do host da Base de Dados

            user : str
                Usuário da Base de Dados

            password : str
                Senha da Base de Dados

            database : str
                Nome do Database a ser utilizado
        '''
        try:
            self._conn = Connect(host, user, password, database)
            self._cursor = self._conn.cursor()
        except Exception as e:
            raise e
        else:
            print("Connecting to '{}' database...".format(database))

    def close(self):
        '''
        Método para fechar a conexão com a Base de Dados
        '''
        try:
            self._conn.close()
        except Exception as e:
            raise e
        else:
            print("Closing connection...")

    def drop_table(self, table):
        '''
        Método para deletar uma tabela da Base de Dados

        Args:
            table : str
                Nome da tabela da Base de Dados
        '''
        try:
            self._cursor.execute(f"DROP TABLE {table};")
        except:
            pass
        else:
            print("Dropping '{}' table...".format(table))

    def commit(self):
        '''
        Método para escrever os dados na Base de Dados
        '''
        try:
            self._conn.commit()
        except Exception as e:
            raise e
        else:
            pass

    def select(self, columns=[], tables=[], value=None):
        '''
        Método para ler dados da Base de Dados

        Args:
            columns : list
                Lista de colunas a serem selecionadas

            tables : list
                Lista de tabelas

            value : str
                Valor a ser usado com a cláusula WHERE

        Returns
            n_rows : int
                Quantidade de linhas retornadas
        '''
        columns = [columns] if not isinstance(columns, list) else columns
        tables = [tables] if not isinstance(tables, list) else tables
        try:
            n_rows = self._cursor.execute(
                '''SELECT {} FROM {} WHERE {}={};'''.format(
                    ', '.join(map(lambda item: str(item), columns)),
                    ', '.join(map(lambda item: str(item), tables)), columns[1],
                    self._add_aspas(value)))
        except Exception as e:
            raise e
        else:
            return n_rows

    def select_all(self):
        '''
        Método para ler todos os dados da Base de Dados

        Returns
            self._cursor.fetchall() : tuple
                Dados lidos da Base de Dados
        '''
        try:
            ret = self._cursor.execute('''
                SELECT Point.pointLAT,
                       Point.pointLNG,
                       Point.pointStreetName,
                       Point.pointHouseNumber, 
                       Suburb.suburbName,
                       City.cityName,
                       Point.pointPostalCode,
                       State.stateUF,
                       Country.countryName 
                FROM Point
                LEFT JOIN Suburb
                ON Point.suburbID = Suburb.id
                LEFT JOIN City
                ON Suburb.cityID = City.id
                LEFT JOIN State
                ON City.stateID = State.id
                LEFT JOIN Country
                ON State.countryID = Country.id;
                ''')
        except:
            return None
        else:
            return self._cursor.fetchall()

    def _add_aspas(self, item):
        '''
        Método para formatar dados: se o item é uma String, 
        são adicionadas aspas ('') no item.

        Args:
            item : str | int | float
                Item a ser formatado

        Returns
            str(item) : str
                Item formatado
        '''
        if isinstance(item, str):
            return f"'{item.lower()}'"
        return str(item)

    def insert(self, table=None, columns=[], values=[]):
        '''
        Método para inserir dados na Base de Dados.
        Se a coluna for do tipo UNIQUE (countryName, stateUF, cityName, suburbName),
        é testado se o dado já existe na Base de Dados. Se já existir, o ID do dado
        é retornado; se o dado não existir, o dado é adicionado à Base de Dados e
        seu ID é retornado.

        Args:
            table : str
                Tabela onde os dados serão inseridos

            columns : list
                Lista de colunas

            values : list
                Lista de valores correspondentes às colunas

        Returns
            _id | self._cursor.lastrowid : int
                ID do dado adicionado ou do dado já existente
        '''
        columns = [columns] if not isinstance(columns, list) else columns
        values = [values] if not isinstance(values, list) else values

        # Busca o ID e o valor Único da tabela na base de dados para
        # verificar se já existe (countryName, stateUF, cityName, suburbName)
        n_rows = self.select(columns=['id', columns[0]],
                             tables=table,
                             value=values[0])

        if n_rows > 0:  # Se o valor já existe, retorna o ID
            _data = self._cursor.fetchall()[0]

            # Testa se os valores são iguais
            _id, _value = _data
            if values[0] == _value:
                return _id

        # Se o valor não existe, insere ele
        try:
            ret = self._cursor.execute(
                '''INSERT INTO {} ({}) VALUES ({});'''.format(
                    table, ', '.join(map(lambda item: str(item), columns)),
                    ', '.join(map(lambda item: self._add_aspas(item),
                                  values))))
        except Exception as e:
            raise e
        else:
            return self._cursor.lastrowid  # retorna o ID da nova inserção

    def create_tables(self):
        '''
        Método para criar as tabelas
        '''
        try:
            self._cursor.execute('''
                CREATE TABLE IF NOT EXISTS Country (
                    id INT NOT NULL AUTO_INCREMENT,
                    countryName VARCHAR(50) NOT NULL UNIQUE,
                    PRIMARY KEY (id)
                );
            ''')

            self._cursor.execute('''
                CREATE TABLE IF NOT EXISTS State (
                    id INT NOT NULL AUTO_INCREMENT,
                    stateUF VARCHAR(5) NOT NULL UNIQUE,
                    countryID INT NOT NULL,
                    PRIMARY KEY (id),
                    FOREIGN KEY (countryID) REFERENCES Country(id)
                );
            ''')

            self._cursor.execute('''
                CREATE TABLE IF NOT EXISTS City (
                    id INT NOT NULL AUTO_INCREMENT,
                    cityName VARCHAR(50) NOT NULL UNIQUE,
                    stateID INT NOT NULL,
                    PRIMARY KEY (id),
                    FOREIGN KEY (stateID) REFERENCES State(id)
                );
            ''')

            self._cursor.execute('''
                CREATE TABLE IF NOT EXISTS Suburb (
                    id INT NOT NULL AUTO_INCREMENT,
                    suburbName VARCHAR(100) NOT NULL UNIQUE,
                    cityID INT NOT NULL,
                    PRIMARY KEY (id),
                    FOREIGN KEY (cityID) REFERENCES City(id)
                );
            ''')

            self._cursor.execute('''
                CREATE TABLE IF NOT EXISTS Point (
                    id INT NOT NULL AUTO_INCREMENT,
                    pointLAT FLOAT,
                    pointLNG FLOAT,
                    pointStreetName VARCHAR(100),
                    pointHouseNumber VARCHAR(20),
                    pointPostalCode VARCHAR(20),
                    suburbID INT(11) NOT NULL,
                    PRIMARY KEY (id),
                    FOREIGN KEY (suburbID) REFERENCES Suburb(id)
                );
            ''')
        except Exception as e:
            raise e
        else:
            print("Creating tables...")
Beispiel #26
0
 def connectMySql(self):
     dbConnection=Connect(host=self.host,user=self.user,passwd=self.passwd,db=self.dbname)
     self.cur=dbConnection.cursor()
Beispiel #27
0
def image_search(query_path, hist_comp_method=4, top_n_results=4):
    global QUERY_HISTOGRAM
    global MATCHED_IMAGES
    QUERY_HISTOGRAM = {}
    MATCHED_IMAGES = {}

    # Instancia classe de extração de descritores
    des_extract = DescriptorExtractor()
    bit_string_vector = des_extract.extract(
        img_name=query_path, feature_detector_alg=FEATURE_DETECTOR_ALG)
    # Percorre lista de descritores da imagem
    for bit_string_des in bit_string_vector:
        # Explora recursivamente a VocabTree
        explore(VOCAB_TREE.tree, bit_string_des, len(bit_string_vector))

    bit_string_vector = None
    del bit_string_vector, des_extract

    # global MATCHED_IMAGES
    # print("[{}] MATCHED_IMAGES: {}".format(len(MATCHED_IMAGES), MATCHED_IMAGES))

    # Percorre lista de imagens que podem ser semelhantes
    for d_image in MATCHED_IMAGES.keys():
        # Percorre lista de nodos pelos quais os descritores da Query passaram
        for node in QUERY_HISTOGRAM.keys():
            # Testa se imagem passou pelo nodo em quastão
            if d_image in VOCAB_TREE.inverted_file[node].keys():
                # Se sim, adiciona qi ao histograma
                MATCHED_IMAGES[d_image].append(
                    VOCAB_TREE.inverted_file[node][d_image])
            else:
                # Semão, adiciona 0 ao histograma
                MATCHED_IMAGES[d_image].append(0)

    # Mostra lista de imagens
    # print("\n\nd_images: ")
    # Percorre chaves do dicionário de imagens possivelmente semelhantes
    for key in MATCHED_IMAGES.keys():
        # Normaliza histograma da imagem da base de dados
        MATCHED_IMAGES[key] = np.array(tuple(
            MATCHED_IMAGES[key])) / np.linalg.norm(
                np.array(tuple(MATCHED_IMAGES[key])), ord=1)
        MATCHED_IMAGES[key] = MATCHED_IMAGES[key].astype('float32')
        # Mostra histrograma
        # print("\n\n[{}] {} ~> {}".format(MATCHED_IMAGES[key].size, key, MATCHED_IMAGES[key]))

    # Normaliza histograma da query
    q_values = np.array(tuple(QUERY_HISTOGRAM.values())) / np.linalg.norm(
        np.array(tuple(QUERY_HISTOGRAM.values())), ord=1)
    q_values = q_values.astype('float32')
    # Mostra histograma da query
    # print("\n\n[{}] {} ~> {}".format(q_values.size, "query", q_values))

    # CALCULA SCORE
    score = []
    for _image_id in MATCHED_IMAGES.keys():
        if q_values.size != MATCHED_IMAGES[_image_id].size:
            raise Exception(
                "Query histogram and database image histogram are different!")
        # Compara histogramas
        s = compare_hist(q_values, MATCHED_IMAGES[_image_id], hist_comp_method)
        score.append((s, _image_id))

    q_values = None
    del q_values
    # Ordena score
    score.sort()
    del score[top_n_results:]

    image_list = []

    # Connect to DATABASE
    try:
        DB_CONN = Connect(DATABASE_SETTINGS["host"], DATABASE_SETTINGS["user"],
                          DATABASE_SETTINGS["password"],
                          DATABASE_SETTINGS["database"])
        DB_CURSOR = DB_CONN.cursor()
    except Exception as e:
        raise e

    for _s, _image_id in score:
        try:
            DB_CURSOR.execute('''
                SELECT _path
                FROM {}
                WHERE _id = {}
                ;
                '''.format(DATABASE_SETTINGS["table"], _image_id))
            query_image_path = DB_CURSOR.fetchall()[0][0].split('/')[-1]

            image_list.append((_s, query_image_path))
        except Exception as e:
            raise Exception("Error to read image path from database!!")

    # Fecha conexão
    try:
        DB_CONN.close()
    except Exception as e:
        raise e

    return image_list
Beispiel #28
0
from MySQLdb import Connect
conn = Connect(host='localhost', user='******', passwd='python')
curs = conn.cursor()
try:
    curs.execute('drop database testpeopledb')
except:
    pass  # did not exist

curs.execute('create database testpeopledb')
curs.execute('use testpeopledb')
curs.execute('create table people (name char(30), job char(10), pay int(4))')

curs.execute('insert people values (%s, %s, %s)', ('Bob', 'dev', 50000))
curs.execute('insert people values (%s, %s, %s)', ('Sue', 'dev', 60000))

curs.execute('select * from people')
for row in curs.fetchall():
    print row

curs.execute('select * from people')
colnames = [desc[0] for desc in curs.description]
while True:
    print '-' * 30
    row = curs.fetchone()
    if not row: break
    for (name, value) in zip(colnames, row):
        print '%s => %s' % (name, value)

conn.commit()  # save inserted records
Beispiel #29
0
class Connect_Db:
    ##  Inicializa o banco de dados
    #   @param host Servidor do banco de dados
    #   @param user Usuario do banco de dados
    #   @param passwd Senha do banco de dados
    def __init__(self,db_dados):
        self.host=db_dados['host']
        self.user=db_dados['user']
        self.passwd=db_dados['passwd']
        self.conecta()

    def __del__(self):
        self.curs.close()
        self.conn.close()

    def conecta(self):
        self.conn = Connect(self.host, self.user, self.passwd,charset='utf8',use_unicode=True)
        self.curs = self.conn.cursor()
        self.curs.execute('USE controledeacesso')

    ##  Cria um funcionario na tabela funcionarios.
    #   @param nome Nome do funcionario
    #   @param matricula Matricula do funcionario
    #   @param rfid RFID do funcionario. Não é obrigatoria
    def criar_Funcionario(self,nome,matricula,rfid=None):
        if not ( (isinstance(nome, str) or isinstance(nome, unicode)) and (isinstance(matricula, str) or isinstance(matricula, unicode))):
            return False
        sql="INSERT INTO funcionarios (ativo,nome,matricula,rfid) VALUES (true,%s,%s,"
        try:
            if (rfid !=  None):
                sql=sql+"%s)"
                self.curs.execute(sql,(nome,matricula,rfid))
            else:
                sql=sql+"NULL)"
                self.curs.execute(sql,(nome,matricula))
        except Exception:
            raise
        self.conn.commit()
        return True

    ##  Atualiza informações do usuario
    #   @param id_funcionario Id do funcionario
    #   @param nome Nome do funcionario
    #   @param matricula Matricula do funcionario
    #   @param rfid RFID do funcionario
    def atualizar_Funcionario(self,id_funcionario, nome=None, matricula=None, rfid=None):
        sql="UPDATE funcionarios SET "
        lista=[]
        if nome != None:
            sql=sql+"nome=%s,";
            lista.append(nome)
        if matricula != None:
            sql=sql+"matricula=%s,";
            lista.append(matricula)
        sql=sql+"rfid=%s,";
        lista.append(rfid)
        lista.append(id_funcionario)
        sql=sql[0:-1] + " WHERE id_funcionario=%s"
        self.curs.execute(sql,tuple(lista))
        self.conn.commit()

    ##  Retorna o Id do funcionario com o nome igual o da entrada
    #   @param nome Nome do funcionario    
    def obter_Id_Funcionario_por_Nome(self, nome):
        if not (isinstance(nome, str) or isinstance(nome, unicode)):
            return False
        self.curs.execute("SELECT id_funcionario FROM funcionarios WHERE nome=%s AND ativo=true",(nome))       
        linhas = self.curs.fetchall()
        self.conn.commit()
        return linhas[0][0] if len(linhas)>0 else False

    ##  Retorna o Id do funcionario com a matricula igual a da entrada
    #   @param matricula Matricula do funcionario    
    def obter_Id_Funcionario_por_Matricula(self, matricula):
        if not (isinstance(matricula, str) or isinstance(matricula, unicode)):
            return False
        self.curs.execute("SELECT id_funcionario FROM funcionarios WHERE matricula=%s AND ativo=true",(matricula))       
        linhas = self.curs.fetchall()
        self.conn.commit()
        return linhas[0][0] if len(linhas)>0 else False

    ##  Retorna o Id do funcionario com a matricula igual a da entrada
    #   @param matricula Matricula do funcionario    
    def obter_Id_Funcionario_por_Rfid(self, rfid):
        if not (isinstance(rfid, str) or isinstance(rfid, unicode)):
            return False
        self.curs.execute("SELECT id_funcionario FROM funcionarios WHERE rfid=%s AND ativo=true",(rfid))       
        linhas = self.curs.fetchall()
        self.conn.commit()
        return linhas[0][0] if len(linhas)>0 else False

    ##  Cria um horario para um funcionario
    #   @param id_funcionario Id do funcionario
    #   @param dia_da_semana Dia da semana no formato INT
    #   @param hora_inicial Hora inicial no formato HH:MM:SS
    #   @param hora_final Hora final no formato HH:MM:SS
    def criar_Horario(self,id_funcionario,dia_da_semana,hora_inicial,hora_final):
        if not isinstance(id_funcionario, long):
            return False
        if not isinstance(dia_da_semana, int):
            return False
        if not (isinstance(hora_inicial, str) or isinstance(hora_inicial, unicode)):
            return False
        if not (isinstance(hora_final, str) or isinstance(hora_final, unicode)):
            return False
        sql="INSERT INTO horarios (id_funcionario,dia_da_semana,hora_inicial,hora_final) VALUES (%s,%s,%s,%s)"
        self.curs.execute(sql,(id_funcionario,dia_da_semana,hora_inicial,hora_final))
        self.conn.commit()
        return True
     
    ##  Remove um dos horarios de um funcionario
    #   @param id_horario Id do horario  
    def remover_Horario(self,id_horario):
        self.curs.execute("DELETE FROM horarios WHERE id_horario=%s ",(id_horario))
        self.conn.commit()

    ##  Obtem as configurações do programa
    #   @param config Nome da configuração
    def obter_Configuracoes(self,config):
        if not (isinstance(config, str) or isinstance(config, unicode)):
            return False
        self.curs.execute("SELECT dado FROM configuracoes WHERE tipo=%s",(config))
        linhas = self.curs.fetchall()
        self.conn.commit()
        return linhas[0][0] if len(linhas)>0 else False
    
    ##  Atualiza as configurações do programa
    #   @param config Nome da configuração
    #   @param dado Dado que vai ser inserido
    def atualizar_Configuracoes(self,config,dado):
        if not (isinstance(config, str) or isinstance(config, unicode)):
            return False
        if not (isinstance(dado, str) or isinstance(dado, unicode)):
            return False
        sql="UPDATE configuracoes SET dado=%s WHERE tipo=%s"
        self.curs.execute(sql,(dado,config))
        self.conn.commit()
        return True

    ##  Obtem todos os funcionarios cadastrados
    def obter_Funcionarios(self):
        self.curs.execute("SELECT id_funcionario,nome FROM funcionarios WHERE ativo=true")
        linhas = self.curs.fetchall()
        result = []
        for i in range(len(linhas)):
            if len(linhas[i])==2:
                result.append({'id_funcionario':linhas[i][0],'nome':linhas[i][1]})
        self.conn.commit()
        return result if len(result)>0 else False

    ##  Verifica se algun dos dados ja existem
    def verifica_Ja_Existe(self,nome=None,matricula=None,rfid=None,id_funcionario=None):
        if nome:
            sql="SELECT count(*) FROM funcionarios WHERE nome=%s AND ativo=true"
            tup=(nome)
            if id_funcionario!=None:
                sql=sql+" AND id_funcionario!=%s"
                tup=(nome,id_funcionario)
            self.curs.execute(sql,tup)
            nome = self.curs.fetchall()
            nome = nome[0][0]
            if nome==0:
                nome = None
            else: 
                nome = True
        if matricula:
            sql="SELECT count(*) FROM funcionarios WHERE matricula=%s AND ativo=true"
            tup=(matricula)
            if id_funcionario!=None:
                sql=sql+" AND id_funcionario!=%s"
                tup=(matricula,id_funcionario)
            self.curs.execute(sql,tup)
            matricula = self.curs.fetchall()
            matricula = matricula[0][0]
            if matricula==0: 
                matricula = None
            else:
                matricula = True
        if rfid:
            sql="SELECT count(*) FROM funcionarios WHERE rfid=%s AND ativo=true"
            tup=(rfid)
            if id_funcionario!=None:
                sql=sql+" AND id_funcionario!=%s"
                tup=(rfid,id_funcionario)
            self.curs.execute(sql,tup)
            rfid = self.curs.fetchall()
            rfid = rfid[0][0]
            if rfid==0: 
                rfid = None
            else:
                rfid = True

        temp=nome or matricula or rfid;
        if temp==None:
            temp=False
        self.conn.commit()
        return {'nome':nome,'matricula':matricula,'rfid':rfid,'existe':temp}

    ##  Remove um funcionario do banco de dados e os horarios dele
    #   @param id_funcionario Id do funcionario
    def remover_Funcionario(self,id_funcionario):
        if not (isinstance(id_funcionario, long) or isinstance(id_funcionario, int)):
            return False
        self.curs.execute("UPDATE funcionarios set ativo=false WHERE id_funcionario=%s",(id_funcionario))
        self.remover_Horario_Funcionario(id_funcionario)
        self.conn.commit()
        return True

    ##  Remove todos os horarios de um funcionario
    #   @param id_funcionario Id do funcionario 
    def remover_Horario_Funcionario(self,id_funcionario):
        self.curs.execute("DELETE FROM horarios WHERE id_funcionario=%s",(id_funcionario))
        self.conn.commit()

    ##  Obtem todos os horarios cadastrados
    def obter_Horarios(self):
        sql="SELECT funcionarios.nome, horarios.dia_da_semana, horarios.hora_inicial, horarios.hora_final FROM horarios INNER JOIN funcionarios ON funcionarios.id_funcionario=horarios.id_funcionario ORDER BY horarios.dia_da_semana ASC,horarios.hora_inicial ASC"
        self.curs.execute(sql)
        linhas = self.curs.fetchall()
        self.conn.commit()
        return linhas if len(linhas)>0 else False

    ##  Retorna todos os horarios de um funcionario
    #   @param id_funcionario Id do funcionario 
    def buscar_Horarios_de_Funcionario(self,id_funcionario):
        self.curs.execute("SELECT id_horario, dia_da_semana, hora_inicial,hora_final FROM horarios WHERE id_funcionario=%s ORDER BY dia_da_semana ASC, hora_inicial ASC",(id_funcionario))
        linhas = self.curs.fetchall()
        l=[]
        if len(linhas)>0:
            for i in linhas:
                l.append({'id_horario':i[0],'dia_da_semana':i[1],'hora_inicial':i[2],'hora_final':i[3]})
        return l if len(l)>0 else False
        
    ##  Retorna todas as informações do funcionario
    #   @param id_funcionario Id do funcionario
    def obter_Funcionario(self,id_funcionario):
        self.curs.execute("SELECT id_funcionario,nome,matricula,rfid,ativo FROM funcionarios WHERE id_funcionario=%s",(id_funcionario))
        linhas = self.curs.fetchall()
        l={}
        if len(linhas)>0:
            i=linhas[0]
            l={'id_funcionario':i[0],'nome':i[1],'matricula':i[2],'rfid':i[3],'ativo':i[4]}
        return l if len(linhas)>0 else False
    
    ##  Retorna os funcionarios esperados para o horario
    #   @param dia_da_semana Dia da semana no formato INT
    #   @param limite_inferior Limite inferior para busca. Formato HH:MM:SS
    #   @param limite_superior Limite superior para a busca. Formato HH:MM:SS
    def buscar_Funcionarios_Esperados(self,dia_da_semana,limite_inferior,limite_superior):
        #Adicionado campo horarios.id_horario
        self.curs.execute("SELECT funcionarios.nome, funcionarios.id_funcionario, horarios.hora_inicial, horarios.hora_final, horarios.id_horario FROM horarios INNER JOIN funcionarios ON horarios.id_funcionario=funcionarios.id_funcionario WHERE horarios.dia_da_semana=%s AND curtime() >= subtime(horarios.hora_inicial,%s) AND curtime() <= addtime(horarios.hora_final,%s)",(dia_da_semana,limite_inferior,limite_superior))
        linhas = self.curs.fetchall()
        l={}
        if len(linhas)>0:
            for i in linhas:
                l[str(i[1])]={'nome':i[0],'hora_inicial':i[2],'hora_final':i[3],'id_horario':i[4]}
        self.conn.commit()
        return l if len(l)>0 else False

    ##  Retorna os funcionarios logados
    #   @param dia_da_semana Dia da semana no formato INT
    #   @param limite_inferior Limite inferior para busca. Formato HH:MM:SS
    #   @param limite_superior Limite superior para a busca. Formato HH:MM:SS
    def buscar_Funcionarios_Esperados_Logados(self,dia_da_semana,limite_inferior,limite_superior):
        self.curs.execute("SELECT pontos.id_funcionario FROM pontos INNER JOIN horarios ON horarios.id_horario=pontos.id_horario WHERE horarios.dia_da_semana=%s AND curtime() >= subtime(horarios.hora_inicial,%s) AND curtime() <= addtime(horarios.hora_final,%s) AND (pontos.presenca=-1)",(dia_da_semana,limite_inferior,limite_superior))
        linhas = self.curs.fetchall()
        l=[]
        for i in linhas:
            l.append(str(i[0]))
        self.conn.commit()
        return l if len(l)>0 else False

    ##  Verifica se existe ponto aberto de um funcionario
    #   @param id_funcionario Id do funcionario 
    def buscar_Ponto_Aberto_de_Funcionario(self,id_funcionario):
        self.curs.execute("SELECT pontos.horario_entrada,horarios.hora_inicial,horarios.hora_final FROM pontos INNER JOIN horarios on pontos.id_horario = horarios.id_horario WHERE pontos.presenca=-1 AND pontos.id_funcionario=%s ORDER BY pontos.id_ponto DESC",(id_funcionario)) #Otimizado por ORDER BY
        linhas = self.curs.fetchall()
        l=False
        if len(linhas)>0:
            i=linhas[0]
            l={'horario_entrada':i[0],'hora_inicial':datetime.datetime.combine(i[0].date(),(datetime.datetime.min+i[1]).time()),'hora_final':datetime.datetime.combine(i[0].date(),(datetime.datetime.min+i[2]).time())}
        self.conn.commit()
        return l

    ##  Cria o ponto de saida de um funcionario
    #   @param id_funcionario Id do funcionario 
    #   @param horario_saida Horario de saida no formato YYYY-MM-DD HH:MM:SS
    #   @presenca 0 para falta. 1 para presença. 2 para ponto nao fechado
    def finaliza_Ponto(self,id_funcionario,horario_saida,presenca):
        sql="UPDATE pontos SET horario_saida=%s, presenca=%s WHERE id_funcionario=%s AND presenca=-1"
        self.curs.execute(sql,(horario_saida,presenca,id_funcionario))
        self.conn.commit()
        return True

    ##  Retorna o horario mais proximo de um funcionario
    #   @param id_funcionario Id do funcionario 
    #   @param dia_da_semana Dia da semana no formato INT
    #   @param limite_inferior Limite inferior para busca. Formato HH:MM:SS
    #   @param limite_superior Limite superior para a busca. Formato HH:MM:SS
    def buscar_Horario_Mais_Proximo_de_Funcionario(self,id_funcionario,dia_da_semana,limite_inferior,limite_superior):
        sql="SELECT id_horario FROM horarios WHERE (id_funcionario=%s AND dia_da_semana=%s AND curtime()>SUBTIME(time(hora_inicial),time(%s)) AND curtime()<ADDTIME(time(hora_inicial),time(%s))) ORDER BY ABS(SUBTIME(%s,curtime())) LIMIT 1"
        self.curs.execute(sql,(id_funcionario,dia_da_semana,limite_inferior,limite_superior,limite_inferior))
        linhas = self.curs.fetchall()
        self.conn.commit()
        return linhas[0][0] if len(linhas)>0 else False

    ##  Cria o ponto de entrada de um funcionario
    #   @param id_funcionario Id do funcionario 
    #   @param id_horario Id do horario do funcionario
    def criar_Ponto(self,id_funcionario,id_horario,presenca=-1):
        sql="INSERT INTO pontos (id_funcionario,id_horario,horario_entrada,presenca) VALUES (%s,%s,now(),%s)"
        self.curs.execute(sql,(id_funcionario,id_horario,presenca))
        self.conn.commit()
        return True

    ##  Cria o ponto de falta de um funcionario
    #   @param id_funcionario Id do funcionario 
    #   @param id_horario Id do horario do funcionario
    def criar_Ponto_Falta(self,id_funcionario,id_horario,entrada_data,entrada_hora):
        sql="INSERT INTO pontos (id_funcionario,id_horario,horario_entrada,presenca) VALUES (%s,%s,concat(%s,' ',%s),0)"
        self.curs.execute(sql,(id_funcionario,id_horario,entrada_data,entrada_hora))
        self.conn.commit()
        return True

    ##  Adiciona no log da porta o funcionario que entrou e o horario
    #   @param id_funcionario Id do funcionario
    def adicionar_Log_Porta(self,id_funcionario):
        sql="INSERT INTO log_porta (id_funcionario,horario_entrada) VALUES (%s,now())"
        self.curs.execute(sql,(id_funcionario))
        self.conn.commit()

    ##  Obtem o log da porta dentro de um periodo de tempo
    #   @param data_inicial Data inicial do log. Formato YYYY-MM-DD HH:MM:SS
    #   @param data_final Data final do log. Formato YYYY-MM-DD HH:MM:SS    
    #   @return Nome,Matricula,Horario_entrada
    def obter_Log_Porta(self,data_inicial,data_final):
        self.curs.execute("SELECT funcionarios.nome,funcionarios.matricula,log_porta.horario_entrada FROM log_porta INNER JOIN funcionarios on log_porta.id_funcionario = funcionarios.id_funcionario WHERE (log_porta.horario_entrada >= %s AND log_porta.horario_entrada <= %s )",(data_inicial,data_final))
        linhas = self.curs.fetchall()
        return linhas if len(linhas)>0 else None
      
    ##  Obtem o log dos pontos dentro de um periodo de tempo
    #   @param data_inicial Data inicial do log. Formato YYYY-MM-DD HH:MM:SS
    #   @param data_final Data final do log. Formato YYYY-MM-DD HH:MM:SS  
    #   @param presentes Mostrar presença de funcionarios
    #   @param faltas Mostrar falta de funcionarios
    #   @param atrazos Mostrar atrazos de funcionarios
    #   @return Nome,Matricula,Horario_entrada,Horario_saida,Presenca
    def obter_Log_Pontos(self,data_inicial,data_final):
        sql="SELECT funcionarios.nome,funcionarios.matricula,pontos.horario_entrada,pontos.horario_saida,SUBTIME(TIME(pontos.horario_saida),TIME(pontos.horario_entrada)),pontos.presenca FROM pontos INNER JOIN funcionarios on pontos.id_funcionario = funcionarios.id_funcionario WHERE (pontos.horario_entrada >= %s AND pontos.horario_entrada <= %s)"
        self.curs.execute(sql,(data_inicial,data_final))
        linhas = self.curs.fetchall()
        return linhas if len(linhas)>0 else None
   
    ##  Obtem os pontos que não foram dados
    #   @param data_inicial Data inicial no formato YYYY-MM-DD HH:MM:SS
    #   @param data_final Data final no formato YYYY-MM-DD HH:MM:SS
    #   @param dia_da_semana Dia da semana inteiro
    #   @param limite_superior_ent Limite superior de entrada no formato HH:MM:SS
    def obter_Pontos_Faltando(self,data_inicial,data_final,dia_da_semana=None,limite_superior_ent=None):
        sql='SELECT id_horario_2,id_funcionario, hora_inicial,dia_da_semana FROM (SELECT pontos2.id_horario AS id_horario_1,horarios.id_horario AS id_horario_2, horarios.id_funcionario,horarios.hora_inicial,horarios.dia_da_semana FROM (SELECT pontos.* FROM pontos where horario_entrada>=%s and horario_entrada<=%s) AS pontos2 right join horarios on pontos2.id_horario=horarios.id_horario'
        dados=(data_inicial,data_final)
        if  dia_da_semana!=None:
            sql=sql+" where horarios.dia_da_semana=%s "
            dados=(data_inicial,data_final,dia_da_semana)
        if limite_superior_ent!=None:
            sql=sql+"and SUBTIME(curtime(),time(horarios.hora_inicial))<=time(%s)"
            dados=(data_inicial,data_final,dia_da_semana,limite_superior_ent)
        sql=sql+") AS tabelaTemp where id_horario_1 IS NULL"
        self.curs.execute(sql,dados)
        linhas = self.curs.fetchall()
        return linhas if len(linhas)>0 else False





    ##  Seta o funcionario como presente
    #   @param id_funcionario Id do funcionario 
    #   @param horario_entrada Horario de entrada do funcionario
    #   @param limite_superior_entrada Tempo limite de entrada do funcionario
    def atualiza_Ponto(self, id_funcionario, horario_entrada, limite_inferior_entrada, limite_superior_entrada):        
        sql="UPDATE pontos SET horario_entrada=%s, presenca=%s WHERE id_funcionario=%s AND presenca=0 AND NOW() >= subtime(pontos.horario_entrada,%s) AND NOW() <= addtime(pontos.horario_entrada,%s)"
        self.curs.execute(sql,(horario_entrada,-1,id_funcionario, limite_inferior_entrada, limite_superior_entrada))
        self.conn.commit()
        return True



    ##  Fecha todos os pontos ainda abertos ate o dia anterior
    def fecha_pontos_abertos(self):
        sql="UPDATE pontos SET presenca=%s WHERE presenca=-1 AND subtime(NOW(),'1 0:0:0') > pontos.horario_entrada"
        self.curs.execute(sql,(2))
        self.conn.commit()
        return True


    ##	Procura ponto recente de funcionario
    #   @param id_funcionario Id do funcionario
    #   @param presenca1 Tipo de presenca a ser procurada
    #   @param presenca2 Tipo de presenca a ser procurada
    def procura_ponto_recente(self, id_funcionario, presenca1=-1, presenca2=0):
        #sql="SELECT pontos.id_ponto FROM pontos INNER JOIN horarios ON pontos.id_horario = horarios.id_horario WHERE pontos.id_funcionario = %s AND DATEDIFF(CURDATE(), pontos.horario_entrada) < 1 AND (TIMEDIFF(CURTIME(), horarios.hora_final) < ADDTIME((SELECT dado FROM configuracoes WHERE tipo='tol_sai_dep'), '00:05:00' ) AND ( pontos.presenca = %s OR pontos.presenca = %s )"
        sql="SELECT pontos.id_ponto FROM pontos INNER JOIN horarios ON pontos.id_horario = horarios.id_horario WHERE pontos.id_funcionario = %s AND DATEDIFF(CURDATE(), pontos.horario_entrada) < 1 AND TIMEDIFF(CURTIME(), horarios.hora_final) < '02:00:00'  AND ( pontos.presenca = %s OR pontos.presenca = %s )"   #EU ODEIO O WINDOWS
        self.curs.execute(sql,(id_funcionario, presenca1, presenca2))
        linhas = self.curs.fetchall()
        l=False
        if len(linhas)>0:
            l=linhas[0][0]
        self.conn.commit()
        return l


    ##	Fecha ponto ao deslogar o usuario
    #   @param id_ponto Id do ponto
    def fecha_ponto_ao_deslogar_usuario(self, id_ponto):
    	sql="UPDATE pontos SET presenca=%s WHERE pontos.id_ponto = %s"
        self.curs.execute(sql,(2, id_ponto))
        self.conn.commit()
        return True