Esempio n. 1
0
class CiUtils(object):
    def init_ci(self, path, is_local):
        self.logger = LogController()
        self.fileManager = FileManager(path)
        if not is_local:
            self.logger.header('generating env file...')
            self.ENV_FILE = self.get_env_content()
            self.fileManager.write_str(self.ENV_FILE)
            self.logger.greenText(f'Env file:\n{self.ENV_FILE}')
        else:
            self.logger.greenText('Running with env file local')

    def get_env_content(self):
        env = f"""
                ENGINE_PORT=8080
                SECRET_KEY=\"{get_random_secret_key()}\"
                OIDC_RP_REALM_NAME=""
                OIDC_RP_CLIENT_ID=""
                OIDC_OP_LOGOUT_ENDPOINT=""
                OIDC_RP_SCOPES=""
                OIDC_RP_CLIENT_SECRET=""
                OIDC_OP_TOKEN_ENDPOINT=""
                OIDC_OP_AUTHORIZATION_ENDPOINT=""
                OIDC_RP_SIGN_ALGO=""
                OIDC_RP_SERVER_URL=""
                OIDC_OP_USER_ENDPOINT=""
                OIDC_OP_JWKS_ENDPOINT=""
                BILLING_COST_PER_WHATSAPP=199
                BILLING_TEST_MODE=True
            """.replace(" ", "").strip()
        return env

    def execute(self, command, is_printing=False):
        os.chdir(os.getcwd())
        self.logger.blueText(command)
        try:
            command_output = subprocess.check_output(
                command, shell=True).decode('utf-8')
            self.logger.success()
            if is_printing:
                self.logger.coloredText(command_output)
            res = 0
        except subprocess.CalledProcessError as e:
            res = 1
            self.logger.fail(
                e.stdout.decode("utf-8").replace("\n", "\n ").strip())
        return res

    def run_ci(self, path, is_local: bool):
        self.init_ci(path, is_local)
        ok = self.execute('python manage.py migrate')
        ok += self.execute('python manage.py collectstatic --noinput', False)
        ok += self.execute('flake8 connect/', False)
        if self.execute('coverage run manage.py test --verbosity=2 --noinput',
                        False) == 0:
            ok += self.execute('coverage report -m', True)
        else:
            ok += 1
        if ok > 0:
            exit(1)
Esempio n. 2
0
    def getMatrixFromFile(self, name):
        fileManager = FileManager()
        matrixString = fileManager.getVectorTxt(name)

        matrix = self.__createMatrixArray(matrixString)

        return matrix
Esempio n. 3
0
    def getVectorFromFile(self, name):
        fileManager = FileManager()
        vectorString = fileManager.getVectorTxt(name)

        vector = self.__createVectorArray(vectorString)

        return vector
Esempio n. 4
0
 def __init__(self, submission_data: SubmissionData, config: Config):
     self.submission_name: str = submission_data.name
     self.filename = submission_data.file_name  # TODO remove this dependency
     self.exe_name = config.exe_filename
     self.functions_data: List[FunctionData] = submission_data.functions
     self.path_manager = PathManager("submission-checker", submission_data,
                                     config)
     self.file_manager = FileManager(self.path_manager)
     self.input_handler = InputHandler(True)
Esempio n. 5
0
 def init_ci(self, path, is_local):
     self.logger = LogController()
     self.fileManager = FileManager(path)
     if not is_local:
         self.logger.header('generating env file...')
         self.ENV_FILE = self.get_env_content()
         self.fileManager.write_str(self.ENV_FILE)
         self.logger.greenText(f'Env file:\n{self.ENV_FILE}')
     else:
         self.logger.greenText('Running with env file local')
Esempio n. 6
0
class Calendar(object):
    def __init__(self, filename):
        self.filename = filename
    
    def __enter__(self):
        self.fManager = FileManager(self.filename)
        self.events = self.fManager.readEvents()
        self.painter = Painter()
        return self
    
    def __exit__(self, exc_type, exc_val, exc_tb):
        self.fManager.rewriteEvents(self.events)
        
    def draw(self):
        self.painter.draw(self.events)
Esempio n. 7
0
def index():
    now = datetime.datetime.now()
    ip = request.remote_addr

    pokemon = RandomPkmon().random_pkmon()
    info = pokemon["base_info"]
    stats = pokemon["statistic"]
    num = info["num"]
    name = info["name"]
    level = info["level"]
    moves = pokemon["moves"]
    dt = DamagesTimes()
    type_index1 = dt.get_type_index(info["type1"])
    type_index2 = dt.get_type_index(info["type2"])
    gifname = '%s.gif' % num
    # moves=pokemon["moves"]
    move_index1 = dt.get_type_index(moves["move1"]["type"])
    move_index2 = dt.get_type_index(moves["move2"]["type"])
    move_index3 = dt.get_type_index(moves["move3"]["type"])
    move_index4 = dt.get_type_index(moves["move4"]["type"])

    context = "%s 用户%s 遇到了 LV.%s %s" % (now, ip, level, name)
    FileManager().save2log(context)
    return render_template('index.html',
                           filename=gifname,
                           info=info,
                           pokemon=stats,
                           type_index1=type_index1,
                           type_index2=type_index2,
                           moves=moves,
                           move_index1=move_index1,
                           move_index2=move_index2,
                           move_index3=move_index3,
                           move_index4=move_index4)
Esempio n. 8
0
    def battlewith(self, mypkmon, wild_pkmon):
        # 首先派出自己的精灵

        # 双方精灵加入战斗场景(写入文本文件)
        battle_manger = {'player': mypkmon, 'enemy': wild_pkmon}
        # print(battle_manger)
        # 测试获取的等级
        pkmoninfo = battle_manger["player"]["base_info"]
        print("该你上场了,去吧,%s!\n" % pkmoninfo['name'])
        FileManager().save_battle_env(battle_manger)
        BattleProcess().start(battle_manger)
        print("over")
Esempio n. 9
0
 def __init__(self):
     self.log_manager = FileManager("log.csv",
                                    _default_log_values)
     self.command_manager = FileManager("commands.csv",
                                        _default_command_values)
     self.configuration_manager = FileManager("configuration.csv",
                                              _default_configuration_values)
Esempio n. 10
0
    def __init__(self):
        QtGui.QMainWindow.__init__(self)

        # Setup
        self.setupUi(self)

        # Attributes
        self.fin = Fin()  # Fin is an attribute: loaded fin
        self.fm = FileManager()  # File I/O

        # Initialize the table
        self.__updateTable()

        # print self.tab_inpoints.item(1,1).text()
        # print self.tab_inpoints.rowCount()

        self.__connectWidgets()
Esempio n. 11
0
class SubmissionChecker:
    def __init__(self, submission_data: SubmissionData, config: Config):
        self.submission_name: str = submission_data.name
        self.filename = submission_data.file_name  # TODO remove this dependency
        self.exe_name = config.exe_filename
        self.functions_data: List[FunctionData] = submission_data.functions
        self.path_manager = PathManager("submission-checker", submission_data,
                                        config)
        self.file_manager = FileManager(self.path_manager)
        self.input_handler = InputHandler(True)

    def start_session(self):
        self.file_manager.unzip_all_files(self.confirm)
        for student in self.file_manager.students_list:
            self.file_manager.create_test_dir(student)
            self.evaluate_submission(student)

    def evaluate_submission(self, student):
        content = self.file_manager.get_file_content(student, self.filename)
        if content:
            tester = Tester(self.path_manager.get_test_path(student),
                            self.filename, self.exe_name, student, content)
            res = True
            while res:
                print("\n\n*** checking submission from " + student)
                write_message(student)
                # TODO EW next two lines
                content = self.file_manager.get_file_content(
                    student, self.filename)
                tester.reload_content(content)
                print(tester.content)
                for func in self.functions_data:
                    self.run_tests(tester, func)
                res = self.confirm(Confirmations.RECHECK_SUBMISSION)

    def run_tests(self, tester: Tester, func):
        print(f"*** {OKBLUE}testing function {func.name} {ENDC}***")
        write_message("\t" + func.name)
        tester.change_function(func.name)
        for test in func.tests:
            # TODO test.f_input instead of test.input
            try:
                tester.run(test.input, test.output)
            except CalledProcessError:
                print("check this out")
        comment = self.confirm(Confirmations.ADDITIONAL_COMMENTS)
        if comment:
            write_message(comment)

    def confirm(self, confirmation):
        return self.input_handler.confirm(confirmation)
Esempio n. 12
0
    def select(self, data, myself, aims):
        #
        move = None
        # 获取当前攻击方
        attacker = data[myself]["base_info"]
        pkmon_name = attacker["name"]

        battle_info = data[myself]["battle_info"]
        moves = battle_info["moves"]
        if myself == "player":

            # choose = int(input())
            choose = random.randint(1, 4)
            if choose == 1:
                move = 'move1'
            elif choose == 2:
                move = 'move2'
            elif choose == 3:
                move = 'move3'
            elif choose == 4:
                move = 'move4'
            else:
                print("啥都没做")
        else:
            move = "move" + str(random.randint(1, 4))
        # 选其中一个技能
        moveinfo = moves[move]
        print("%s使出了%s" % (pkmon_name, moveinfo["name"]))
        # 计算是否命中
        isHit = self.is_move_accuracy(moveinfo, data, myself, aims)
        if isHit is True:
            # 判断技能类型进行伤害计算后返回计算后的值
            data = self.move_effect(moveinfo, data, myself, aims)

        # 保存伤害计算结果
        FileManager().save_battle_env(data)
Esempio n. 13
0
        # Insert current date and time to spreadsheet.
        if data:
            newSheet.insert_row([str(datetime.now())], 2)

    # from the files that are downloaded, get them and put them in google sheets
    # assumption: the .csv files are deleted after inserted into google sheets.
    def putFilesInGoogleSheets(self, filemanager):
        content = filemanager.mergeCSVFiles().read()

        sheet = self.client.open('cryptoscreener')
        print(sheet)
        self.client.import_csv(sheet.id, content)


bot = TradingviewBot()
manager = FileManager()
sUpdater = SpreadsheetUpdater(bot.args['pair'])

print(bot.args['pair'])
# bot.signIn()
# print('Sign in stage completed')
#
# bot.downloadAll()
# print('download stage completed')

sUpdater.putFilesInGoogleSheets(manager)
print('Files in google sheets stage completed')

newSheet = sUpdater.openNewSheet()
sUpdater.searchAndCopy(newSheet, manager)
print('Search and copy stage completed')
Esempio n. 14
0
                # we had issues with this mainly for test 9.
                ESTR.resetESTR() 
                time.sleep(0.5)
                # send the desired test number to the ESTR
                COM.sendStr(item)

################################ MAIN LOOP ##########################################
printMenu()

# Make an object to represent the Stellaris and reset device.
ESTR = LoadTest()
ESTR.resetESTR()

# Create two log files. One for raw COM port data, the other
# for interpreted test results.
dataLog = FileManager("logs/datalog{}.txt")
resultLog = FileManager("logs/resultlog{}.txt")

#try to open the COM port to connect to ESTR
try:
    COM = Comms("COM39", 115200*2) #57600 #203400
except:
    quit_event.set()
    print("COM port could not be opened! Exiting...")

# Create a queue to communicate between COM producer thread
# and COM worker thread.
COMQueue = Queue.Queue()

# Create three daemom threads, one to read the COM port, one to 
# work on the COM data and the last to read the command line interface
Esempio n. 15
0
if args.path is None or \
        args.maillist is None or \
        args.timeDiff is None or \
        args.file is None or \
        args.screen is None or \
        args.siteName is None or \
        args.isCSV is None:
    print('One of the parameter missing.')
    sys.exit(0)

if os.path.isdir(args.path) is not True:
    print('Directory Not exist.')
    sys.exit(0)

f = FileManager()
f.setFile(args.file)


def sendMailtoDIH(screen=False, timeAhead=False):
    global emailtoDIH
    if not emailtoDIH:
        print('sending to dih')
        config = configparser.ConfigParser()
        config.read('./Config/mailList.ini')
        if config.has_section('dih.support'):
            senderList = [x[1] for x in config.items('dih.support')]
            config.clear()
            config.read('./Config/messages.cfg')
            messageList = [x[1] for x in config.items('dih.support')]
            service = Mail()
Esempio n. 16
0
import sys
from fileManager import FileManager
from VMTranslator import VMTranslator

if __name__ == "__main__":

    files = sys.argv
    files = files[1:]
    fm = FileManager()
    if (len(files) == 0):
        print('At least one .vm file must be passed to the program')
        exit()
    else:
        file_name = ''
        translator = VMTranslator()
        trans_lines = [translator.init_MIPS_ASM()]
        print(files[0])
        fm.write(files[0], trans_lines)
        for i in files:
            lines = fm.read(i)
            if (i.find('\\') != -1):
                file_name = i[i.rfind('\\') + 1:i.rfind('.')]
            else:
                file_name = i[:i.rfind('.')]
            trans_lines.append(translator.translate(lines, file_name))

        fm.write(files[0], trans_lines)
Esempio n. 17
0
def execute():
    global spritesMatrix, piecesMatrix, playerMove, movesCount, log, playerColor, AIColor, missedPiecesPlayer
    catched = False  #permite saber si ya ha elegido una pieza
    sprite = ""
    piece = ""
    done = False
    endGame = False
    winnerColor = "Partida sin concluir"
    iniX = 0
    iniY = 0
    iniPosI = 0
    iniPosJ = 0
    iniMatrix = FileManager.getMatrix()
    locate(iniMatrix)
    startCol = FileManager.getStartColor()
    AICol = FileManager.getAIColor()
    inteligence = AI()
    posibleMoves = []
    if (AICol == startCol):
        playerMove = False
    else:
        playerMove = True

    if (('B' in AICol) or ('b' in AICol) or ('w' in AICol) or ('W' in AICol)):
        AIColor = "Blanco"
        playerColor = "Negro"
    else:
        AIColor = "Negro"
        playerColor = "Blanco"
    inteligence.missedPieces = FileManager.getMissedPieces(iniMatrix, AIColor)
    missedPiecesPlayer = FileManager.getMissedPieces(iniMatrix, playerColor)
    drawInfo(endGame, winnerColor)
    textBox.Draw()
    isMusicPlaying = True
    while not done:

        for event in pygame.event.get():

            if event.type == pygame.QUIT:
                done = True
            if event.type == pygame.KEYDOWN:
                if (event.key == 27):
                    done = True
                elif (event.key == 109 or event.key == 32):
                    if (isMusicPlaying):
                        pygame.mixer.music.stop()
                        isMusicPlaying = False
                    else:
                        pygame.mixer.music.play(-1)
                        isMusicPlaying = True

            if event.type == pygame.MOUSEBUTTONDOWN:

                if (event.button == 4):
                    if (boardSurface.collidepoint(pygame.mouse.get_pos())):
                        textBox.MoveUp()
                        drawInfo(endGame, winnerColor)
                        textBox.Draw()

                if (event.button == 5):
                    if (boardSurface.collidepoint(pygame.mouse.get_pos())):
                        textBox.MoveDown()
                        drawInfo(endGame, winnerColor)
                        textBox.Draw()

                if (event.button == 3):
                    catched = False
                coorX = roundBy75(pygame.mouse.get_pos()[0])
                coorY = roundBy75(pygame.mouse.get_pos()[1])
                loc = buscarIndice(coorX, coorY)
                if (event.button == 1 and playerMove and loc != (-1, -1)
                        and not (endGame)):
                    if (not catched):
                        iniPosI = loc[0]
                        iniPosJ = loc[1]
                        iniX = coorX
                        iniY = coorY
                        sprite = spritesMatrix[loc[0]][loc[1]]
                        piece = piecesMatrix[loc[0]][loc[1]]
                        if ((sprite in whitePieces) and ('B' in playerColor)
                                and (sprite != "")):
                            catchSound.play()
                            catched = True
                            posibleMoves = rules.GetListOfValidMoves(
                                piecesMatrix, playerColor, (iniPosI, iniPosJ))
                        elif ((sprite in blackPieces) and ('N' in playerColor)
                              and (sprite != "")):
                            catchSound.play()
                            catched = True
                            posibleMoves = rules.GetListOfValidMoves(
                                piecesMatrix, playerColor, (iniPosI, iniPosJ))
                    else:
                        if (rules.IsLegalMove(piece, piecesMatrix,
                                              (iniPosI, iniPosJ),
                                              (loc[0], loc[1]))
                                and not (rules.DoesMovePutPlayerInCheck(
                                    piecesMatrix, playerColor,
                                    (iniPosI, iniPosJ), (loc[0], loc[1])))):
                            spritesMatrix[iniPosI][iniPosJ] = ""
                            piecesMatrix[iniPosI][iniPosJ] = ""
                            if (AIColor[0] in piecesMatrix[loc[0]][loc[1]] and
                                    not ('P' in piecesMatrix[loc[0]][loc[1]])):
                                inteligence.missedPieces.append(
                                    piecesMatrix[loc[0]][loc[1]])
                            moveAnimation(sprite, iniX, iniY, coorX, coorY,
                                          spritesMatrix)
                            spritesMatrix[loc[0]][loc[1]] = sprite
                            piecesMatrix[loc[0]][loc[1]] = piece
                            strMove = str(
                                movesCount
                            ) + ". " + piece + "  " + converIndCol(
                                iniPosJ) + ":" + converIndFil(
                                    iniPosI) + " -> " + converIndCol(
                                        loc[1]) + ":" + converIndFil(loc[0])
                            log += strMove + "\n"

                            iniX = 0
                            iniY = 0
                            iniPosI = 0
                            iniPosJ = 0
                            catched = False
                            playerMove = not playerMove
                            drawInfo(endGame, winnerColor)
                            drawMessage(strMove)

                            if ("BP" == piece
                                    and loc[0] == 0) or ("NP" == piece
                                                         and loc[0] == 7):
                                main_window = tk.Tk()
                                app = selectionWindow(main_window)
                                app.setItems(missedPiecesPlayer)
                                main_window.attributes('-topmost', True)
                                main_window.mainloop()

                                if (app.name != ""):
                                    spritesMatrix[loc[0]][loc[1]] = getSprite(
                                        app.name)
                                    piecesMatrix[loc[0]][loc[1]] = app.name
                                    missedPiecesPlayer.remove(app.name)
                            movesCount += 1
                            drawMatrix()
                            fill(spritesMatrix)
                            pygame.display.update()
                            if (rules.IsCheckmate(piecesMatrix, AIColor)):
                                winnerColor = playerColor
                                endGame = True
                                drawInfo(endGame, winnerColor)
                                textBox.Draw()

            #--- computer move
            if (not playerMove and not endGame):
                move = inteligence.play(piecesMatrix, AIColor)
                if (move[2] < -10000):
                    print("**forced mate**")
                    winnerColor = playerColor
                    endGame = True
                    drawInfo(endGame, winnerColor)
                    textBox.Draw()
                iniPos = move[0]
                finPos = move[1]
                sprite = spritesMatrix[iniPos[0]][iniPos[1]]
                piece = piecesMatrix[iniPos[0]][iniPos[1]]
                iniCoord = gameMatrix[iniPos[0]][iniPos[1]]
                finCoord = gameMatrix[finPos[0]][finPos[1]]

                spritesMatrix[iniPos[0]][iniPos[1]] = ""
                piecesMatrix[iniPos[0]][iniPos[1]] = ""
                if (playerColor[0] in piecesMatrix[finPos[0]][finPos[1]]
                        and not ('P' in piecesMatrix[finPos[0]][finPos[1]])):
                    missedPiecesPlayer.append(
                        piecesMatrix[finPos[0]][finPos[1]])
                moveAnimation(sprite, iniCoord[0], iniCoord[1], finCoord[0],
                              finCoord[1], spritesMatrix)
                spritesMatrix[finPos[0]][finPos[1]] = sprite
                piecesMatrix[finPos[0]][finPos[1]] = piece
                if ("BP" == piece and finPos[0] == 0) or ("NP" == piece
                                                          and finPos[0] == 7):
                    pieceName = inteligence.getMaxMissedPiece(AIColor)
                    spritesMatrix[finPos[0]][finPos[1]] = getSprite(pieceName)
                    piecesMatrix[finPos[0]][finPos[1]] = pieceName
                strMove = str(movesCount) + ". " + piece + "  " + converIndCol(
                    iniPos[1]) + ":" + converIndFil(
                        iniPos[0]) + " -> " + converIndCol(
                            finPos[1]) + ":" + converIndFil(finPos[0])
                log += strMove + "\n"
                playerMove = not playerMove
                drawInfo(endGame, winnerColor)
                drawMessage(strMove)
                movesCount += 1
                if (rules.IsCheckmate(piecesMatrix, playerColor)):
                    drawMatrix()
                    fill(spritesMatrix)
                    pygame.display.update()
                    winnerColor = AIColor
                    endGame = True
                    drawInfo(endGame, winnerColor)
                    textBox.Draw()

        drawMatrix()
        if (catched):
            gameDisplay.blit(cyanSquare, (iniX, iniY))
            for move in posibleMoves:
                gameDisplay.blit(cyanSquare, (gameMatrix[move[0]][move[1]]))
        fill(spritesMatrix)

        pygame.display.update()
        clock.tick(60)
    time = datetime.datetime.now()
    strOutput = "Partida: " + str(
        time
    ) + "\nAI: " + AIColor + "\nJugador: " + playerColor + "\n\nGanador: " + winnerColor + "\n***********************\n" + log
    fileName = "matches//" + str(time).replace(":", ".") + ".txt"
    FileManager.save(fileName, strOutput)
    pygame.quit()
Esempio n. 18
0
 def __enter__(self):
     self.fManager = FileManager(self.filename)
     self.events = self.fManager.readEvents()
     self.painter = Painter()
     return self
Esempio n. 19
0
class Gui(QtGui.QMainWindow, Ui_MainWindow):

    n_rows = 0
    contourResolution = 2000

    def __init__(self):
        QtGui.QMainWindow.__init__(self)

        # Setup
        self.setupUi(self)

        # Attributes
        self.fin = Fin()  # Fin is an attribute: loaded fin
        self.fm = FileManager()  # File I/O

        # Initialize the table
        self.__updateTable()

        # print self.tab_inpoints.item(1,1).text()
        # print self.tab_inpoints.rowCount()

        self.__connectWidgets()

    def __connectWidgets(self):
        self.connect(self.but_genSpline, QtCore.SIGNAL("clicked()"), self.genSpline)
        self.connect(self.but_genSurf, QtCore.SIGNAL("clicked()"), self.genSurf)
        self.connect(self.spin_rows, QtCore.SIGNAL("editingFinished()"), self.updateRows)
        self.connect(self.actionSaveAs, QtCore.SIGNAL("triggered()"), self.saveFFD)
        self.connect(self.actionOpenFile, QtCore.SIGNAL("triggered()"), self.openFFD)
        self.connect(self.contour_resolution, QtCore.SIGNAL("valueChanged( int )"), self.setContourResolution)
        self.connect(self.butBrowseSVG, QtCore.SIGNAL("clicked()"), self.selectSvgFile)

    # Remains here to be compatble with original code but is redirected to new code
    def updateRows(self):
        self.setRows(self.spin_rows.value())

    # Set the amount of datapoints (or rows)
    def setRows(self, amount):
        self.n_rows = amount
        self.tab_inpoints.setRowCount(amount)
        self.spin_rows.setValue(int(amount))

    def __updateTable(self):
        data = self.fin.pointdata
        self.n_rows = len(data)  # amount of data points
        self.tab_inpoints.setRowCount(self.n_rows)
        self.spin_rows.setValue(self.n_rows)
        for col in arange(0, 2):
            for row in arange(0, len(data)):
                item = QtGui.QTableWidgetItem()
                item.setText(str(data[row, col]))
                self.tab_inpoints.setItem(row, col, item)

    # Set the currently loaded fin
    def setFin(self, fin):
        self.fin = fin
        self.__updateTable()

    def setContourResolution(self, resolution):
        self.contourResolution = resolution
        self.contour_resolution.setValue(int(resolution))

    def genSpline(self):
        self.fin.set_con_resolution(self.contour_resolution.value())

        if self.radioManualInput.isChecked():
            # Read table:
            n_rows = self.tab_inpoints.rowCount()
            data = zeros((n_rows, 2))
            for i in arange(0, n_rows):
                data[i, 0] = float(self.tab_inpoints.item(i, 0).text())
                data[i, 1] = float(self.tab_inpoints.item(i, 1).text())

            self.fin.set_pointdata(data)

            self.fin.gen_contour_fspline()

        elif self.radioImportSVG.isChecked():
            #            pathName = self.linePathName.text()
            self.fin.genContourSVG(str(self.lineSelectedSVG.text()))

        self.fin.plot_contour()
        # self.fin.show_plot()

    def genSurf(self):
        # Read gui input
        xres = self.Xresolution.value()
        yres = self.Yresolution.value()
        thickness = self.spin_thickness.value()
        layer_thick = self.spin_layer.value()

        # Generate
        self.fin.set_resolution([xres, yres])
        self.fin.set_basethickness(thickness * 2)

        if self.exponentialThicknessRadio.isChecked():
            self.fin.gen_surface(self.spin_exponConstant.value())
        elif self.percentualThicknessRadio.isChecked():
            self.fin.gen_surface(-float(self.spin_percentualConstant.value()) / 100)
        else:
            self.fin.gen_surface(0)

        self.fin.plot_surface(layer_thick)
        # self.fin.show_plot()

    def saveFFD(self):
        print "saveFFD"

        # Generate an ffd file of current configuration
        ffd = self.generateFFD()
        # load it into the filemanager
        self.fm.loadObject(ffd)

        saveFile = QtGui.QFileDialog.getSaveFileName(self, "Save file", "", ".ffd")

        # saveFile = saveFile.replace(" ","\ ")
        # saveFile = saveFile.replace("(","\(")
        # saveFile = saveFile.replace(")","\)")

        name = saveFile
        print saveFile

        # write to file
        self.fm.saveLoadedObject(name)

    def openFFD(self):
        print "openFFD"

        filename = QtGui.QFileDialog.getOpenFileName(self, "Open file", "", "*.ffd")

        self.fm.loadObjectFromFile(filename)
        ffd = self.fm.getLoadedObject()

        # SET FIN
        self.setFin(ffd.getFin())

        # SET CONTOUR SETTINGS
        rows = ffd.getContourSetting("nrows")
        contour_resolution = ffd.getContourSetting("contour_resolution")

        #
        self.setContourResolution(contour_resolution)
        self.setRows(rows)

        # SET SURFACE SETTINGS
        self.spin_thickness.setValue(ffd.getSurfaceSetting("fin_base_thickness"))
        self.spin_layer.setValue(ffd.getSurfaceSetting("layer_thickness"))
        self.Xresolution.setValue(ffd.getSurfaceSetting("XResolution"))
        self.Yresolution.setValue(ffd.getSurfaceSetting("YResulution"))

    def generateFFD(self):
        ffd = FFD()

        # add fin
        ffd.setFin(self.fin)

        # add contour settings
        ffd.addContourSetting("nrows", self.n_rows)
        ffd.addContourSetting("contour_resolution", self.contour_resolution.value())

        ffd.addSurfaceSetting("fin_base_thickness", self.spin_thickness.value())
        ffd.addSurfaceSetting("layer_thickness", self.spin_layer.value())
        ffd.addSurfaceSetting("XResolution", self.Xresolution.value())
        ffd.addSurfaceSetting("YResulution", self.Yresolution.value())

        return ffd

    def selectSvgFile(self):
        filename = QtGui.QFileDialog.getOpenFileName(self, "Import SVG file", "", "*.svg")
        self.lineSelectedSVG.setText(filename)
Esempio n. 20
0
from flask import Flask, escape, request, render_template, url_for, redirect # Flask tools
import logging # Enable logging
import os # Enable OS tools
import time # Use time to get last access
# from orchestrator import Orchestrator # This is meant to be a class that reads CPU and net usage and determined the most optimal workload.
from encoder import Encoder # This is our code creator
from forms import Transform # This is our Flask webpage
from fileManager import FileManager, logsFile # This will manage out filesystem
from urlData import URLData # This is the object that holds the data and metadata for each link
# from tables import makeTable # This is meant to be an object that formats HTML tables



# fileManager will be responsible in interacting with our OS's file system
fileManager = FileManager()


# Define logs file
logsFile = "/urlshortener/logs.log"

 ### ENABLE LOGS ###
LOG_FORMAT = "%(levelname)s %(asctime)s %(message)s"
logging.basicConfig(filename = logsFile, level=logging.DEBUG, format=LOG_FORMAT) # FOR SERVER TESTING
#logging.basicConfig(filename = "/home/taitz/Documents/Python/urlshortener/logs.log", level=logging.DEBUG, format=LOG_FORMAT) # FORM LOCAL TESTING
logger = logging.getLogger()

### Clear logger ###
try:
    open(logsFile, "w").close()
except OSError:
Esempio n. 21
0
class DatabaseManager:
    def __init__(self):
        self.log_manager = FileManager("log.csv",
                                       _default_log_values)
        self.command_manager = FileManager("commands.csv",
                                           _default_command_values)
        self.configuration_manager = FileManager("configuration.csv",
                                                 _default_configuration_values)

    def set_gesture(self, gesture_name, now):
        self.log_manager.append_line(''.join((now.isoformat()[:10], "    ",
                                              now.isoformat()[12:19], "    ", gesture_name, " \n")))

    def set_gesture_sequence(self, gesture_sequence, now, was_recognised):
        if was_recognised:
            ending = "] recognised."
        else:
            ending = "] not recognised."

        self.log_manager.append_line(''.join((now.isoformat()[:10], "    ",
                                              now.isoformat()[12:19], "    ", "pattern: [",
                                              ", ".join(gesture_sequence), ending, " \n")))

    def set_gesture_sequence_link(self, device, device_linked, state, now):
        if device_linked:
            ending = " is now " + state + "."
        else:
            ending = " is not linked to the system. No state change will be observed."

        self.log_manager.append_line(''.join((now.isoformat()[:10], "    ",
                                              now.isoformat()[12:19], "    ", device, ending, " \n")))

    def set_gesture_sequence_error(self, output):
        self.log_manager.append_line(output)

    def get_gestures(self):
        return self.log_manager.get_lines()

    def set_command(self, gesture_sequence, command_text, device_name):
        commands = self.get_commands()
        is_registered = False
        line_index = 0

        for command in commands:
            if command["gesture_sequence"] == gesture_sequence:
                is_registered = True
                break
            else:
                line_index += 1

        gesture_sequence = '-'.join(gesture_sequence)
        line_contents = gesture_sequence + ', ' + command_text + ', ' + device_name + '\n'

        if is_registered:
            self.command_manager.set_line(line_index, line_contents)
        else:
            self.command_manager.append_line(line_contents)

    def get_commands(self):
        lines = self.command_manager.get_lines()
        commands = []
        for line in lines:
            line = line.split(', ')
            commands.append({
                "gesture_sequence": line[0].split('-'),
                "command_text": line[1],
                "device_name": line[2][:-1]
            })
        return commands

    def __set_configuration__(self, column_name, value):
        self.configuration_manager.set_line(
            _get_configuration_index(column_name), str(value) + "\n")

    def __get_configuration__(self, column_name):
        return self.configuration_manager.get_line(
            _get_configuration_index(column_name))

    def set_open_eye_threshold(self, new_open_eye_ratio):
        self.__set_configuration__('open_eye_ratio', new_open_eye_ratio / 100)

    def get_open_eye_threshold(self):
        return  float(self.__get_configuration__('open_eye_ratio')) * 100
 
    def set_minimum_time_increment(self, new_minimum_time_increment):
        self.__set_configuration__('minimum_time_increment', new_minimum_time_increment)

    def get_minimum_time_increment(self):
        return float(self.__get_configuration__('minimum_time_increment'))

    def set_maximum_time_increment(self, new_maximum_time_increment):
        self.__set_configuration__('maximum_time_increment', new_maximum_time_increment)

    def get_maximum_time_increment(self):
        return float(self.__get_configuration__('maximum_time_increment'))
import sys
from fileManager import FileManager
from VMParser import Parser

if __name__ == "__main__":

    files = sys.argv
    files = files[1:]
    fm = FileManager()
    if (len(files) == 0):
        print('At least one .vm file must be passed to the program')
        exit()
    else:
        file_name = ''
        parser = Parser()
        for i in files:
            lines = fm.read(i)
            if (i.find('\\') != -1):
                file_name = i[i.rfind('\\') + 1:i.rfind('.')]
            else:
                file_name = i[:i.rfind('.')]
            trans_lines = parser.parse(lines, file_name)
            for i in trans_lines:
                print(i)