Example #1
0
File: users.py Project: dcorbe/wap
    def open(self, i_user=0):
        try:
            db = conn.cursor()
        except NameError:
            conn = DB()
            db = conn.cursor()

        if i_user == 0:
            self.id = 0
            self.username = None
            self.password = None
            self.options = None
            return

        db.execute(self.queryUserSelect, (i_user))
        row = db.fetchone()

        try:
            self.id = i_user
            self.username = row[1]
            self.password = row[2]
        except:
            self.id=0
            self.username = None
            self.password = None
            self.options = None

        self.options = User_Options(self.id)
Example #2
0
 def getData(self):
     url = "http://202.118.201.228/academic/teacher/teachresource/roomschedule_week.jsdo"
     # 提交周一至周日的表单数据
     for i in self.week:
         form_data = {
             "aid": self.aid,
             "buildingid": self.buildingid,
             "room": self.room,
             "whichweek": self.whichweek,
             "week": i,  # 星期1-7
         }
         html = LG.s.post(url=url, data=form_data).text  # 发送Post请求
         tmp = re.finditer(r'<tr style="display:" id="tr(.*?)".*?</table>', html, re.S)  # 返回迭代器,即各教室
         for j in tmp:
             id = j.group(1)
             tr = re.findall(r'<tr align="center" >(.*?)</tr>', j.group(), re.S)
             lst = re.findall(r"<td.*?</td>", tr[1], re.S)
             cnt = 0  # 记录课程节数
             for k in lst[::2]:
                 cnt += 1
                 if k[3] == " ":
                     flag = 0
                 else:
                     flag = 1
                 DB.insert(id, i, cnt, flag)  # 将数据插入数据库
Example #3
0
def getCampaignWordsPerDay(campaignID):
 #   print "Get Campaign Words Per Day"
      
    connection = Connection(DB.getDBHost(), DB.getDBPort())
    
    try:
        
        db = connection.meteor
         
        campaign = db.campaigns.find_one({"_id":campaignID})
        
        connection.close()
        
        if (campaign == ""):
            return "1"
        
        wordsPerDay = campaign['sendcount']
        
        if (wordsPerDay == ""):
            return "1"
    
        return wordsPerDay
    
    except:
        print "**** getCampaignWordsPerDay Exception ****"
        return "1"
Example #4
0
def getActiveStudents(campaignID):
#    print "ACTIVE Students"
    
    
    connection = Connection(DB.getDBHost(), DB.getDBPort())
#    print "Connecting to Students"

    try: 
        db = connection.meteor
        print "Connected to Students"
    
        activeStudentList = []
    
        print "Active Student List for Campaign " + campaignID
    
        for students in db.students.find({'campaign':campaignID}):         
#            print students['cell']  + "   "  + students['campaign']              
#            print " IS Active"
            activeStudentList.append(students['cell'])
             
        connection.close()
        
#        print "ACTIVE Students List EXIT"

        return activeStudentList
    
    except:
        print "GET ACTIVE STUDENT EXCEPTION"
Example #5
0
def getCrawlLogData():
    data = {
        "errorRows": [],
        "newestRows": []
    }

    errorRecords = DB.getCrawlRecordsWithErrors()
    crawlRecords = DB.getNewestCrawlRecords(limit=100)

    def pr(rows, crawlRecords):
        seenUrls = {}
        for cr in crawlRecords:
            dashboardRow = {
                "url": cr['url'],
                "renderTime": cr['renderTime'],
                "serverErrors": len(cr['serverErrors']),
                "browserErrors": len(cr['browserErrors']),
                "errorsPresent": cr['errorsPresent']
            }
            if dashboardRow['url'] not in seenUrls:
                rows.append(dashboardRow)
                seenUrls[dashboardRow['url']] = True
    pr(data['newestRows'], crawlRecords)
    pr(data['errorRows'], errorRecords)
    return data
 def getNearbyFacilities(self):
     hotel_list = DB.query("select * from hotel");
     facility_type = DB.query("select * from facility_type")
     types = {}
     for type in facility_type:
         types[type["name"]] = type["id"]
     for hotel in hotel_list:
         hotel_id = hotel["originalHotelID"]
         print hotel_id
         hotel_url = self.hotel_page_prefix + hotel_id + ".html"
         page_code = requests.get(hotel_url)
         soup = BeautifulSoup(page_code.text, "html.parser")
         div_list = soup.find_all('div',{'class':'htl_info_table'})
         if len(div_list) == 0:
             continue
         div = div_list[len(div_list) -1]
         #print div
         tr_list = div.find_all('tr')
         for tr in tr_list:
             type = types[tr.find('th').string]
             print tr.find('th').string
             ctt = tr.find_all('li')
             if len(ctt) != 0:
                 for li in ctt:
                     sql = "insert into hotel_nearby_facility(hotel_id,type,name,sub_type) values("+str(hotel["id"])+","+str(type)+",\""+li.string+"\",0)"
                     print sql
                     DB.insert(sql)
Example #7
0
def processCrawlJob(crawlJob):
    DB.removeFromCrawlQueue(crawlJob.url)
    resp = callAgent(crawlJob)
    processAgentResponse(resp)
    DB.addToCrawlQueue(crawlJob.url)
    crawlJob.success = True
    return crawlJob
 def getNearbyCateringInfo(self):
     hotel_list = DB.query("select * from hotel where id > 570");
     for hotel in hotel_list:
         hotel_id = hotel["id"]
         hotel_name = hotel["name_cn"]
         #hotel_name = "桔子水晶酒店(北京总部基地店)(原双赢酒店)"
         print hotel_name
         headers = {
             'User-Agent': 'Mozilla/5.0 (X11; U; Linux i686; zh-CN; rv:1.9.1.2) Gecko/20090803 Fedora/3.5.2-2.fc11 Firefox/3.5.2'
         }
         dianping_search_url = self.dianping_search_hotel_url+ hotel_name
         page_code = requests.get(dianping_search_url,headers = headers)
         soup = BeautifulSoup(page_code.text, "html.parser")
         #print soup
         ul = soup.find('ul',{'class':'hotelshop-list'})
         h2 = ul.find('h2',{'class':'hotel-name'})
         title = ''
         url = ''
         if h2 is not None:
             a = h2.find('a',{'class':'hotel-name-link'})
             title = a.string
             url = a['href']
             print title
             print url
         else:
             title = 'n/a'
             url = 'n/a'
         sql = "insert into hotel_dianping_info(id,name_cn,dianping_url,dianping_name) values("+str(hotel_id)+",\""+hotel_name+"\",\""+url+"\",\""+title+"\")"
         print sql
         DB.insert(sql)
Example #9
0
def getTFIDF():
    if not request.get_json(force=True) or not 'text' in request.get_json(force=True):
        print 'aborting'
        abort(400)


    # istr = request.json['text']
    istr = request.get_json(force=True)['text'] 
    n = int(request.get_json(force=True)['max_n'] )
    # remove all nonAsciiCharacters
    istr = removeNonAscii(istr)

    inclusion_list = DB.getInclusionList()
    exclusion_list = DB.getExclusionList()

    istr = removeNonAscii(istr)

    TFIDF_results = TFIDF.findTFIDFkeywords(istr)

    keywords = TFIDF_results[0:n]


    keywords = NER.excludeKeywords(exclusion_list, keywords)



    return jsonify({'keywords': keywords}), 201
Example #10
0
def getNER():
    if not request.get_json(force=True) or not 'text' in request.get_json(force=True):
        print 'aborting'
        abort(400)


    # istr = request.json['text']
    istr = request.get_json(force=True)['text'] 
    n = int(request.get_json(force=True)['max_n'] )
    # remove all nonAsciiCharacters
    istr = removeNonAscii(istr)

    inclusion_list = DB.getInclusionList()
    exclusion_list = DB.getExclusionList()

    istr = removeNonAscii(istr)

    NER_results = NER.findNamedEntities(istr, inclusion_list)

    keywords = NER_results[0:n]

    # omit repeats and return lowercase
    keywords = sorted(list(set(i.lower() for i in keywords)))
    keywords = NER.excludeKeywords(exclusion_list, keywords)



    return jsonify({'keywords': keywords}), 201
Example #11
0
def getActiveWordList(campaignID):
    print "ACTIVE Word List Order"
      
    connection = Connection(DB.getDBHost(), DB.getDBPort())
#    print "Connecting to Campaigns"
    
    db = connection.meteor
#    print "Connected to Words"    
    
    activeWordList = []
#    print "Active Word List Order"
    
    campaign = db.campaigns.find_one({"_id":campaignID})
    
    connection.close()
    
    if (campaign == ""):
        return ""
    
    wordOrder = campaign['cwordorder']
    
    if (wordOrder == ""):
        return ""
    
    wordOrderArray = wordOrder.split(",")
    
    for word in wordOrderArray:
        if (len(word) > 0):
            activeWordList.append(word)             
 #           print "activeWordList  add- > " + word
    
    return activeWordList    
Example #12
0
def getCampaignName(campaignID):
 #   print "Get Campaign Name"
      
    connection = Connection(DB.getDBHost(), DB.getDBPort())
    
    try:
        
        db = connection.meteor
         
        campaign = db.campaigns.find_one({"_id":campaignID})
        
        connection.close()
        
        if (campaign == ""):
            return "N/A"
        
        name  = campaign['campaign']
        
        if (name  == ""):
            return "N/A"
    
        return name
    
    except:
        print "**** getCampaignName Exception ****"
        return "N/A"    
Example #13
0
File: api.py Project: dcorbe/fm
def get_playlists(i_user=0):
    playlists = [ ]
    listenum = { }

    try:
        db = conn.cursor()
    except NameError:
        conn = DB()
        db = conn.cursor()
        
    db.execute("""SELECT id,listnum
                  FROM playlists
                  WHERE i_user = %s
                  ORDER BY listnum,id """, (i_user))

    rows = db.fetchall()

    for row in rows:
        try:
            if listenum[row[1]]:
                continue
        except:
            pass

        listenum[row[1]] = True;
        p = Playlist(row[1], i_user)
        playlists.append(p)

    return playlists
Example #14
0
def auth():

	TeacherID = 01475963
	AdminID = 36957410
	DB clockAideDB = DB("ClockAideDB")
	
	id = keypad.ReadLine()
	clockAideDB.authenticateUser(id)
	if id == TeacherID:
		keypad.SendLine(MODES['4'])
		return [,,modes[4]]								# auth() returns a list of the form [ID, Name, Session - True/False, Mode - Read/Set]
		
	elif id == AdminID:
		keypad.SendLine(MODES['5'])
		return [,,modes[5]]								# auth() returns a list of the form [ID, Name, Session - True/False, Mode - Read/Set]
		
	elif clockAideDB.isUserAuthenticated():
		
		keypad.SendLine(command["good"])			# Sends "Correct" Code to Keypad
		time.sleep(2)
		keypad.SendLine(name)					# Sends Student Name to Keypad
		
		# beginning logging information
		
		return [0,'',modes[int(keypad.ReadLine())]]		# auth() returns a list of the form [ID, Name, Session - True/False, Mode - Read/Set]
	else:
		print(keypad.SendLine(command["wrong"]))		# Sends "Wrong" Code to Keypad
		time.sleep(2)
		return modes[0]	
Example #15
0
File: song.py Project: dcorbe/fm
    def open(self, i_song): 
        try:
            db = conn.cursor()
        except NameError:
            conn = DB()
            db = conn.cursor()

        db.execute(self.querySongSelect, (i_song))

        row = db.fetchone()

        try:
            self.id = i_song
            self.artist = row[1]
            self.title = row[2]
            self.path = row[3]
        except:
            self.id = 0
            self.artist = False
            self.title = False
            self.path = False

        try:
            self.artist = self.artist.decode('UTF-8')
            self.title = self.title.decode('UTF-8')
        except:
            pass
Example #16
0
File: users.py Project: dcorbe/fm
    def get_user(self, username):
        try:
            db = conn.cursor()
        except NameError:
            conn = DB()
            db = conn.cursor()

        if self.Config.user['backend'] == 'mysql':
            db.execute(self.queryUnameSelect, (username))
        elif self.Config.user['backend'] == 'simplemachines':
            db.execute(self.querySMFUnameSelect, (username))
        else:
            # TODO: Throw an exception here, but I don't know how to do that
            #       at the moment :(
            pass

        row = db.fetchone()

        try:
            self.id = row[0]
            self.username = row[1]
            self.password = row[2]
        except:
            self.id = 0
            self.username = ''
            self.password = ''
Example #17
0
File: users.py Project: dcorbe/fm
    def open(self, i_user):
        try:
            db = conn.cursor()
        except NameError:
            conn = DB()
            db = conn.cursor()

        # Special case, used by playlist (amongst other things)
        if i_user == 0:
            self.id = 0
            self.username = '******'
            self.password = ''
            return

        if self.Config.user['backend'] == 'mysql':
            db.execute(self.queryUserSelect, (i_user))
        elif self.Config.user['backend'] == 'simplemachines':
            db.execute(self.querySMFUserSelect, (i_user))
        else:
            # TODO: Throw an exception here, but I don't know how to do that
            #       at the moment :(
            pass
            
        row = db.fetchone()

        try:
            self.id = i_user
            self.username = row[1]
            self.password = row[2]
        except:
            self.id = 0
            self.username = ''
            self.password = ''
Example #18
0
File: nas.py Project: dcorbe/wap
    def open(self, i_nas=0):
        try:
            db = conn.cursor()
        except NameError:
            conn = DB()
            db = conn.cursor()

        if i_nas == 0:
            self.id = 0
            self.identifier = None
            self.description = None
            self.options = None;
            return

        db.execute(self.queryNidSelect, (i_nas))
        row = db.fetchone()
        
        try:
            self.id = row[0]
            self.identifier = row[1]
            self.description = row[2]
        except:
            self.id = 0
            self.identifier = None
            self.description = None
            self.options = None;

        self.options = Nas_Options(self.id)
Example #19
0
def testTables():
    unitTestHelper.printHeader("Testing integrity of tables");
    # Set up for testing.
    unitTestHelper.printInfo("Adding in test values.");
    pidTemp = -1;
    try:
        pidTemp = DB.setUpTestValues();
    except:
        unitTestHelper.printFailed("Failed to set up test values.... Attempting cleanup");
        try:
            DB.removeTestValues(pidTemp);
        except:
            unitTestHelper.printFailed("Failed to clean up test values. Clean up values with PID: %s" % (pidTemp));
        return;


    # Conduct testing...

    # Check the SubmittedBy Table.

    # Check the Objects Table.

    # Check the Funds Table.

    # Check the UploadedFiles Table.

    # Clean up after testing.
    try:
        DB.removeTestValues(pidTemp);
    except:
        unitTestHelper.printFailed("Failed to clean up test values.");
        return;
Example #20
0
File: api.py Project: dcorbe/fm
def del_playlist_song(i_user=0, i_playlist=0, i_song=0):
    try:
        db = conn.cursor()
    except NameError:
        conn = DB()
        db = conn.cursor()

    db.execute("DELETE FROM playlists WHERE i_user=%s AND listnum=%s AND i_song=%s", (i_user, i_playlist, i_song))
Example #21
0
    def push(self, data):
        t = data['type']
        key = self.genKey(t)

        if t == self.TYPE_TOURNAMENT:
            DB.get_list(key).append(json.dumps(data))
        else:
            DB.Redis().hincrby(key, t)
Example #22
0
File: web.py Project: arsentur/demo
def edit(select, n):
    if select == 'edit':
        val = request.form['note']
        DB.edit(val, n)
    elif select == 'delete':
        DB.remove_element(n)

    return 'ok'
Example #23
0
 def run(self): #Overwrite run() method, put what you want the thread do here
     fileDirectory = []
     fileDirectory.append((self.disk, 1,0)) 
     handle = DB.initDB(self.disk[0:1])
     maxCount = self.getSubfolder(handle, fileDirectory)
     print maxCount
     DB.setFileTableCount(self.disk[0:1], maxCount)
     DB.closeDB(handle)
Example #24
0
def q_log(qid, priority, facility, mesg):
    """function for question scripts (marker, render, generator, etc) to
       use to log messages. """
    qid = int(qid)
    version = DB.get_q_version(qid)
    variation = DB.get_q_variation(qid)
    qtid = DB.get_q_parent(qid)
    owner = DB.get_qt_owner(qtid)
    audit(3, owner, qtid, "qlogger", "version=%s,variation=%s,priority=%s,facility=%s,message=%s" % (version, variation, priority, facility, mesg))
Example #25
0
def userRecord(account):
    username = session.get('username')
    account = session.get('account')

    if not username:
        return redirect(url_for('login'))
    userRecord=DB.userRecord(DB.open_database(),account)
    # your code
    return render_template('userInfo.html', userRecord=userRecord, username=username, account=account)
Example #26
0
    def save(cls, table, data):
        key_set = cls.genKSKey(table)

        for k, v in data.items():
            DB.get_set(key_set).add(k)
            cls(table, k).setAll(v)

            ver_key_set = cls.genKSKey(table, v['revision'])
            DB.get_set(ver_key_set).add(k)
Example #27
0
def add_prac_q_count(year, month, day, hour, qtemplate, count, avgscore):
    """ Insert a practice count for the given time/qtemplate """
    sql = """INSERT INTO stats_prac_q_course ("qtemplate", "hour", "day",
                                              "month", "year", "number",
                                              "when", "avgscore")
                VALUES (%s, %s, %s, %s, %s, %s, %s, %s);"""
    params = (qtemplate,  hour, day,
              month, year, count,
              datetime(year=year, hour=hour, day=day, month=month), avgscore)
    DB.run_sql(sql, params)
Example #28
0
def update_prac_q_count(year, month, day, hour, qtemplate, count, avgscore):
    """ Insert a practice count for the given time/qtemplate """
    sql = """UPDATE stats_prac_q_course SET "number"=%s, "avgscore"=%s
                 WHERE hour=%s
                 AND month=%s
                 AND day=%s
                 AND year=%s
                 AND qtemplate=%s;"""
    params = (count, avgscore, hour, month, day, year, qtemplate)
    DB.run_sql(sql, params)
Example #29
0
def registerPlayer(name):
    """Adds a player to the tournament database.

    Args:
      name: the player's full name (need not be unique).
    """
    cursor = DB().cursor()
    # Get already escaped SQL statement
    query = cursor.mogrify("INSERT INTO players (name) VALUES (%s)", (name,))
    DB().execute(query, True)
Example #30
0
def touchUserExam(exam, user):
    """ Update the lastchange field on a user exam so other places can tell that
        something changed. This should probably be done any time one of the
        following changes:
            userexam fields on that row
            question/guess in the exam changes
    """
    assert isinstance(exam, int)
    assert isinstance(user, int)
    DB.touch_user_exam(exam, user)
Example #31
0
    def initialize(self):
        print('Starting company scan: %s' % self.company)
        print('\n')
        self.ebot = DB.DBM("/data/bookjob.db", self)
        epo = 0
        for kw in self.kws:
            self.kkw = kw
            for cat in self.cat:
                epo += 1
                self.ccat = cat
                self.threads, self.c = [], 1
                self.sustain, self.mem = True, 360
                li = [0, cat, kw]
                order = [li[i - 1] for i in self.cwn]
                text = ''
                cs = (self.url % tuple(order))
                response = requests.get(cs)
                self.c = 1
                soup = BeautifulSoup(response.content, 'lxml')
                if self.num:  # Numbered version
                    print("Scan %s out of %s \t Current url: %s" %
                          (epo, len(self.cat) * len(self.kws), cs),
                          end='\r')
                    text = soup.find(**self.num)
                    # print('URL: %s'%cs)
                    if not text:
                        continue
                    text = text.text
                    try:
                        num = max([x for x in text.split() if x.isdigit()])
                    except ValueError:
                        print('\n')
                        print('No max number ERROR')
                        print(self.url % tuple(order))
                        print(text)
                        print([x for x in text if x.isdigit()])
                        continue
                    self.reps = int(int(num) / self.ipp)
                    if self.reps == 0:
                        self.reps += 1
                    self.left = self.reps
                    for i in range(self.reps):
                        self.process_page(i)
                else:  # Numberless version
                    self.rep = None
                    result = True
                    i = 0
                    while result:
                        li = [i, cat, kw]
                        order = [li[i - 1] for i in self.cwn]
                        cs = (self.url % tuple(order))
                        d = self.driver()
                        d.get(cs)
                        try:
                            d.WebDriverWait(d, 10).until(
                                EC.presence_of_element_located(
                                    (By.CSS_SELECTOR, "." + self.item[1])))
                        except:
                            pass
                        response = d.page_source
                        soup = BeautifulSoup(response, 'lxml')
                        result = soup.find_all(*self.item)
                        if not result:
                            break
                        self.process_page(i)
                        i += self.ipp
                        d.exit()
                    print("\rScan %s out of %s \t Current url: %s" %
                          (epo, len(self.cat) * len(self.kws), cs),
                          end='\r')

        # self.driver.close()
        print("Done")
Example #32
0
Default regkeys.txt is in data directory

"""

import DB, conf, sys
import csv
import re
import sys, os

if len(sys.argv) < 2:
    print "Usage: %s path_to_regkey_csv_file.  Default regkeys.txt is in data directory\n" % os.path.basename(
        sys.argv[0])
    sys.exit(0)

#Get a handle to our database
dbh = DB.DBO(None)

#This is in db.setup - uncomment if you need it.
#dbh.execute("""CREATE TABLE `registrykeys` (
#	`id` int auto_increment,
#	`path` VARCHAR( 250 ) ,
#	`reg_key` VARCHAR( 200 ) ,
#	`category` VARCHAR( 100 ),
#	`description` VARCHAR( 200 ) ,
#	PRIMARY KEY  (`id`)
#)""")

if __name__ == "__main__":

    try:
        filename = sys.argv[1]
Example #33
0
    def __init__(self, database, file=False, assume=False, unique='A'):
        '''

        '''
        self.region = pickle.load(open('r_key', 'rb'))
        self.cc = ''
        self.set = set()
        self.db = {}
        self.ucolumn = 0
        self.unique = unique
        self.a = assume
        self.oj = PatternFill(fill_type='solid',
                     start_color='f3af84',
                     end_color='f3af84')

        self.bord =  Border(left=Side(style='thin'), 
                     right=Side(style='thin'), 
                     top=Side(style='thin'), 
                     bottom=Side(style='thin'))


        self.og = PatternFill(fill_type='solid',
                     start_color='a9d08f',
                     end_color='a9d08f')

        self.align = Alignment(horizontal='center',
                               vertical='center',
                               text_rotation=0,
                               wrap_text=False,
                               shrink_to_fit=False,
                               indent=0)
        self.font = Font(name='Arial',
                         size=10,
                         bold=False,
                         italic=False,
                         vertAlign=None,
                         underline='none',
                         strike=False,
                         color='00000000')

        print("Loading database")
        self.dbm = DB.DBM(database, self)
        print("Loading file")
        if file:
            self.filepath = file
            if os.path.isfile(self.filepath):
                self.wb = openpyxl.load_workbook(self.filepath)
            else:
                self.wb = openpyxl.Workbook()
        else:
            self.filepath = None
            self.wb = openpyxl.Workbook()
        for sheet in self.wb.sheetnames:
            self.sheetn = sheet
            self.sheet = self.wb[self.sheetn]
            self.db[self.sheetn] = {"Meta": {"sheet name": self.sheetn,
                                             'width': self._current_width(),
                                             'bottom': self._current_line()}}
            self._sheet_load()
            self.db[sheet]['Data'] = self.self_scan()
        print("Loading complete")
        print("Choose an active sheet")
Example #34
0
def init_sql():
    db_path='../../data/db/'
    global Wdb
    Wdb=DB(db_path+'1220conserva_category.db')
    Wdb.create_table('category','user_id,user_name,pd_name,rv_title,rv_len,rv_text,anti,pd_url,rv_url,category1,category2,category3,category4,category5')
def addJsonToDB():
    DB.insert_text(1, json.dumps(dictionary))
Example #36
0
    def click_btn_run(self):
        # Получаем все переводы из файла
        translate_path = Path(self.setting_file_translates)
        try:
            translate_path.owner()
            translate_file_content = check_output([
                'php', '-r', 'include "' + self.setting_file_translates +
                '"; echo json_encode($l);'
            ])
            translate_file_content = json.loads(translate_file_content)

            # Введенный фрагмент
            self.input = self.output = self.main_input.toPlainText()
            soup = BeautifulSoup(self.input, 'html.parser')
            for script in soup(["script", "style"]):
                script.extract()  # rip it out
            text = soup.get_text()
            # break into lines and remove leading and trailing space on each
            lines = (line.strip() for line in text.splitlines())
            # break multi-headlines into a line each
            chunks = [c for c in filter(None, lines)]

            chunks = filter(self.filter_values, chunks)
            for v in chunks:
                print(v)
            sys.exit(0)

            # Массив с переводами которые уже есть в БД (и которые не нужно будет переводить)
            exist_translates = DB.check_translates(self.setting_db_name,
                                                   self.setting_db_user,
                                                   self.setting_db_pass,
                                                   self.setting_main_lang,
                                                   chunks)

            # Подставляем ID существующих переводов, и удаляем эти элементы из списка (chunks)
            if (len(exist_translates) > 0):
                for translate in exist_translates:
                    self.output = self.output.replace(
                        translate[self.setting_main_lang],
                        str(self.setting_l_placeholder) +
                        str(translate['lang_id']) +
                        str(self.setting_r_placeholder))
                    chunks.pop(chunks.index(translate[self.setting_main_lang]))

            # Перебираем оставщиеся строки, требующие перевода
            translator = Translator()
            translator.session.proxies['http'] = '125.26.109.83:8141'
            translator.session.proxies['http'] = '98.221.88.193:64312'
            translator.session.proxies['http'] = '188.244.35.162:10801'
            translator.session.proxies['http'] = '185.162.0.110:10801'

            # языки
            langs = self.setting_langs.split('|')

            # Прогресс бар
            i = 0
            self.progressBar.setMaximum(len(chunks) + 1)
            # Прогресс бар

            for item in chunks:

                # Прогресс бар
                i += 1
                self.progressBar.setValue(i)
                # Прогресс бар

                translate_file_string = []
                translate_dic = {}
                translate_dic[self.setting_main_lang] = item

                # строка для файла переводов
                translate_file_string = []
                for lang in langs:
                    new_translate = translator.translate(
                        item, src=self.setting_main_lang, dest=lang).text
                    translate_dic[lang] = new_translate  # Пауза для гугла
                    sleep(3)

                # для запроса в базу (корректировка языков)
                correct_lang_sql = []
                # значения для записи в базу
                string_sql_values = []
                for item in translate_dic.items():
                    print(item[0] + '--------' + item[1])
                    correct_lang_sql.append(DB.lang_field_connector(item[0]))
                    string_sql_values.append("'" + item[1] + "'")
                    # Строка для записи в файл переводов
                    translate_file_string.append('"' + item[0] + '": "' +
                                                 item[1] + '"')
                langs_sql = ','.join(correct_lang_sql)
                string_sql_values = ','.join(string_sql_values)

                # Запись в БД
                sql = "INSERT INTO modx_a_lang (" + langs_sql + ") VALUES (" + string_sql_values + ");"
                # values = (translate_dic["uk"], translate_dic["ru"], translate_dic["en"]);
                last_id = DB.add_translate(self.setting_db_name,
                                           self.setting_db_user,
                                           self.setting_db_pass, sql)

                # Запись в файл переводов
                translate_file_string = '{' + ','.join(
                    translate_file_string) + '}'
                translate_file_string = json.loads(translate_file_string)

                # Добавление нового перевода в строку json переводов
                translate_file_content[last_id] = translate_file_string
                self.output = self.output.replace(
                    translate_dic[self.setting_main_lang],
                    "[#" + str(last_id) + "#]")

            self.write_to_file(translate_file_content,
                               self.setting_file_translates)
            # subprocess.call(['chmod', '0777', '"' + self.setting_file_translates + '"'])
            self.main_input.setPlainText(self.output)
            # Информационное сообщение о завершении работы
            self.showMessage(
                "Перевод завершен!",
                "Перевод фрагмента html выполнен. Теперь вы можете его скопировать и добавить в свой шаблон!",
                'info')
        except FileNotFoundError as f:
            self.showMessage('Ошибка!', 'Не верно указан путь к файлу!',
                             'critical')
Example #37
0
class Game:
    # Class qui représente une partie de jeu

    #Const
    TIMEOUT = 10

    #Constructeur
    def __init__(self, levels_list):
        self.db = DB()
        self.db.connectDB()
        self.levels_list = levels_list
        self.levels = levels_list.getLevels()
        self.player = None
        self.dotation = None
        self.stats = None
        self.nb_python = 0
        self.mise = 0
        self.currentLevel = self.levels[0]
        self.nb_coup = 0
        self.level = 1
        self.gameEnded = False
        self.gain = 0
        self.maxLevel = 0
        self.maxMise = 0
        self.miseMin = 0
        self.gainMin = 0
        self.idPlayer = None
        self.cmpFirst = 0
        self.maxLoss = 0

    #Setters
    def setPlayer(self, player):
        self.player = player

    def setLevel(self, level):
        self.level = level

    def setStats(self, stats):
        self.stats = stats

    def setNbPython(self, nb_python):
        self.nb_python = nb_python

    def setMise(self, mise):
        self.mise = mise

    def setDotation(self, dotation):
        self.dotation = dotation

    def play(self):
        '''
            Permet de lancer le jeu
        '''
        while True:
            name_user = input("Je suis Python. Quel est votre pseudo ? ")
            if not name_user:
                print("Pseudo non valide")
            else:
                print("Pseudo valide !")
                self.player = self.db.addPlayer(name_user)
                self.dotation = self.player.getSolde()
                break
        #Ask the player if he wants to know the rules of the game
        answer = self.askRules()
        if (answer == True):
            self.showRules()

        #Initialisation
        self.miseMin = self.player.getSolde()
        self.gainMin = self.player.getSolde()
        playQuestion = self.askPlayer()
        while (self.dotation != 0 and playQuestion == True):
            while True:
                # Demander au joueur de miser
                print("### current level : " + self.currentLevel.ToString())
                print('Entrer une mise inférieure ou égale à {} € : ?'.format(
                    self.dotation))
                self.mise = input()
                try:
                    self.mise = int(self.mise)
                except:
                    print('Entrez un nombre.')
                    continue
                if self.mise < 1:
                    print('Entrez a nombre postif.')
                    continue
                if self.mise > self.dotation:
                    print(
                        'Erreur, votre mise est plus elevé que votre solde.: '
                        + str(self.dotation))
                    continue

                self.idPlayer = self.db.checkRegistredPlayer(name_user)['id']
                self.idGame = self.db.displayGames(name_user)
                self.miseMin = self.getMin(self.miseMin, self.mise)
                self.maxMise = self.getMax(self.mise, self.maxMise)
                #Mettre à jour les valeurs dans la BD
                self.db.updateStats('miseMin', self.miseMin, self.idPlayer,
                                    name_user, self.idGame['id'])
                self.db.updateStats('miseMax', self.maxMise, self.idPlayer,
                                    name_user, self.idGame['id'])
                break
            # Generer un nombre random
            self.nb_python = self.currentLevel.getRandomNumber(
                self.currentLevel.getRange1(), self.currentLevel.getRange2())
            print("#### nb_python " + str(self.nb_python))
            while (self.nb_coup < self.currentLevel.getCount()):
                # Demander au joueur de saisir un nombre qui correspond au nombre tiré par hasard
                while True:
                    timeout = time.time() + self.TIMEOUT
                    self.nb_user = input("Entrez SVP votre nombre ? ")
                    try:
                        self.nb_user = int(self.nb_user)
                    except:
                        print('Please use numeric digits.')
                        continue
                    if self.nb_user < 1:
                        print('Entrez a positive number.')
                        continue
                    if time.time() > timeout:
                        # Verifier que le délai de 10 sec n'a pas été franchis
                        triesLeft = self.currentLevel.getCount() - (
                            self.nb_coup + 1)
                        print(
                            "Vous avez dépassé le délai de 10 secondes ! Vous perdez l'essai courant\n\t\t\t et il vous reste {} essai(s) !"
                            .format(triesLeft))
                        self.nb_coup += 1
                        continue
                    self.nb_coup += 1
                    break
                #Verifier la réponse du joueur
                if self.nb_user > self.nb_python:
                    print('Votre nbre est trop grand')
                elif self.nb_user < self.nb_python:
                    print('Votre nbre est trop petit')
                else:
                    print("Bingo ! Vous avez gagné en {} coup(s) !".format(
                        self.nb_coup))

                    cote = self.currentLevel.getCote()
                    cote = cote[self.nb_coup - 1]
                    if (self.nb_coup == 1):
                        self.cmpFirst += 1
                        self.db.updateStats('firstTryNumber', self.cmpFirst,
                                            self.idPlayer, name_user,
                                            self.idGame['id'])
                    # Calculer le gain, le nouveau solde, mise minimal, etc
                    self.dotation = (self.player.getSolde() -
                                     self.mise) + (self.mise * cote)
                    self.gain += (self.mise * cote) - self.mise
                    self.gainMin = self.getMin(self.gainMin, self.gain)
                    self.player.setSolde(self.dotation)
                    self.maxLevel = self.getMax(self.level, self.maxLevel)
                    # Mettre à jour les champs dans la BD
                    self.db.updateStats('gainMin', self.gainMin, self.idPlayer,
                                        name_user, self.idGame['id'])
                    self.db.updateStats('gainMax', self.gain, self.idPlayer,
                                        name_user, self.idGame['id'])
                    self.db.updateStats('levelMax', self.level, self.idPlayer,
                                        name_user, self.idGame['id'])
                    self.db.updateTable('players', 'solde', self.dotation,
                                        self.idPlayer, name_user)

                    # Aller au niveau suivant aprés un succés
                    self.level += 1
                    if (self.level > self.levels_list.getNumberLevels()):
                        # Si le joueur arrive au dernier niveau
                        self.gameEnded = True
                        self.askPlayer()
                    else:
                        print("Super ! Vous passez au Level: {}!\n".format(
                            self.level))
                        self.currentLevel = self.levels_list.getLevel(
                            self.level - 1)
                        self.nb_coup = 0
                        self.askPlayer()
                    break

            if (self.nb_user != self.nb_python):
                print("Vous avez perdu, mon nombre choisi est :" +
                      str(self.nb_python))
                self.dotation -= self.mise
                self.player.setSolde(self.dotation)
                self.maxLoss = self.getMax(self.mise, self.maxLoss)
                # Si le joueur perd il retourne au niveau précédent
                if (self.level == 0):
                    self.currentLevel = self.levels_list.getLevel(0)
                else:
                    self.currentLevel = self.levels_list.getLevel(self.level -
                                                                  1)
                self.nb_coup = 0
                self.askPlayer()
            if (self.dotation == 0):
                print("Vous avez perdu, vous n'avez plus de solde €:" +
                      str(self.dotation))
                self.show()
                self.gameEnded = True
                sys.exit()
                break
        playQuestion = self.askPlayer()

    def askPlayer(self):
        '''
        Demander au joueur s'il veut rejoueur
        Réponse yes, y, no or n
        No case sensitivity in the answer. yes, YeS, y, Y, nO . . . 
        '''
        while (True):
            if (self.gameEnded == True):
                answer = input("Vous possedez € " +
                               str(self.player.getSolde()) +
                               " Voulez vous encore jouer ? (Y/N)")
                answer = answer.lower()
                if (answer == "yes" or answer == "y"):
                    self.currentLevel = self.levels_list.getLevel(0)
                    self.level = 1
                    self.nb_coup = 0
                    return True
                elif (answer == "no" or answer == "n"):
                    print("Vous avez terminé votre partie avec €" +
                          str(self.player.getSolde()) + " de solde.")
                    self.show()
                    sys.exit()
                else:
                    print("wrong input!")

            else:
                answer = input("Bonjour " + self.player.getUserName() +
                               ". Vous possedez €" +
                               str(self.player.getSolde()) +
                               ". Voulez vous jouer(Y/N)? ")
                answer = answer.lower()
                if (answer == "yes" or answer == "y"):
                    return True
                elif (answer == "no" or answer == "n"):
                    print("Vous avez terminé votre partie avec €" +
                          str(self.player.getSolde()) + " de solde.")
                    self.show()
                    sys.exit()
                else:
                    print("wrong input!")

    def askRules(self):
        '''
        Demander au joueur s'il veut voir les régles du jeu
        Réponse yes, y, no or n
        No case sensitivity in the answer. yes, YeS, y, Y, nO . . . 
        '''
        while (True):
            answer = input("Bonjour voulez vous connaitre les régles (Y/N) ? ")
            answer = answer.lower()
            if (answer == "yes" or answer == "y"):
                return True
            elif (answer == "no" or answer == "n"):
                print("Bonne Partie !.")
                return False
            else:
                print("wrong input!")

    def getMax(self, elem1, elem2):
        if (elem1 >= elem2):
            return elem1
        else:
            return elem2

    def getMin(self, elem1, elem2):
        if (elem1 <= elem2):
            return elem1
        else:
            return elem2

    def showRules(self):
        '''
        Afficher les régles du jeu
        '''
        print(""" 
                    *  *  *  *  *  *  *  *  *  *  * Bienvenue *  *  *  *  *  *  *  *  *\n
                    Le jeu comporte 3 levels avec la possibilié que le joueur choissise son level (si ce n'est pas sa 1è fois dans le Casino).
                    En d'autres termes, tout nouveau joueur doit passer par le 1è level. Suite à la 1è partie, il a le droit de choisir son level en lui rappelant / proposant le dernier niveau atteint\n.
                    Lors de chaque niveau, Python tire un nombre : level 1 (entre 1 et 10),
                    level2 (1 et 20), level3 (1 et 30). C'est à vous de deviner le nombre mystérieux avec 3 essais (en tout) lors du 1è 
                    level, 5 au 2è level et 7 au 3è level. Chaque essai ne durera pas plus de 10 secondes. Au-delà, 
                    vous perdez votre essai. Att : si vous perdez un level, vous rejouez le level précédent.
                    Quand vous souhaitez quitter le jeu, un compteur de 10 secondes est mis en place. 
                    En absence de validation de la décision, le jeu est terminé.
                    *  *  *  *  *  *  *  *  *  *  * Régles *  *  *  *  *  *  *  *  *\n
                    vous avez le droit à trois essais !\n
                    \t- Si vous devinez mon nombre dès le premier coup, vous gagnez le double de votre mise !\n
                    \t- Si vous le devinez au 2è coup, vous gagnez exactement votre mise !\n
                    \t- Si vous le devinez au 3è coup, vous gagnez la moitiè votre mise !\n    
                    \t- Si vous ne le devinez pas au 3è coup, vous perdez votre mise et
                    \tvous avez le droit : 
                    \t\t- de retenter votre chance avec l'argent qu'il vous reste pour reconquérir le level perdu.
                    \t\t- de quitter le jeu.\n
                    \t- Dès que vous devinez mon nombre : vous avez le droit de quitter le jeu et de partir avec vos gains OU \n\t\tde continuer le jeu en passant au level supérieur.\n     
                    """)

    def show(self):
        '''
        Afficher les stats du joueur de la partie terminée
        '''
        print("""\t************ Vos meilleures stats ************ \n
                \t- Réponse dés le premier coup : {}!\n
                \t- Gain Maximal : {} € !\n
                \t- Mise Maximale : {}€ !\n
                \t- Level Maximale : {} !\n
                ************ Vos Mauvaises stats ************ \n
                \t- Gain minimal : {} € :(\n
                \t- Mise minimale : {} € :(\n
                \t- Grosse Perte : {} € :(\n
                """.format(self.cmpFirst, self.gain, self.maxMise,
                           self.maxLevel, self.gainMin, self.miseMin,
                           self.maxLoss))
Example #38
0
def warning_check():
    unconfirm_warning = db.get_unconfirm_warning()
    if unconfirm_warning:
        se.send_warnmail(unconfirm_warning)
    else:
        print('No unconfirm warning found...')
Example #39
0
def get_random():
    return DB.get_random_anek()
Example #40
0
def SetInactive(d,m):
    new = DB.Server()
    n = new.cursor()
    n.execute("UPDATE Pi__Doors SET Active = 0 WHERE Door = %s AND Pi = %s", (d,m))
    new.commit()
#!python
print("Content-Type: text/html; charset=utf-8\n\n")
import cgi, os, DB as db
params = cgi.FieldStorage()
#num = int(params["num"].value) - 1
#content = params["content"].value
#list = os.listdir("files")
#f = open("files/" +list[num], "w", encoding="utf8")
#f.write(content)
#f.close()

sql = "UPDATE `list` SET  `content` = %s WHERE `no` = %s"
db.update(sql, [params["content"].value, int(params["num"].value)])

print(1)
Example #42
0
from keras.layers import Conv3D, MaxPooling3D, BatchNormalization, Dropout, Input, Dense, Flatten, concatenate
from keras.models import Model
import tensorflow as tf
import numpy as np
import MRIDataset as md
import MRIDatasetV as mdv
import DB as db
import H5ToPBConverter as h5
from keras import backend as K

K.set_learning_phase(0)

database = db.DBManager()

MRIs = md.MRIDataset("Datasets/**/**/", True, True)
train_images = np.array(MRIs.images)
train_labels = np.array(MRIs.labels)
ids = np.array(MRIs.ids)

dbRes = database.GetPatientsByCode(",".join(ids))
train_data = np.array(dbRes.loc[:, dbRes.columns != "code"])

vMRIs = mdv.MRIDatasetV("Validation/**/**/", True)
v_images = np.array(vMRIs.images)
v_labels = np.array(vMRIs.labels)
v_ids = np.array(vMRIs.ids)
v_dbRes = database.GetPatientsByCode(",".join(v_ids))
v_data = np.array(v_dbRes.loc[:, v_dbRes.columns != "code"])

convInput = Input(shape=(16, 256, 256, 1), name="convInput")
conv = Conv3D(64, kernel_size=(3, 3, 3), strides=(4, 4, 4),
Example #43
0
def main():
    HEIGHT = 600
    WIDTH = 1000

    sql.create_table()

    def create_folder(name, level, year):
        """Creates a folder in the specified location"""
        new_path = f'C:/{name}/{level}/{year}'
        if not os.path.exists(new_path):
            os.makedirs(new_path)

    def open_folder(name, level, year):
        """open a folder in the specified location"""
        path = f'C:/{name}/{level}/{year}'
        path = os.path.realpath(path)
        os.startfile(path)

    def create_word(course_name, question_name, difficult_level, year):
        """Creates a WORD document with the questions asked"""
        try:

            if course_name == '' or question_name == '':
                # Checks if the received name course and question name is not empty
                raise NameError

            all_data = sql.get_test_info(course_name, question_name,
                                         difficult_level, year)

            empty_list = []

            if all_data == empty_list:
                # Checks if the received name course and question name are the same as the database
                raise ValueError

            create_folder(question_name, difficult_level, year)

            count = 1

            word_list = []
            for row in all_data:
                photo_data = row[0]
                # Saves the image information
                photo_path = f'C:/{question_name}/{difficult_level}/{year}/{count}.jpg'
                # Creates the location where the image will be saved
                sql.write_to_file(photo_data, photo_path)
                word_list.append(photo_path)
                label.insert(tk.END, f"{count}) {row[1:]} ")
                # print in label
                count += 1

            create_word_file(question_name, word_list)

        except NameError:
            mess = "Must enter course name and question name"
            gui_print(mess)
        except ValueError:
            mess = "The names do not exist in the database"
            gui_print(mess)
        except Exception:
            mess = "Something went wrong"
            gui_print(mess)

    def search_question(course_name, question_name, difficult_level, year):
        """Creates a folder with the questions asked"""
        try:

            if course_name == '' or question_name == '':
                # Checks if the received name course and question name is not empty
                raise NameError

            all_data = sql.get_test_info(course_name, question_name,
                                         difficult_level, year)

            empty_list = []

            if all_data == empty_list:
                # Checks if the received name course and question name are the same as the database
                raise ValueError

            create_folder(question_name, difficult_level, year)

            count = 1

            for row in all_data:
                photo_data = row[0]
                # Saves the image information
                photo_path = f'C:/{question_name}/{difficult_level}/{year}/{count}.jpg'
                # Creates the location where the image will be saved
                sql.write_to_file(photo_data, photo_path)
                label.insert(tk.END, f"{count}) {row[1:]} ")
                # print in label
                count += 1

            open_folder(question_name, difficult_level, year)
        except NameError:
            mess = "Must enter course name and question name"
            gui_print(mess)
        except ValueError:
            mess = "The names do not exist in the database"
            gui_print(mess)
        except Exception:
            mess = "Something went wrong"
            gui_print(mess)

    def gui_print(message):
        label.insert(tk.END, f"{message}, Try again")
        # print in label

    root = tk.Toplevel()
    # Creates the program window

    canvas = tk.Canvas(root, height=HEIGHT, width=WIDTH)
    # Creates the window in "canvas" size
    canvas.pack()
    # Shows the window in "canvas" size

    background_image = tk.PhotoImage(file='landscape.png')
    # Takes a photo as input
    background_label = tk.Label(root, image=background_image)
    # Uses image as background
    background_label.place(relwidth=1, relheight=1)
    # Shows it in The specified coordinates

    frame1 = tk.Frame(root, bg='#80c1ff', bd=5)
    # Creates the frame Light blue (#80c1ff)
    frame1.place(relx=0.2, rely=0.05, relwidth=0.3, relheight=0.15, anchor='n')
    # Shows the frame in The specified coordinates

    entry1 = tk.Entry(frame1, font=40)
    # Creates a input box
    entry1.place(rely=0.2, relwidth=1, relheight=0.8)
    # Shows the input box

    label1 = tk.Label(frame1,
                      text='course name:',
                      bg='#80c1ff',
                      font=('courier', 10),
                      anchor='nw',
                      bd=4)
    # Creates a label
    label1.place(relx=0.12, rely=0, relwidth=0.35, relheight=0.3)
    # Shows the label

    frame2 = tk.Frame(root, bg='#80c1ff', bd=5)
    # Creates the frame Light blue (#80c1ff)
    frame2.place(relx=0.45,
                 rely=0.05,
                 relwidth=0.2,
                 relheight=0.15,
                 anchor='n')
    # Shows the frame in The specified coordinates

    entry2 = tk.Entry(frame2, font=40)
    # Creates a input box
    entry2.place(rely=0.2, relwidth=1, relheight=0.8)
    # Shows the input box

    label2 = tk.Label(frame2,
                      text='question name:',
                      bg='#80c1ff',
                      font=('courier', 10),
                      anchor='nw',
                      bd=4)
    # Creates a label
    label2.place(relx=0.12, rely=0, relwidth=0.63, relheight=0.3)
    # Shows the label

    frame3 = tk.Frame(root, bg='#80c1ff', bd=5)
    # Creates the frame Light blue (#80c1ff)
    frame3.place(relx=0.65,
                 rely=0.05,
                 relwidth=0.2,
                 relheight=0.15,
                 anchor='n')
    # Shows the frame in The specified coordinates

    entry3 = tk.Entry(frame3, font=40)
    # Creates a input box
    entry3.place(rely=0.2, relwidth=1, relheight=0.8)
    # Shows the input box

    label3 = tk.Label(frame3,
                      text='difficulty level:',
                      bg='#80c1ff',
                      font=('courier', 10),
                      anchor='nw',
                      bd=4)
    # Creates a label
    label3.place(relx=0.12, rely=0, relwidth=0.75, relheight=0.3)
    # Shows the label

    frame4 = tk.Frame(root, bg='#80c1ff', bd=5)
    # Creates the frame Light blue (#80c1ff)
    frame4.place(relx=0.85,
                 rely=0.05,
                 relwidth=0.2,
                 relheight=0.15,
                 anchor='n')
    # Shows the frame in The specified coordinates

    entry4 = tk.Entry(frame4, font=40)
    # Creates a input box
    entry4.place(rely=0.2, relwidth=0.5, relheight=0.8)
    # Shows the input box

    label4 = tk.Label(frame4,
                      text='year:',
                      bg='#80c1ff',
                      font=('courier', 10),
                      anchor='nw',
                      bd=4)
    # Creates a label
    label4.place(relx=0.12, rely=0, relwidth=0.25, relheight=0.3)
    # Shows the label

    button = tk.Button(frame4,
                       text="Search",
                       font=40,
                       command=lambda: search_question(entry1.get(
                       ), entry2.get(), entry3.get(), entry4.get()))
    # entry1.get() = course_name, entry2.get() = question name, entry3.get() = difficult_level, entry4.get() = year
    # Creates a button
    button.place(relx=0.55, rely=0.2, relwidth=0.45, relheight=0.8)
    # Shows the button

    lower_frame = tk.Frame(root, bg='#80c1ff', bd=10)
    # Creates the lower frame Light blue (#80c1ff)
    lower_frame.place(relx=0.5,
                      rely=0.25,
                      relwidth=0.75,
                      relheight=0.6,
                      anchor='n')
    # Shows the lower frame in The specified coordinates

    scrollbar = tk.Scrollbar(lower_frame)
    # Creates a scrollbar
    scrollbar.pack(side=tk.RIGHT, fill=tk.Y)
    # Shows the scrollbar
    label = tk.Listbox(lower_frame,
                       font=('courier', 12),
                       yscrollcommand=scrollbar.set)
    # Creates a label
    label.place(relwidth=0.9761, relheight=1)
    # Shows the label
    scrollbar.config(command=label.yview)

    word_button = tk.Button(
        root,
        text="create word file",
        font=40,
        command=lambda: create_word(entry1.get(), entry2.get(), entry3.get(),
                                    entry4.get()))
    # entry1.get() = course_name, entry2.get() = question name, entry3.get() = difficult_level, entry4.get() = year
    # Creates a button
    word_button.place(relx=0.37, rely=0.87, relwidth=0.25, relheight=0.1)
    # Shows the button

    root.mainloop()
    # Run the program window

    sql.close_db()
Example #44
0
 def mostrarInstanciaXSet(self,setId):
     filas = DB.select_instanciaXSet(self.conn,setId)
     #print(filas)
     for e in filas:
         self.twInstancia.insert("", tk.END, text=str(e[0]), values=(e[1],e[2],e[3],e[4],e[5]))
Example #45
0
 def mostrarSet(self):
     filas = DB.select_sets(self.conn)
     #print(filas)
     for e in filas:
         self.twSet.insert("", tk.END, text=str(e[0]), values=(e[1],))
Example #46
0
 def warning():
     lstWarningList = db.get_unconfirm_warning()
     return render_template(
         "warning.html",
         lstWarningList=lstWarningList,
     )
Example #47
0
def load(song):
    # Available metadata:
    # 'comment': '',
    # 'rating': '0',
    # 'albumArtRef': [
    # {'url': 'http://lh3.googleusercontent.com/p8U1RGRxD0ALYDIQn7i5FnQeqHRgwdK-nkfSZz8ZBlFoRlGELXyCnHlFNMu-pcE07N4RnzEJ'}
    # ],
    # 'artistId': ['Axoinbuvsvwmwg6ivw7zh4wrdgu'],
    # 'composer': '',
    # 'year': 2010,
    # 'creationTimestamp': '1359063177192221',
    # 'id': '818adcf0-8f46-34cd-bf06-15fae192537c',
    # 'album': 'We Speak No Americano',
    # 'totalDiscCount': 0,
    # 'title': 'We No Speak Americano',
    # 'recentTimestamp': '1377030153712000',
    # 'albumArtist': 'Yolanda Be Cool',
    # 'trackNumber': 1,
    # 'discNumber': 0,
    # 'deleted': False,
    # 'storeId': 'Ta5h26qukyn6ak2vqbxhjwhlymu',
    # 'nid': 'Ta5h26qukyn6ak2vqbxhjwhlymu',
    # 'totalTrackCount': 0,
    # 'estimatedSize': '27964108',
    # 'albumId': 'Bndl5iegqwoofmnghpgn3scq4aa',
    # 'beatsPerMinute': 0,
    # 'genre': 'House',
    # 'playCount': 1,
    # 'artistArtRef': [
    # {'url': 'http://lh3.googleusercontent.com/1ENtGnKsVUBDUwC6SgVTpDCOQodlAjOadralURIVQ1kmc2UM-POSonmInfO8XR2OWmiafOic'}
    # ],
    # 'kind': 'sj#track',
    # 'primaryVideo': {
    # 'kind': 'sj#video',
    # 'id': 'YKa0yM4ZisA',
    # 'thumbnails': [
    #   {'url': 'https://i.ytimg.com/vi/YKa0yM4ZisA/mqdefault.jpg',
    #    'width': 320,
    #    'height': 180}
    # ]
    # },
    # 'artist': 'DCUP/Yolanda Be Cool',
    # 'lastModifiedTimestamp': '1452341253502000',
    # 'clientId': 'KGuhQUzL9y/pYPgpeSNTxA',
    # 'durationMillis': '270000'

    # Step 1: Add the artist / Find the artist in the DB and collect their ID
    songArtist = song['artist'] or 'NULL'
    songArtistId = 'NULL'
    songArtistArt = 'NULL'

    if 'artistId' in song:
        songArtistId = song['artistId'][0] or 'NULL'
    if 'artistArtRef' in song:
        songArtistArt = song['artistArtRef'][0]['url'] or 'NULL'
    artistPyId = DB.findArtistId(songArtist, songArtistId, songArtistArt)

    # Using this internal ID, assign the album (or find the current ID if already exists)
    songAlbum = song['album'] or 'NULL'
    songAlbumId = 'NULL'
    songAlbumDiscNo = song['discNumber'] or 0
    songAlbumTrackCount = song['totalTrackCount'] or 0
    songAlbumArt = 'NULL'

    if 'albumId' in song:
        songAlbumId = song['albumId'] or 'NULL'
    if 'albumArtRef' in song:
        songAlbumArt = song['albumArtRef'][0]['url'] or 'NULL'
    albumPyId = DB.findAlbumId(songAlbum, songAlbumDiscNo, songAlbumTrackCount,
                               artistPyId, songAlbumId, songAlbumArt)

    # Finally, add the song itself to the DB
    songTitle = song['title'] or 'NULL'
    songId = song['id'] or 'NULL'
    songTrackNo = song['trackNumber'] or 0
    songDuration = song['durationMillis']
    songSize = song['estimatedSize']
    DB.addSong(songId, songTrackNo, songTitle, albumPyId, artistPyId,
               songDuration, songSize)
Example #48
0
    def home():
        if request.args.get('trace'):
            TRACE = request.args.get('trace')
            haap.get_trace(TRACE, trace_level_cfg)
        else:
            pass

        if mode == 'rt':
            StatusHAAP = haap_rt_info_to_show()
            StatusSANSW = sansw_rt_info_to_show()
            if StatusHAAP:
                StatusHAAP.sort(key=operator.itemgetter(0))
                tlu_haap = s.time_now_to_show()
                status_warning = 0
            else:
                tlu_haap = s.time_now_to_show()
                status_warning = 0

            if StatusSANSW:
                StatusSANSW.sort(key=operator.itemgetter(0))
                tlu_sansw = s.time_now_to_show()
                status_warning = 0
            else:
                tlu_sansw = s.time_now_to_show()
                status_warning = 0

        elif mode == 'db':
            lstWarningList = db.get_unconfirm_warning()
            if request.method == 'GET' and lstWarningList:
                error = 1
            else:
                db.update_warning()
                error = 0

            engine = haap_info_to_show()
            sansw = sansw_info_to_show()
            status_warning = db.get_unconfirm_warning()
            if engine:
                tlu_haap = engine[0]
                StatusHAAP = engine[1]
                StatusHAAP.sort(key=operator.itemgetter(0))

            else:
                tlu_haap = s.time_now_to_show()
                StatusHAAP = [0]

            if sansw:
                tlu_sansw = sansw[0]
                StatusSANSW = sansw[1]
                StatusSANSW.sort(key=operator.itemgetter(0))
            else:
                tlu_sansw = s.time_now_to_show()
                StatusSANSW = [0]

        return render_template("monitor.html",
                               Title_HAAP=lstDescHAAP,
                               Title_SANSW=lstDescSANSW,
                               tlu_haap=tlu_haap,
                               tlu_sansw=tlu_sansw,
                               status_haap=StatusHAAP,
                               status_sansw=StatusSANSW,
                               status_warning=status_warning,
                               interval_web_refresh=interval_web_refresh,
                               sw_status=sw_status)
def Connent_Online_Mysql_By_DB(hostname,port,username,pwd,dbname,socket):
    db = DB.DB(False,host=hostname, port=port, user=username ,passwd=pwd, db=dbname,charset='gbk', unix_socket=socket) 
    return db
Example #50
0
def generate_hash():
    x = ''.join(
        random.choice(string.ascii_uppercase + string.ascii_lowercase +
                      string.digits) for _ in range(16))
    return x


buyer = Info.buyer
uploader = Info.uploader

buyerKey = Info.buyerKey
uploaderKey = Info.uploaderKey

if __name__ == "__main__":

    db = DB.DB()
    trading = Contract.Contract(buyer, uploader, buyerKey, uploaderKey)
    curBlock = int(trading.getBlock()["number"])

    try:
        select = sys.argv[1]

        if select == "getToken":
            user = sys.argv[2]
            token = int(sys.argv[3])
            trading.getToken(token)

            logger.debug({'event': "getToken", 'token': token})

        elif select == "uploadFile":
            category = sys.argv[2]
def bruteforce_iterate():
    d_df_asset = DB.preload(asset=setting["target"],
                            step=setting["preload_step"],
                            query_df="trade_date > 20050101")

    e_ibase = Alpha.ABase
    e_ideri = Alpha.ADeri

    len_e_ibase = len([x for x in e_ibase])
    len_e_ideri = len([x for x in e_ideri])

    # for each possible base ibase
    for ibase_counter, ibase in enumerate(e_ibase, start=1):
        ibase_name = ibase.value

        # for each possible derivative function
        for ideri_counter, ideri in enumerate(e_ideri, start=1):
            ideri_name = ideri.value
            if ideri_name == "create":
                deri_function = Alpha.get_func(ibase_name)
            else:
                deri_function = Alpha.get_func(ideri_name)
            print("deri is,", ideri_name, deri_function.__name__)
            settings_explode = function_all_combinations(deri_function)

            print("all combinations", settings_explode)
            len_setting_explode = len(settings_explode)

            # for each possible way to create the derivative function
            for setting_counter, one_setting in enumerate(settings_explode,
                                                          start=1):

                # CHECK IF OVERRIDE OR NOT if small update, then continue if file exists
                if not setting["big_update"]:
                    for key in LB.c_bfreq():
                        path = f"{setting['path_general']}{ibase_name}/{ideri_name}/" + LB.indi_name(
                            abase=ibase_name,
                            deri=ideri_name,
                            d_variables=one_setting) + f"_fgain{key}.csv"
                        if not os.path.exists(path):
                            print("=" * 40)
                            print(
                                f"SMALL UPDATE: File NOT EXIST. DO. -> {ibase}:{ibase_counter}/{len_e_ibase}. Deri.{ideri_name}:{ideri_counter}/{len_e_ideri}. setting:{setting_counter}/{len_setting_explode}"
                            )
                            print("=" * 40)
                            break  # go into the ibase
                    else:
                        print("=" * 40)
                        print(
                            f"SMALL UPDATE: File Exists. Skip. -> {ibase}:{ibase_counter}/{len_e_ibase}. Deri.{ideri_name}:{ideri_counter}/{len_e_ideri}. setting:{setting_counter}/{len_setting_explode}"
                        )
                        print("=" * 40)
                        continue  # go to next ibase
                else:
                    print("=" * 40)
                    print(
                        f"BIG UPDATE: -> {ibase}:{ibase_counter}/{len_e_ibase}. Deri.{ideri_name}:{ideri_counter}/{len_e_ideri}. setting:{setting_counter}/{len_setting_explode}"
                    )
                    print("=" * 40)
                # create sample
                path = f"{setting['path_general']}{ibase_name}/{ideri_name}/" + LB.indi_name(
                    abase=ibase_name, deri=ideri_name,
                    d_variables=one_setting) + f"_sample"
                df_sample = d_df_asset["000001.SZ"].copy()
                print("one setting is", {**one_setting})
                deri_function(df=df_sample, ibase=ibase.value, **one_setting)
                LB.to_csv_feather(df=df_sample,
                                  a_path=LB.a_path(path),
                                  index_relevant=False,
                                  skip_feather=True)

                # Initialize ALL ts_code and fgain result for THIS COLUMN, THIS DERIVATION, THIS SETTING
                d_fgain_mean_detail = {
                    f"fgain{freq}": pd.DataFrame()
                    for freq in LB.c_bfreq()
                }

                # for each possible asset
                print(
                    f"START: ibase={ibase.value} ideri={ideri.value} setting="
                    + str({**one_setting}))
                d_df_asset_sample = {
                    x: d_df_asset[x]
                    for x in random.sample([x for x in d_df_asset.keys()],
                                           setting["sample_size"])
                }
                for ts_code, df_asset in d_df_asset_sample.items():
                    # create new derived indicator ON THE FLY and Evaluate
                    print("ts_code", ts_code)
                    df_asset_copy = df_asset.copy(
                    )  # maybe can be saved, but is risky. Copy is safer but slower
                    deri_column = deri_function(df=df_asset_copy,
                                                ibase=ibase.value,
                                                **one_setting)
                    bruteforce_eval_fgain(
                        df=df_asset_copy,
                        ts_code=ts_code,
                        column=deri_column,
                        d_fgain_gmean_detail=d_fgain_mean_detail)

                # save evaluated results
                for key, df in d_fgain_mean_detail.items():
                    df.index.name = "ts_code"
                    path = f"{setting['path_general']}{ibase_name}/{ideri_name}/" + LB.indi_name(
                        abase=ibase_name,
                        deri=ideri_name,
                        d_variables=one_setting) + f"_{key}"
                    # DB.ts_code_series_to_excel(df_ts_code=df, path=path, sort=[key, False], asset="E", group_result=setting["group_result"])
                    LB.to_csv_feather(df=df,
                                      a_path=LB.a_path(path),
                                      index_relevant=True,
                                      skip_feather=True)
Example #52
0
 def GetRoomType(self, roomID):
     conn = DB.CreateConnection()
     a = roomDictionary[f'{DB.GetRoomType(conn, roomID)}']
     conn.close()
     return a
Example #53
0
 def filomplain(self, filename, complain):
     DB.fileComplain(self.email, filename, complain)
 def test_register_admin_func(self):
     # self.cursor.execute("INSERT INTO users VALUES ('parentTest','123','parent','',1)")
     res = DB.register_admin('adminTest', '123')
     self.assertNotEqual(res, True)  # Test
Example #55
0
def update(connect, cursor):
    code = input("Product code: ").lower()
    price = input("New price: ")

    DB.update(connect, cursor, code, price)
    print("Product updated")
Example #56
0
    # setup Arduino thread
    arduino = Arduino.Arduino(cfg,
                              queueFromArduino=queueReadings,
                              queueToArduino=queueToArduino)

    # setup calculation thread
    threadCalc = Calc.Calc(cfg,
                           queueReadings=queueReadings,
                           queueResults=queueDB,
                           broadcast_queue=queueMqttPub)
    threadCalc.daemon = True
    threadCalc.start()

    # setup database thread
    updateDB = DB.UpdateDB(cfg, queueResults=queueDB)
    updateDB.daemon = True
    updateDB.start()

    # setup arduino scheduler thread
    ards = Arduino.ArdSchedule(cfg, queueToArduino)
    ards.initialize()
    ards.daemon = True
    ards.start()

    meter = HydroMeter.Meter(cfg,
                             queue_readings=queueReadings,
                             queue_db=queueDB)
    meter.daemon = True
    meter.start()
                    df.index.name = "ts_code"
                    path = f"{setting['path_general']}{ibase_name}/{ideri_name}/" + LB.indi_name(
                        abase=ibase_name,
                        deri=ideri_name,
                        d_variables=one_setting) + f"_{key}"
                    # DB.ts_code_series_to_excel(df_ts_code=df, path=path, sort=[key, False], asset="E", group_result=setting["group_result"])
                    LB.to_csv_feather(df=df,
                                      a_path=LB.a_path(path),
                                      index_relevant=True,
                                      skip_feather=True)


if __name__ == '__main__':

    # need to use geomean for eval function
    df = DB.get_asset()

    bruteforce_iterate()
    bruteforce_summary(setting["path_general"], setting["path_result"])


def explode_settings(d_one_indicator_variables):
    # 1. only get values form above dict
    # 2. create cartesian product of the list
    # 3. create dict out of list

    # first list out all possible choices
    for key, value in d_one_indicator_variables.items():
        print(f"Input ---> {key}: {value}")

    a_product_result = []
Example #58
0
from flask import Blueprint, session, request, redirect, url_for, render_template
from werkzeug import secure_filename
from werkzeug.contrib.fixers import ProxyFix

import time
import api

from DB import *
from bbcode import *
from topics import *
from post import *
from subscriptions import *
import api

blog = Blueprint('blog', __name__)

conn = DB()
bbcode = postmarkup_wrapper()


@blog.route('/blog')
def blog_main():
    posts = api.blog_posts()
    return render_template('blog.html',
                           posts=posts,
                           time=time,
                           api=api,
                           bbcode=bbcode)
Example #59
0
    def UpdateTableData(self):
        # Create connection to database
        conn = DB.CreateConnection()
        # get the customer data for the current month
        data = DB.GetCustomersByMonth(conn,
                                      self.monthSelection.currentIndex() + 1,
                                      self.yearSelection.date().year(),
                                      self.roomTypeSelection.currentIndex())

        # get the rooms based on the room type
        rooms = DB.GetRoomsByType(conn, self.roomTypeSelection.currentIndex())

        #
        if self.roomTypeSelection.currentIndex() == 0:
            rowNumber = DB.GetRoomNumber(conn)
        else:
            rowNumber = DB.GetRoomNumber(conn,
                                         self.roomTypeSelection.currentIndex())
        conn.close()

        currentRow = self.tableWidget.currentRow()
        currentColumn = self.tableWidget.currentColumn()

        # set up the table rows
        try:
            # set the number of rows based on the selected roomtype
            self.tableWidget.setRowCount(0)

            for item in rooms:
                rowPosition = self.tableWidget.rowCount()
                self.tableWidget.insertRow(rowPosition)
                self.tableWidget.setVerticalHeaderItem(
                    rowPosition, QtWidgets.QTableWidgetItem(str(item)))

            self.tableWidget.setCurrentCell(currentRow, currentColumn)

            # set the number of columns based on the selected month
            if self.currentMonth != (self.monthSelection.currentIndex() + 1):
                self.tableWidget.setColumnCount(0)
                self.tableWidget.setColumnCount(
                    self.months[f'{self.monthSelection.currentIndex() + 1}'])
                self.currentMonth = self.monthSelection.currentIndex() + 1

            for item in data:
                try:
                    row = rooms.index(
                        item.RoomID)  # find the row by searching the room list
                    column = item.CheckIn.day - 1  # starting column is the check in day
                    span = item.NumberOfStayNights  # how many cells to merge based on the stay days
                    if item.CheckIn.month < (
                            self.monthSelection.currentIndex() + 1
                    ):  # if the CheckIn date is on a previous month calculate difference
                        column = 0
                        delta = -(item.CheckIn - date(
                            self.yearSelection.date().year(),
                            self.monthSelection.currentIndex() + 1, 1))
                        span = item.NumberOfStayNights - delta.days + 1  # set span to difference

                    self.tableWidget.setItem(
                        row, column,
                        QtWidgets.QTableWidgetItem(
                            f'"{item.Name}" Άτομα: {item.People} Τιμή ανά βράδυ: {item.PricePerNight}'
                        ))
                    temp = self.tableWidget.item(
                        row, column)  # access the item just created
                    temp.setBackground(
                        QColor(dictionary[f"{item.BookingType}"][1][0],
                               dictionary[f"{item.BookingType}"][1][1],
                               dictionary[f"{item.BookingType}"][1][2],
                               alpha=150)
                    )  # set the background color of the item based on the dictionary
                    temp.setData(
                        1, item.CustomerID
                    )  # set the metadata of the item to the CustomerID
                    self.tableWidget.setSpan(row, column, 1,
                                             span)  # merge the cells
                except ValueError:
                    pass

            del data  # clean up memory by deleting the customer data from memory

        except TypeError:
            return
Example #60
0
    def POST(self):
        try:
            webData = web.data()
            con = db.connectdb()
            print "Handle Post webdata is ", webData
            recMsg = receive.parse_xml(webData)
            is_b = db.check_binding(con, recMsg.FromUserName)
            print(is_b)
            if is_b != 1 and isinstance(
                    recMsg, receive.Msg) and recMsg.MsgType == 'text':
                toUser = recMsg.FromUserName
                fromUser = recMsg.ToUserName
                content = "pull test! git"
                replyMsg = reply.TextMsg(toUser, fromUser, content)
                return replyMsg.send()
            elif isinstance(
                    recMsg,
                    receive.Msg) and recMsg.MsgType == 'text' and is_b == 1:
                print("courseid:" + recMsg.Content)
                db.bind_courese(con, recMsg.FromUserName, recMsg.Content)
                return 'success'

            elif isinstance(recMsg, receive.Msg) and recMsg.MsgType == 'image':
                toUser = recMsg.FromUserName
                fromUser = recMsg.ToUserName
                mediaId = recMsg.MediaId
                print(mediaId)
                replyMsg = reply.ImageMsg(toUser, fromUser, mediaId)
                return replyMsg.send()
            # elif isinstance(recMsg,)
            if isinstance(recMsg, receive.EventMsg):
                if recMsg.Event == 'CLICK':
                    if recMsg.Eventkey == 'mpBind':

                        toUser = recMsg.FromUserName
                        fromUser = recMsg.ToUserName
                        print(toUser)
                        content = "enter course code"
                        replyMsg = reply.TextMsg(toUser, fromUser, content)
                        # con=db.connectdb()
                        db.insert_user(con, toUser)

                        return replyMsg.send()
                    elif recMsg.Eventkey == 'mpState':
                        toUser = recMsg.FromUserName
                        fromUser = recMsg.ToUserName
                        re, len, fn = db.query_ppt(con, toUser)
                        hist.create_hist(len, re, fn)
                        accessToken = Basic().get_access_token()
                        myMedia = media.Media()
                        mediaType = "image"
                        res = myMedia.uplaod(accessToken,
                                             './img/{0}.jpg'.format(fn),
                                             mediaType)
                        data = json.loads(res)
                        media_id = data['media_id']
                        # media_id = 'KPPQWLBPNNqSyWdURe8L8RV0W4yx8zMz18Zp_8k7lsQJ7hMMhilPLlpyidC2YDUL'
                        print(media_id)
                        replyMsg = reply.ImageMsg(toUser, fromUser, media_id)
                        return replyMsg.send()

            # else:
            print "do nothing"
            closedb(db)
            return "success"
        except Exception, Argment:
            return Argment