Ejemplo n.º 1
0
 def __init__(self, name, command, positions, verbose):
     Thread.__init__(self)
     self._name = name
     self._positions = positions
     self._verbose = verbose
     command = command + " --logfile-name=" + name + ".log"
     self._program = Program(command, verbose)
Ejemplo n.º 2
0
def send_program():
    json_data = request.args.get('json_data')
    print("======>>>json_data" + json_data)
    program = Program(json_data)
    prog_name = program.send_program()
    print("send program:" + prog_name)
    return {"code": "200", "program_name": prog_name}
def P15():
    p = Program(num_prog_inputs=2)
    p.create_add_component()
    p.create_and_component()
    p.create_xor_component()
    p.create_bitshiftright_component(1)
    return ProgramSynthesis(p, BVT.P15, 'P15')
Ejemplo n.º 4
0
def main():
    print("Start")
    #The first 2 parameters are msg_id, sig_name by which to filter the display of real-time data
    #The next 2 params are the paths of the file containing the dbc definition file (in json) and the data trace
    program = Program('c000003', 'TSC1EMSTECU_EngReqTrq_HR', 'data/convereted_dbc_to_json.json', "data/trace.asc")

    program.plot()
Ejemplo n.º 5
0
 def test_detach(self):
     vert = VertexShader("A")
     frag = FragmentShader("B")
     program = Program(vert, frag)
     program.detach(frag)
     assert len(program.shaders) == 1
     assert program.shaders[0].code == "A"
Ejemplo n.º 6
0
 def __init__(self, settings=None):
     # self.settings = settings
     Program.__init__(self, settings)
     Driver.__init__(self, settings)
     print("initializing viewer")
     self.settings = settings
     if self.settings["verbose"]:
         print()
         print("Settings:")
         print()
         print(
             pformat([f"{k}: {v}" for k, v in settings.items()
                      ]).lstrip('[').rstrip(']'))
         print()
     self.env = Environment(DEFAULT_VARS)
     # programs should be loaded from a directory located by a configuration file setting
     self.programs = list()
     self.fig = plt.figure()
     self.ax = self.fig.add_subplot(111,
                                    projection='3d',
                                    xlim=(0, 6),
                                    ylim=(0, 6))
     # self.ax.plot([0.0, 1.0], [0.2, 0.7], 0.4)
     self.current_position = Point()
     plt.show()
     self.current_program = NCProgram()
Ejemplo n.º 7
0
def main():
    root = tkinter.Tk()
    from libs import painter

    #import pdb;pdb.set_trace()
    program = Program(painter)
    try:
        fileToLoad = sys.argv[1]
    except IndexError:
        print("Ne file specified, opening first.lsa")
        fileToLoad = "first.lsa"
    program.load_file(fileToLoad)

    #Create the gui widgets
    menuBar = gui.MenuBar(root, program)
    stepChanger = gui.StepChanger(root, program)
    text = gui.TextInput(root, program)
    contextShower = painter.ContextShower(root)
    activeStateShower = gui.ActiveStateShower(root, program, contextShower)
    stepOutput = gui.StepOutput(root, text, program)
    textHelp = gui.TextHelp(root, text, program)
    help = gui.HelpShower(root, program)

    #Place them in the rigth order
    root['menu'] = menuBar
    root.grid_propagate(True)
    stepChanger.grid(row=0, column=0, columnspan=50, sticky="nesw")
    vScrollbar = tkinter.Scrollbar(root, orient=tkinter.VERTICAL)
    vScrollbar.grid(row=1, column=0, sticky="nesw")
    text.grid(row=1, column=10, sticky="nesw")
    textHelp.grid(row=1, column=11, sticky="nesw")
    stepOutput.grid(row=1, column=12, sticky="nesw")
    activeStateShower.grid(row=1, column=13, sticky="nesw")
    help.grid(row=2, column=0, columnspan=50, sticky="nesw")
    root.columnconfigure(0, weight=0)
    root.columnconfigure(10, weight=2)
    root.columnconfigure(11, weight=1)
    root.columnconfigure(12, weight=2)
    root.columnconfigure(13, weight=0)
    root.rowconfigure(0, weight=0)
    root.rowconfigure(1, weight=1)
    root.rowconfigure(2, weight=0)

    def proxy_yview(*args, **kwords):
        text.yview(*args, **kwords)
        textHelp.on_activeStep_changed()
        stepOutput.on_steps_changed()

    def proxy_set(*args, **kwords):
        vScrollbar.set(*args, **kwords)
        textHelp.on_activeStep_changed()
        stepOutput.on_steps_changed()

    text['yscrollcommand'] = proxy_set
    vScrollbar['command'] = proxy_yview

    # create the interpretor and go, go, go
    interpretor = interpreter.Interpreter(program)
    root.after(500, lambda : program.event("source_changed")())
    root.mainloop()
Ejemplo n.º 8
0
def main(argv=None, syslog=syslog):

    if argv is None:
        argv = sys.argv[1:]
        program = Program(__version__, __updated__, argv, syslog)
        program.mainLoop()
    program.logFinish()
Ejemplo n.º 9
0
	def message_wylio(self, event):
		global program
		try:
			log("WylioServer message wylio received")
			print event['wylio']
			if event['wylio']['run']:
				#print "run in wylio"
				code = event['wylio']['run']
				file = open('received_program.py', 'w')
				file.write(code)
				file.close()
				if program != None:
					program.stop()
				program = Program(1,'received_program.py')
				try:
					thread.start_new_thread(program.run,(self,event['from']))
					print "created thread"
				except:
					traceback.print_exc()
					log("Error creating thread")
			if event['wylio']['value']:
				signal = event['wylio']['value']['signal']
				value = event['wylio']['value']['value']
				if program != None:
					program.sendSensorInput(signal,value)
		except:
			traceback.print_exc()
Ejemplo n.º 10
0
    def jumpleq(state: Program, address1: int, address2: int, address3: int):
        """If Value in Address 1 <= Value in Address 2, Jump to Address 3

        Args:
            state: the program state
            address1: address 1
            address2: address 2
            address3: the address to jump to

        Notes:
            Rules for legal argument ranges and syntactical correctness:
            Jumps may lead to any address in the dynamic range [Min, Max + 1]
        """
        address1 = state.read(state, address1)
        if state.halt is not None:
            return

        address2 = state.read(state, address2)
        if state.halt is not None:
            return

        if address1 <= address2:
            Primitives.jump(state, address3)
            if state.halt is not None:
                return
        else:
            state.jumped = False
Ejemplo n.º 11
0
def run_mem(savedstate=""):
    with zipfile.ZipFile(os.path.join("source", "challenge.zip"), 'r') as zip:
        machine = zip.read('challenge.bin')
    program = Program()
    program.load_bytes(machine)
    show_all = False
    if len(savedstate):
        program.deserialize(savedstate)
    memory = []
    while True:
        program.run(abort_on_input=True)
        if len(memory) == 0:
            memory = program.memory[:]
        else:
            for i in range(len(memory)):
                if memory[i] != program.memory[i]:
                    if show_all or i == 2732:
                        print(f"{i} => {memory[i]} != {program.memory[i]}")
        temp = input("Step? ")
        if temp.startswith("all"):
            show_all = not show_all
        elif temp.startswith("room "):
            temp = temp[4:]
            program.memory[2732] = int(temp)
        elif temp.startswith("mem "):
            temp = temp[4:].split(' ')
            program.memory[int(temp[0])] = int(temp[1])
        elif temp == "reset":
            memory = program.memory[:]
        else:
            program.input_buffer += temp + "\n"
Ejemplo n.º 12
0
    def free(state: Program, address1: int):
        # No more than 5 work tape cells may be Allocated or Freed at a time.
        if address1 > 5 or address1 <= 0 or (state.min + address1) > 0:
            state.halt = HaltingCode.ERROR_FREE_OUT_BOUNDS
            return

        state.free(address1)
Ejemplo n.º 13
0
def search_next(cur, program, fo_remain, ho_remain, target_len):
    if len(program) == target_len:
        p = Program()
        for s in program:
            p.append_step(Step(*s))
        PROGRAMs.append(p)
        # print p
        return
    else:
        valid_fo_funcs = filter(lambda x: FUNCs['FO'][x][1][0] == cur[2] \
                if len(FUNCs['FO'][x][1]) == 1 \
                else FUNCs['FO'][x][1][1] == cur[2], fo_remain)
        # len(FUNCs['HO'][x][1]) == 2 \ and
        valid_ho_funcs = filter(lambda x: FUNCs['HO'][x][1][1] == cur[2],
                                ho_remain)
        for func in valid_fo_funcs:
            search_next(FUNCs['FO'][func], \
                    program+[(func,)], \
                    filter(lambda x: x!=func, valid_fo_funcs), \
                    valid_ho_funcs, \
                    target_len)
        for func in valid_ho_funcs:
            for lambs in filter(lambda x: (Lambdas[x][3], Lambdas[x][2])\
                    ==FUNCs['HO'][func][1][0], \
                    [l for l in Lambdas]):
                search_next(FUNCs['HO'][func], \
                        program+[(func, lambs)], \
                        valid_fo_funcs, \
                        filter(lambda x: x!=func, valid_ho_funcs), \
                        target_len)
Ejemplo n.º 14
0
 def test_detach(self):
     vert = VertexShader("A")
     frag = FragmentShader("B")
     program = Program(vert, frag)
     program.detach(frag)
     assert len(program.shaders) == 1
     assert program.shaders[0].code == "A"
Ejemplo n.º 15
0
def main():
    app = None

    try:
        from program import Program

        app = Program()
        app.run()

    except Exception as exc:
        traceback.print_exc(file=open(ERROR_LOG, "w"))

        class Error(App):
            theme_cls = kivymd.theming.ThemeManager()

            def report_callback(self, *args):
                try:
                    import webbrowser
                    webbrowser.open(PROJ_REPO + "/issues/new?body=" + str(exc))
                except Exception:
                    traceback.print_exc(file=open(ERROR_LOG, "w"))
                    sys.exit(1)

            def build(self):
                return BugReporter(report_callback=self.report_callback)

        Error().run()
Ejemplo n.º 16
0
def main():
    INSTRUCTION = """
0 - exit
1 - sort by name in non-decreasing order
2 - sort by name in non-increasing order
3 - sort by destination in non-decreasing order
4 - sort by destination in non-increasing order
5 - sort by flight number in non-decreasing order
6 - sort by flight number in non-increasing order
7 - sort by price in non-decreasing order
8 - sort by price in non-increasing order
9 - find aeroflots with provided destination
10 - find aeroflots with provided name
11 - find aeroflots with provided departure day
12 - add new aeroflot
13 - delete aeroflot by index
14 - edit aeroflot(enter index and field which you want to change)
15 - print aeroflots
"""
    print(INSTRUCTION)
    path_read = input("enter path_read: ")
    path_write = input("enter path_write: ")
    reader = ReadFromFile(path_read)
    file = FileEditor(path_write)


    collection = reader.read()
    menu = Program(collection)
    while True:
        try:
            menu.menu(file)
        except Exception as s:
            print(s)
Ejemplo n.º 17
0
def main():
    logging.basicConfig(level=logging.DEBUG)
    logging.info('Started')
    lv = LoadValues()
    lines = lv.strip_lines()

    instr = get_instructions(lines)
    prog = Program(instr)
    (_, ip, acc) = prog.does_terminate()
    print("Star 1 : ", acc)

    finished = None
    for (i, cur_instr) in enumerate(instr):
        if cur_instr[0] == 'nop' or cur_instr[0] == 'jmp':
            instr2 = instr.copy()
            if cur_instr[0] == 'nop':
                instr2[i] = ('jmp', cur_instr[1])
            else:
                instr2[i] = ('nop', cur_instr[1])
            (res, ip, acc) = Program(instr2).does_terminate()
            if res:
                finished = (ip, acc)
                break

    print("Star 2 : ", acc)

    logging.info('Finished')
Ejemplo n.º 18
0
    def execute(self, program: Program):
        variable = program.var_get('SETCHAR', self.args[0])
        index = program.get_symb('SETCHAR', self.args[1])
        toModify = program.get_symb('SETCHAR', self.args[2])

        if variable is None:
            exit_app(exitCodes.UNDEFINED_VALUE, 'SETCHAR\nUndefined variable.',
                     True)

        if not index.is_int() or not variable.is_string() or\
                not toModify.is_string():
            exit_app(exitCodes.INVALID_DATA_TYPE,
                     'SETCHAR\nExpected: string variable, int, string', True)

        if len(toModify.value) == 0 or index.value >= len(variable.value):
            exit_app(exitCodes.INVALID_STRING_OPERATION,
                     'SETCHAR\nZero length of to modify characters.', True)

        try:
            result = "{}{}{}".format(variable.value[:index.value],
                                     toModify.value[0],
                                     variable.value[index.value + 1:])
            program.var_set('SETCHAR', self.args[0],
                            Symbol(DataTypes.STRING, result))
        except IndexError:
            exit_app(exitCodes.INVALID_STRING_OPERATION,
                     'SETCHAR\nIndex is out of range.', True)
Ejemplo n.º 19
0
    def __parse_program():
        if Parser.tokens.current is None:
            raise ValueError("File cannot be empty")

        if Parser.tokens.current.type == "PROGRAM":
            Parser.tokens.next()
            if Parser.tokens.current.type == "IDENTIFIER":
                Parser.tokens.next()
                if Parser.tokens.current.type == "SEMICOLON":
                    Parser.tokens.next()

                    node = Program()

                    node.set_child(Parser.__parse_block())

                    if Parser.tokens.current is None or \
                            Parser.tokens.current.type != "DOT":
                        raise ValueError(
                            f"Expecting final dot (.). Got: {Parser.tokens.current.type}"
                        )
                else:
                    raise ValueError(
                        f"Fatal: Syntax error, \";\" expected" +
                        f" but \"{Parser.tokens.current.type}\" found")
            else:
                raise ValueError(
                    f"Fatal: Syntax error, \"IDENTIFIER\" expected" +
                    f" but \"{Parser.tokens.current.type}\" found")
        else:
            raise ValueError(f"Fatal: Syntax error, \"PROGRAM\" expected" +
                             f" but \"{Parser.tokens.current.type}" +
                             f" {Parser.tokens.current.value}\" found")

        return node
Ejemplo n.º 20
0
 def process_phase_sequence(self, phase_sequence):
     program_a = Program(self.program, default_inputs=[phase_sequence[0], 0])
     program_b = Program(self.program, default_inputs=[phase_sequence[1], program_a.outputs.pop()])
     program_c = Program(self.program, default_inputs=[phase_sequence[2], program_b.outputs.pop()])
     program_d = Program(self.program, default_inputs=[phase_sequence[3], program_c.outputs.pop()])
     program_e = Program(self.program, default_inputs=[phase_sequence[4], program_d.outputs.pop()])
     return program_e.outputs.pop()
Ejemplo n.º 21
0
def test_allocation_get_channel():
    program = Program([Push(0), Pop(0), Push(1), Push(2), Pop(2)])

    assert program.get_channel_for_port_key(0, KEY_CKS_DATA) == 0
    assert program.get_channel_for_port_key(0, KEY_CKS_CONTROL) == 3
    assert program.get_channel_for_port_key(1, KEY_CKR_DATA) is None
    assert program.get_channel_for_port_key(2, KEY_CKS_DATA) == 2
Ejemplo n.º 22
0
        def display():
            glClearColor(20 / 255, 20 / 255, 20 / 255, 1)

            ShadowProgram.use()
            glClear(GL_DEPTH_BUFFER_BIT)

            if not Display._show_shadow_map:
                glBindFramebuffer(GL_FRAMEBUFFER, ShadowMap.depth_buffer)

            glViewport(0, 0, ShadowMap.width, ShadowMap.height)
            glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT)
            glEnableClientState(GL_VERTEX_ARRAY)
            glBindBuffer(GL_ARRAY_BUFFER, Model.vbo)
            glVertexPointer(3, GL_FLOAT, 0, None)
            glBindBuffer(GL_ARRAY_BUFFER, 0)
            glDrawArrays(GL_TRIANGLES, 0, len(vertices))
            glDisableClientState(GL_VERTEX_ARRAY)

            if glCheckFramebufferStatus(
                    GL_FRAMEBUFFER) != GL_FRAMEBUFFER_COMPLETE:
                exit(1)

            Display._check_map()

            ShadowProgram.disable()

            if Display._show_shadow_map:
                glutSwapBuffers()
                glutPostRedisplay()
                return

            Program.use()
            glBindFramebuffer(GL_FRAMEBUFFER, 0)
            glClearDepth(1)
            glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT)

            glViewport(0, 0, Config.width, Config.height)
            glActiveTexture(GL_TEXTURE0)
            glBindTexture(GL_TEXTURE_2D, ShadowMap.depth_texture)

            glEnableClientState(GL_VERTEX_ARRAY)
            glEnableClientState(GL_TEXTURE_COORD_ARRAY)
            glEnableClientState(GL_NORMAL_ARRAY)
            glBindBuffer(GL_ARRAY_BUFFER, Model.vbo)
            glVertexPointer(3, GL_FLOAT, 0, None)
            glBindBuffer(GL_ARRAY_BUFFER, Model.tbo)
            glTexCoordPointer(2, GL_FLOAT, 0, None)
            glBindBuffer(GL_ARRAY_BUFFER, Model.nbo)
            glNormalPointer(GL_FLOAT, 0, None)
            glDrawArrays(GL_TRIANGLES, 0, len(vertices))
            glBindBuffer(GL_ARRAY_BUFFER, 0)
            glDisableClientState(GL_VERTEX_ARRAY)
            glDisableClientState(GL_TEXTURE_COORD_ARRAY)
            glDisableClientState(GL_NORMAL_ARRAY)

            Program.disable()

            glutSwapBuffers()
            glutPostRedisplay()
Ejemplo n.º 23
0
    def move(state: Program, address1: int, address2: int):
        address1 = state.read(state, address1)
        if state.halt is not None:
            return

        state.write(state, address2, address1)
        if state.halt is not None:
            return
Ejemplo n.º 24
0
 def reshape(width, height):
     Program.use()
     glViewport(0, 0, width, height)
     gluPerspective(100, width / height, 0.1, 50)
     gluLookAt(*(10, 10, 10), *(0, 0, 0), *(0, 1, 0))
     Display.width = width
     Display.height = height
     return
Ejemplo n.º 25
0
    def decrement(state: Program, address1: int):
        v1 = state.read(state, address1)
        if state.halt is not None:
            return

        state.write(state, address1, v1 - 1)
        if state.halt is not None:
            return
Ejemplo n.º 26
0
    def execute(self, program: Program):
        symb1 = program.get_symb(self.opcode, self.args[1])
        symb2 = program.get_symb(self.opcode, self.args[2])

        validate_math_symbols(self.opcode, symb1, symb2)

        result = self.compute(symb1, symb2)
        program.var_set(self.opcode, self.args[0], result)
Ejemplo n.º 27
0
    def execute(self, program: Program):
        if len(program.data_stack) == 0:
            exit_app(
                exitCodes.UNDEFINED_VALUE,
                'POPS\nInstruction {}. Data Stack is empty.'.format(
                    self.opcode), True)

        program.var_set('POPS', self.args[0], program.pop_stack(1)[0])
def test_P15():
    print('P15 program, floor of average of inputs, with debug printing:')
    p = Program(num_prog_inputs=2)
    p.create_add_component()
    p.create_and_component()
    p.create_xor_component()
    p.create_bitshiftright_component(1)
    timed_synthesis(p, BVT.P15, 100000, True)
Ejemplo n.º 29
0
    def execute(self, program: Program):
        symb = program.get_symb('TYPE', self.args[1], False)

        if symb is None:
            program.var_set('TYPE', self.args[0], Symbol(DataTypes.STRING, ''))
        else:
            program.var_set('TYPE', self.args[0],
                            Symbol(DataTypes.STRING, symb.data_type.value))
Ejemplo n.º 30
0
 def test_attach(self):
     vert = VertexShader("A")
     frag = FragmentShader("B")
     program = Program(vert)
     program.attach(frag)
     assert len(program.shaders) == 2
     assert program.shaders[0].code == "A"
     assert program.shaders[1].code == "B"
def P16():
    p = Program(num_prog_inputs=2)
    p.create_xor_component()
    p.create_xor_component()
    p.create_negate_component()
    p.create_and_component()
    p.create_ule_component()
    return ProgramSynthesis(p, BVT.P16, 'P16')
Ejemplo n.º 32
0
 def initgl(self):
     glEnable(GL_TEXTURE_2D)
     glEnable(GL_BLEND)
     glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA)
     self.program = Program.load(in_module('glsl/flat.glsl'))
     self.program_ms = Program.load(in_module('glsl/flat_ms.glsl'))
     self.use_program(self.resolution)
     self.stream = BufferStream(Vertex, GL_TRIANGLES)
Ejemplo n.º 33
0
    def execute(self, program: Program):
        arg = self.args[0]

        if program.var_exists(arg):
            exit_app(exitCodes.SEMANTIC_ERROR,
                     'DEFVAR\nVariable {} now exists. Cannot redefine.', True)

        program.var_set('DEFVAR', arg, None, True)
Ejemplo n.º 34
0
 def test_attach(self):
     vert = VertexShader("A")
     frag = FragmentShader("B")
     program = Program(vert)
     program.attach(frag)
     assert len(program.shaders) == 2
     assert program.shaders[0].code == "A"
     assert program.shaders[1].code == "B"
Ejemplo n.º 35
0
def main():
    parser = argparse.ArgumentParser(description='You started a proxy-script.'
                                     ' Enter your port to use '
                                     'this')
    parser.add_argument('-p', '--port', help='This will be your port')
    port = parser.parse_args().port
    prog = Program(port)
    prog.process()
Ejemplo n.º 36
0
def handle_program_status():
    """
    Expose the program status
    """
    logging.debug("program_status")
    prog = Program("")
    if app.prog:
        prog = app.prog
    return json.dumps({'name': prog.name, "running": prog.is_running(), "log": app.prog_engine.get_log()})
Ejemplo n.º 37
0
class Commander(object):
    
    def __init__(self, program):
        self.program = Program(program)
        self.army = list()
        self.enemies = list()
        self.army_name = self.find_army_name()
        
    def find_army_name(self):
        try:
            name = self.do_find_army_name()
        except Exception:
            # If program fails to implement -n properly, just choose
            # a random name.
            name = 'army-%d'% random.randint(1,10000000)
        return name
        
    def do_find_army_name(self):
        arguments = ProgramArguments()
        reader = FileReader(self)
        output_filename = FileUtils.get_new_filename()
        arguments.add('-n')
        arguments.add('-o', output_filename)
        self.program.execute(arguments)
        name = reader.read_name(output_filename)
        FileUtils.remove_file(output_filename)
        return name  
        
    def get_army_name(self):
        return self.army_name
        
    def get_army(self):
        return self.army
    
    def set_army(self, soldiers):
        map(self.set_army_on_soldier, soldiers)
        self.army = soldiers
    
    def set_army_on_soldier(self, soldier):
        army_name = self.get_army_name()
        soldier.set_army_name(army_name)
    
    def add_enemies(self, enemies):
        self.enemies.extend(enemies)
        
    def read_file_or_raise(self, filename, writer, context):
        reader = FileReader(context)
        try:
            data = reader.read(filename)
        except IOError:
            raise MissingFileException(self.army_name, self.program,
                                       writer.get_filename())
        except ParsingException, e:
            e.set_army_name(self.army_name)
            raise e
        else:
Ejemplo n.º 38
0
    def eval(self, text):
        """Respond to text entered by the user.

        :param text: the user's input
        """
        program = Program(text, echo=self.echo, transforms=self.transforms)
        tokens = program.gen_tokens()
        for sentence in program.gen_sentences(tokens, self.aliases):
            if self.echo:
                self.terminal.debug(str(sentence))
            program.interpret(sentence, self.commands)
Ejemplo n.º 39
0
Archivo: main.py Proyecto: coyf/agl
 def launch_f2c(self):
     is_running = False
     for p in psutil.process_iter():
         try:
             if p.name() == "FlowchartToCode.exe":
                 print "Flowchart To Code is already running"
                 is_running = True
         except psutil.error:
             pass
     if not is_running:
         f2c = Program(self.f2c_path)
         f2c.start()
         print "program {} started".format(self.f2c_path)
Ejemplo n.º 40
0
Archivo: main.py Proyecto: coyf/agl
 def launch_dia(self):
     is_running = False
     for p in psutil.process_iter():
         try:
             if p.name() == "dia.exe":
                 print "Dia is already running"
                 is_running = True
         except psutil.error:
             pass
     if not is_running:
         dia = Program(self.dia_path)
         dia.start()
         print "program {} started".format(self.dia_path)
Ejemplo n.º 41
0
Archivo: main.py Proyecto: coyf/agl
 def launch_intellij(self):
     is_running = False
     for p in psutil.process_iter():
         try:
             if p.name() == "idea.exe":
                 print "IntelliJ IDEA is already running"
                 is_running = True
         except psutil.error:
             pass
     if not is_running:
         intellij = Program(self.intellij_path)
         intellij.start()
         print "program {} started".format(self.intellij_path)
Ejemplo n.º 42
0
class programTest(unittest.TestCase):

    def setUp(self):
        self.fixture = Program(1, 1, "-d 1".split(' '), FakeSyslog())

    def test_default_options_are_set(self):
        fixture = self.fixture
        self.assertEqual('1', fixture.opts.keyid)
        self.assertEqual(None, fixture.opts.verbose)
        self.assertEqual('0000', fixture.opts.pin)
        self.assertEqual('/usr/lib/opensc-pkcs11.so', fixture.opts.module)
        self.assertEqual(None, fixture.opts.environment)
        self.assertEqual('localhost', fixture.opts.host)
        self.assertEqual(256, fixture.opts.inputlength)
        self.assertEqual(256, fixture.opts.outputlength)
        self.assertEqual('SHA512-RSA-PKCS', fixture.opts.mechanism)
        self.assertEqual(9999, fixture.opts.port)

    def test_keyid_can_be_given_with_d(self):
        self.fixture.parseArgs("-d 2222".split(' '))
        self.assertEqual('2222', self.fixture.opts.keyid)

    def test_verbose_can_be_set_with_v(self):
        self.fixture.parseArgs("-d 1 -v".split(' '))
        self.assertEqual(1, self.fixture.opts.verbose)

    def test_verbose_level_is_increased_with_all_v(self):
        self.fixture.parseArgs("-d 1 -vvvv".split(' '))
        self.assertEqual(4, self.fixture.opts.verbose)

    def test_outputlength_is_set_by_o(self):
        self.fixture.parseArgs("-d 1 -o 511".split(' '))
        self.assertEqual(511, self.fixture.opts.outputlength)
Ejemplo n.º 43
0
def execute_file(fname):
    program = Program(fname)
    state = ExecutionState()
    done = False

    try:
        while not done:
            pc = state.read_program_cntr()
            state.write_program_cntr(pc + 1)
            cmd = program.fetch(pc)
            if DEBUG_MODE:
                print "Executing: '"+str(cmd)+"'"
            done = cmd.execute(state)

    except Exception as e: print e
    finally: print "Stack:", str(state)
 def __init__(self, name, command, positions, verbose):
     Thread.__init__(self)
     self._name = name
     self._positions = positions
     self._verbose = verbose
     command = command + " --logfile-name=" + name + ".log"
     self._program = Program(command, verbose)
Ejemplo n.º 45
0
def load_programs_from_xml(xml_root, exercise_type_dict):
    program_dict = {}
    programs_node = xml_root.find("programs")
    for program_node in programs_node:
        program_name = program_node.get("name")
        program_description = program_node.get("description")
        program = Program(program_name, program_description)
        for action_node in program_node:
            action_exercise_name = action_node.get("exercise")
            action_exercise_type = exercise_type_dict[action_exercise_name]
            action_nb_series = int(action_node.get("nbSeries"))
            action_rest = int(action_node.get("rest"))
            action_min = int(action_node.get("min"))
            action_goal = int(action_node.get("goal"))
            program.add_action(action_exercise_type, action_nb_series, action_rest, action_min, action_goal)
        program_dict[program_name] = program
    return program_dict
Ejemplo n.º 46
0
class agent:
	def __init__(self, exe):
		self.exe = exe 
		self.program = Program(self.exe, True)
		self.name = self.program.sendCommand("name").strip()
		self.lock  = threading.Lock()

	def sendCommand(self, command):
		self.lock.acquire()
		answer = self.program.sendCommand(command)
		self.lock.release()
		return answer

	def reconnect(self):
		self.program.terminate()
		self.program = Program(self.exe,True)
		self.lock = threading.Lock()
Ejemplo n.º 47
0
 def __init__(self, output, default_font, program=None):
     self.output = output
     self.default_font = default_font
     self.stream = VertexStream(fmt)
     self.textures = TextureCache()
     if program is None:
         self.program = Program.load(in_module('shaders/flat.glsl'))
     else:
         self.program = program
Ejemplo n.º 48
0
 def create_program(self):
     self.command = 0
     self.program = Program(self.display)
     self.program.add_command("^", "Forward", self.wheels.forwards, self.wheels.stop)
     self.program.add_command("v", "Backward", self.wheels.backwards, self.wheels.stop)
     self.program.add_command("<", "Left", self.wheels.left, self.wheels.stop)
     self.program.add_command(">", "Right", self.wheels.right, self.wheels.stop)
     self.program.add_command("{", "Slow Left", self.wheels.slow_left, self.wheels.stop)
     self.program.add_command("}", "Slow Right", self.wheels.slow_right, self.wheels.stop)
     self.add_component("Program", self.program)
Ejemplo n.º 49
0
def main():
    app = None

    try:
        from program import Program  # основной класс программы

        # Запуск приложения.
        app = Program()
        app.run()
    except Exception as exc:
        print(traceback.format_exc())
        traceback.print_exc(file=open("{}/error.log".format(
            os.path.split(os.path.abspath(sys.argv[0]))[0]), "w"))

        if app:  # очищаем экран приложения от всех виджетов
            app.start_screen.clear_widgets()

        class Error(App):
            """Выводит экран с текстом ошибки."""

            def callback_report(self, *args):
                """Функция отправки баг-репорта"""

                try:
                    import webbrowser
                    import six.moves.urllib

                    txt = six.moves.urllib.parse.quote(
                        self.win_report.txt_traceback.text.encode(
                            "utf-8"))
                    url = "https://github.com/HeaTTheatR/KivyCleanMasterDemo" \
                          "/issues/new?body=" + txt
                    webbrowser.open(url)
                except Exception:
                    sys.exit(1)

            def build(self):
                self.win_report = BugReporter(
                    callback_report=self.callback_report, txt_report=str(exc),
                    icon_background="Data/Images/logo.png")
                return self.win_report

        Error().run()
Ejemplo n.º 50
0
class WrapperAgent(object):

    def __init__(self, executable, verbose=False):
        self.executable=executable
        self.program=Program(self.executable, verbose)
        self.name=self.program.sendCommand("name").strip()
        self.lock=threading.Lock()

    def sendCommand(self, command):
        self.lock.acquire()
        answer=self.program.sendCommand(command)
        self.lock.release()
        return answer

    def reconnect(self):
        self.program.terminate()
        self.program=Program(self.executable, True)
        self.lock=threading.Lock()

    def play_black(self, move):
        self.sendCommand("play black "+move)

    def play_white(self, move):
        self.sendCommand("play white "+move)

    def genmove_black(self):
        return self.sendCommand("genmove black").strip()

    def genmove_white(self):
        return self.sendCommand("genmove white").strip()

    def clear_board(self):
        self.sendCommand("clear_board")

    def set_board_size(self, size):
        self.sendCommand("boardsize "+repr(size))

    def play_move_seq(self, moves_seq):
        turn=0
        for m in moves_seq:
            self.play_black(m) if turn==0 else self.play_white(m)
            turn = (turn+1)%2
Ejemplo n.º 51
0
    def mutate(self, programs_population):
        """
        Generates mutation chances and mutate the team if it is a valid mutation.
        """
        if Config.USER['advanced_training_parameters']['use_agressive_mutations']:
            mutation_chance = 1
            while (mutation_chance > random.random() 
                and len(self.programs) > Config.USER['training_parameters']['team_size']['min']):
                self._randomly_remove_program()
                mutation_chance = mutation_chance * Config.USER['training_parameters']['mutation']['team']['remove_program']

            mutation_chance = 1
            while (mutation_chance > random.random() 
                and len(self.programs) < Config.USER['training_parameters']['team_size']['max']):
                self._randomly_add_program(programs_population)
                mutation_chance = mutation_chance * Config.USER['training_parameters']['mutation']['team']['add_program']
        else:
            if len(self.programs) > Config.USER['training_parameters']['team_size']['min']:
                mutation_chance = random.random()
                if mutation_chance <= Config.USER['training_parameters']['mutation']['team']['remove_program']:
                    self._randomly_remove_program()

            if len(self.programs) < Config.USER['training_parameters']['team_size']['max']:
                mutation_chance = random.random()
                if mutation_chance <= Config.USER['training_parameters']['mutation']['team']['add_program']:
                    self._randomly_add_program(programs_population)

        to_mutate = []
        while len(to_mutate) == 0:
            for program in self.programs:
                mutation_chance = random.random()
                if mutation_chance <= Config.USER['training_parameters']['mutation']['team']['mutate_program']:
                    to_mutate.append(program)
        for program in to_mutate:
            clone = Program(self.generation, copy.deepcopy(program.instructions), program.action)
            clone.mutate()
            self._add_program(clone)
            programs_population.append(clone)
            if self._is_ok_to_remove(program):
                self.remove_program(program)
        return programs_population
Ejemplo n.º 52
0
 def __init__(self):
     self.program = Program()
     self.vao = GLuint(0)
     self.vbuf = None
     self.ibuf = None
     self.vertices = []
     self.normals = []
     self.indices = []
     self.uvs = []
     # we should really be getting the camera not creating a new instance..
     self.camera = Camera(800, 600)
     GameObject.__init__(self)
Ejemplo n.º 53
0
    def test_failed_build(self):
        vert = VertexShader("A")
        frag = FragmentShader("B")

        program = Program(verts = vert)
        with self.assertRaises(ProgramException):
            program.build()

        program = Program(frags = frag)
        with self.assertRaises(ProgramException):
            program.build()
Ejemplo n.º 54
0
    def test_failed_build(self):
        vert = VertexShader("A")
        frag = FragmentShader("B")

        program = Program(verts = vert)
        with self.assertRaises(ValueError):
            program.activate()

        program = Program(frags = frag)
        with self.assertRaises(ValueError):
            program.activate()
Ejemplo n.º 55
0
 def loadProgram(self, fileName):
     """
     Load the program in memory
     
     @param filename: file containing the code to execute       
     @type  filename: string
     """
     try:
         self.program = Program()
         self.program.load(fileName, self)
         self.chip.setEndProgram(False)
         return True
     except MemError as e:
         e.display()
         return False
     except ProgramError:
         return False
Ejemplo n.º 56
0
 def import_data(cls):
   filenm ='kegiatan.csv'
   with open(filenm, 'rb') as csvfile:
     reader = csv.DictReader(csvfile, delimiter=';', quotechar='"')
     for row in reader:
       print row
       kode = row['kode'].strip()
       data = cls.get_by_kode(kode)
       if not data:
         data=cls()
         data.kode = kode
         data.created = datetime.now()
         data.create_uid = 1
         #data.tahun = data.created.year 
         #data.level_id = data.kode.count('.')+1
         #data.parent_id = DBSession.query(Rekening.id).filter(Rekening.kode==data.kode[:data.kode.rfind('.')]).scalar()
         data.disabled = 0
         #data.defsign = 1
         data.program_id=Program.get_by_kode(''.join([row['urusankd'].strip(),'.',row['programkd'].strip()])).id
       data.nama = row['nama'].strip()
       DBSession.add(data)
   DBSession.flush()
   DBSession.commit()
Ejemplo n.º 57
0
        print "At least one of %s is alive" % GR_PROG_BIN
        result = True
    return result


#### -------------- MAIN start ----------------####

# create the program processor. This
# 1. accepts and process the command line options
# 2. creates XML processing engine, that in turn
#    a) validates the XML file
#    b) extracts the DOM object tree
#    c) populates the GINI network class library
#    d) performs some semantic/syntax checkings on
#       the extracted specification
myProg = Program(sys.argv[0], SRC_FILENAME)
if (not myProg.processOptions(sys.argv[1:])):
    sys.exit(1)
options = myProg.options

# set the UML directory if is not given via -u option
if (not options.umlDir):
    # set it to the directory pointed by the $UML_DIR env
    # if no such env variable, set the uml dir to curr dir
    if (os.environ.has_key("UML_DIR")):
        options.umlDir = os.environ["UML_DIR"]
    else:
        options.umlDir = "."

# get the binaries
binDir = options.binDir
Ejemplo n.º 58
0
from base import *
from rekening import Rekening
from rekening_hukum import DasarHukum
from urusan import Urusan
from fungsi import Fungsi
from fungsi_urusan import FungsiUrusan
from unit import Unit
from program import Program
from kegiatan import Kegiatan

if __name__ == '__main__':
  Rekening.import_data()
  DasarHukum.import_data()
  Urusan.import_data()
  Fungsi.import_data()
  FungsiUrusan.import_data()
  Unit.import_data()
  Program.import_data()
  Kegiatan.import_data()
  
Ejemplo n.º 59
0
 def __init__(self, app=None, name = "default"):
     info("Creating script")
     self.extension = "scr"
     Program.__init__(self, None)
     DictObj.__init__(self, "script", app, name)
     self.repr_blacklist += ["exit", "sleep_event", "freeze_event", "next_event_in"]
Ejemplo n.º 60
0
					help="human plays first (if not present default to second)")
parser.add_argument("--boardsize", "-b", type=int, help="side length of (square) board")
parser.add_argument("--time", "-t", type=int, help="total time allowed for each move in seconds")
args = parser.parse_args()

if args.boardsize:
	boardsize = args.boardsize
else:
	boardsize = 11

if args.time:
	time = args.time
else:
	time = 10

agent = Program(args.program, False)
agent.sendCommand("boardsize "+str(boardsize))
agent.sendCommand("set_time "+str(time))

human_game = gamestate(boardsize)
game = gamestate(boardsize)
winner = None
moves = []

while(True):
	if(args.first):
		moves.append(get_human_move(game, human_game, "black"))
		if(game.winner() != game.PLAYERS["none"]):
			winner = game.winner()
			break
		print("waiting for opponent...")