def init(): global window, context, images, workspace, visual SDL_Init(SDL_INIT_VIDEO) SDL_GL_SetAttribute(SDL_GL_DOUBLEBUFFER, 1) window = SDL_CreateWindow(b"textended-edit", SDL_WINDOWPOS_CENTERED, SDL_WINDOWPOS_CENTERED, 640, 480, SDL_WINDOW_SHOWN | SDL_WINDOW_OPENGL | SDL_WINDOW_RESIZABLE) context = SDL_GL_CreateContext(window) images = sdlut.ImageResources() SDL_StartTextInput() glEnable(GL_BLEND) glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA) options = dict( background=(0x27/255.0, 0x28/255.0, 0x22/255.0, 1), font=font.load("assets/OpenSans.fnt"), font_size=12, page_width=320, color=(1, 1, 1, 1), white=(1, 1, 1, 1), color_string=(1, 1, 0.5, 1.0), color_notation=(1.0, 1.0, 1.0, 0.2), color_notation_error=(1.0, 0.5, 0.5, 0.2), color_empty=(1.0, 1.0, 1.0, 0.5), color_external=(1.0, 1.0, 1.0, 0.1), ) workspace = Workspace() document = workspace.get(sys.argv[1]) visual = Visual(images, document, options)
def on_initialize(self, params): self.root_uri = params['rootUri'] self.workspace = Workspace(self.root_uri, self.f18_path, self.f18_args) return { 'capabilities': { 'textDocumentSync': { 'openClose': True, 'change': 1, 'save': { 'includeText': True }, }, 'definitionProvider': True, 'documentSymbolProvider': True, # 'completionProvider': { # 'resolveProvider': False, # 'triggerCharacters': ['%'] # }, # 'referencesProvider': True, # 'hoverProvider': True, # 'implementationProvider': True, # 'renameProvider': True, # 'workspaceSymbolProvider': True, } }
def test_add_project_to_workspace_oneProject(): project = Project("New project", JSON={ 'name': "New project in JSON", 'created': "10/31/2019", 'edited': "10/31/2019", 'description': "filler description for testing purposes", 'protocol': "UDP", 'change_protocol': "TCP", 'src_port': "1234", 'dst_port': "8080", 'author': "author1", 'path': "", 'dissector': "" }) workspace = Workspace("New Workspace", JSON={ 'name': "New Workspace", 'projects': {}, 'created': "10/31/2019", 'edited': "10/31/2019", 'path': 'path' }) workspace.add_project_to_workspace(project) test_json = workspace.get_json() assert test_json['projects'][0] == project assert workspace.projects[0] == project
def run(self): config = self._decode_config() self._print_debug('[cppcheck] config: {}'.format(config)) workspace = Workspace(config.get('include_paths')) workspace_files = workspace.calculate() if not len(workspace_files) > 0: return self._print_debug('[cppcheck] analyzing {} files'.format( len(workspace_files))) file_list_path = self._build_file_list(workspace_files) plugin_config = config.get('config', {}) command = Command(plugin_config, file_list_path).build() self._print_debug('[cppcheck] command: {}'.format(command)) results = self._run_command(command) issues = self._parse_results(results) for issue in issues: # cppcheck will emit issues for files outside of the workspace, # like header files. This ensures that we only emit issues for # files in the workspace. if issue and workspace.should_include(issue["location"]["path"]): print('{}\0'.format(json.dumps(issue)))
def update_NET_DESKTOP_GEOMETRY(force=False): global properties, xinerama old_geom = properties["_NET_DESKTOP_GEOMETRY"] old_xinerama = xinerama time.sleep(1) properties["_NET_DESKTOP_GEOMETRY"] = ptxcb.XROOT.get_desktop_geometry() xinerama = ptxcb.connection.xinerama_get_screens() if old_xinerama != xinerama or force: if not force and len(old_xinerama) == len(xinerama): for mon in Workspace.iter_all_monitors(): mid = mon.id mon.refresh_bounds( xinerama[mid]["x"], xinerama[mid]["y"], xinerama[mid]["width"], xinerama[mid]["height"] ) mon.calculate_workarea() else: for mon in Workspace.iter_all_monitors(): for tiler in mon.tilers: tiler.destroy() for wid in Window.WINDOWS.keys(): Window.remove(wid) for wsid in Workspace.WORKSPACES.keys(): Monitor.remove(wsid) Workspace.remove(wsid) reset_properties() load_properties()
class MainWindow(QMainWindow): def __init__(self, parent=None): QMainWindow.__init__(self, parent) self.createActions() self.createMenuBar() self.createToolBar() self.setCentralWidget(self.createCentralWidget()) self.setWindowIcon(QIcon('images/logo.png')) self.loadSettings() def createActions(self): self.fileAction = QAction(QIcon('images/map.png'), u'文件', self) self.helpAction = QAction(QIcon('images/add.png'), u'帮助', self) def createMenuBar(self): fileMenu = self.menuBar().addMenu(u'文件') fileMenu.addAction(self.fileAction) fileMenu.addSeparator() fileMenu.addAction(self.helpAction) helpMenu = self.menuBar().addMenu(u'帮助') helpMenu.addAction(self.helpAction) helpMenu.triggered.connect(self.actionTest) def createToolBar(self): toolBar = self.addToolBar(u'文件') toolBar.setIconSize(QSize(16, 16)) toolBar.setMovable(False) toolBar.addAction(self.fileAction) toolBar.addSeparator() toolBar.addAction(self.helpAction) def createCentralWidget(self): self.centralWidget = Workspace() return self.centralWidget def actionTest(self): print('test') def loadSettings(self): settings = QSettings() geometry = settings.value('MainWindow/geometry') #如果设置文件存在,那么geometry的值一定存在,否则说明是第一次启动,跳过之后的设置读取过程 if not geometry: return self.restoreGeometry(geometry) def saveSettings(self): settings = QSettings() settings.beginGroup('MainWindow') settings.setValue('geometry', self.saveGeometry()) settings.endGroup() def closeEvent(self, e): self.saveSettings() self.centralWidget.saveSettings()
def __init__(self, initial=None, workspace='', policy='random', context=None, **options): # Signals / Callbacks handlers will be invoked potentially at different # worker processes. State provides a local context to save data. #Executor signals self.will_start_run = Signal() self.will_finish_run = Signal() self.will_fork_state = Signal() self.will_store_state = Signal() self.will_load_state = Signal() self.will_terminate_state = Signal() self.will_generate_testcase = Signal() #Be sure every state will forward us their signals self.will_load_state += self._register_state_callbacks #The main executor lock. Acquire this for accessing shared objects self._lock = manager.Condition(manager.RLock()) #Shutdown Event self._shutdown = manager.Event() #States on storage. Shared dict state name -> state stats self._states = manager.list() #Number of currently running workers. Initially no runnign workers self._running = manager.Value('i', 0) self._workspace = Workspace(self._lock, workspace) #Executor wide shared context if context is None: context = {} self._shared_context = manager.dict(context) #scheduling priority policy (wip) self.policy = Random() if self.load_workspace(): if initial is not None: logger.error("Ignoring initial state") # We loaded state ids, now load the actual state current_state_id = self.get() initial = self._workspace.load_state(current_state_id) self._register_state_callbacks(initial, current_state_id) self.add(initial) ##FIXME PUBSUB We need to forward signals here so they get declared ##forward signals from initial state so they are declared here self._register_state_callbacks(initial, 0) # id param unused
class Compose: def __init__(self, workspace, strict=True): ''' Object to manage working with Docker-Compose on the CLI. exposes a natural language for performing common tasks with docker in juju charms. @param workspace - Define the CWD for docker-compose execution @param strict - Enable/disable workspace validation ''' self.workspace = Workspace(workspace) if strict: self.workspace.validate() def up(self, service=None): ''' Convenience method that wraps `docker-compose up` usage: c.up('nginx') to start the 'nginx' service from the defined `docker-compose.yml` as a daemon ''' if service: cmd = "docker-compose up -d {}".format(service) else: cmd = "docker-compose up -d" self.run(cmd) def kill(self, service=None): ''' Convenience method that wraps `docker-compose kill` usage: c.kill('nginx') to kill the 'nginx' service from the defined `docker-compose.yml` ''' if service: cmd = "docker-compose kill {}".format(service) else: cmd = "docker-compose kill" self.run(cmd) def run(self, cmd): ''' chdir sets working context on the workspace @param: cmd - String of the command to run. eg: echo "hello world" the string is passed through shlex.parse() for convenience. returns STDOUT of command execution usage: c.run('docker-compose ps') ''' with chdir("{}".format(self.workspace)): out = check_output(split(cmd)) return out
class Compose: def __init__(self, workspace, strict=True): ''' Object to manage working with Docker-Compose on the CLI. exposes a natural language for performing common tasks with docker in juju charms. @param workspace - Define the CWD for docker-compose execution @param strict - Enable/disable workspace validation ''' self.workspace = Workspace(workspace) if strict: self.workspace.validate() def up(self, service=None): ''' Convenience method that wraps `docker-compose up` usage: c.up('nginx') to start the 'nginx' service from the defined `docker-compose.yml` as a daemon ''' if service: cmd = "docker-compose up -d {}".format(service) else: cmd = "docker-compose up -d" self.run(cmd) def kill(self, service=None): ''' Convenience method that wraps `docker-compose kill` usage: c.kill('nginx') to kill the 'nginx' service from the defined `docker-compose.yml` ''' if service: cmd = "docker-compose kill {}".format(service) else: cmd = "docker-compose kill" self.run(cmd) def run(self, cmd): ''' chdir sets working context on the workspace @param: cmd - String of the command to run. eg: echo "hello world" the string is passed through shlex.parse() for convenience. returns STDOUT of command execution usage: c.run('docker-compose ps') ''' with chdir("{}".format(self.workspace)): out = check_output(split(cmd)) return out
def test_add_project_to_workspace_float(): workspace = Workspace("New Workspace", JSON={ 'name': "New Workspace", 'projects': {}, 'created': "10/31/2019", 'edited': "10/31/2019", 'path': 'path' }) assert workspace.add_project_to_workspace(1.0) == None
def load_workspace(self, location) -> bool: try: self.workspace = Workspace(self, location, self.token, style=self.style, orient=tk.HORIZONTAL) self.workspace.grid(row=0, column=0, sticky=tk.NSEW) return True except FileNotFoundError: print("Directory: {0} does not exist".format(location)) except NotADirectoryError: print("{0} is not a directory".format(location)) except PermissionError: print("You do not have permissions to change to {0}".format(location))
def test_add_project_to_workspace_string(): workspace = Workspace("New Workspace", JSON={ 'name': "New Workspace", 'projects': {}, 'created': "10/31/2019", 'edited': "10/31/2019", 'path': 'path' }) assert workspace.add_project_to_workspace("random string") == None
def demo(): root = tkinter.Tk() root.title("Motion Planning") universal_height = 1000 nb = ttk.Notebook(root) page1 = ttk.Frame(nb, width= 1080,height = universal_height) page2 = ttk.Frame(nb,width = 1080,height = universal_height) nb.add(page1, text='Workspace') nb.add(page2, text='Configspace') nb.grid(column=0) workspace = Workspace("./resources/robot_BW_small.bmp", "./resources/Room_BW_small.bmp", page1) configspace = Configspace(page2) controller = Controller(workspace,configspace) workspace.drawAll(workspace.currentPos[0],workspace.currentPos[1]) def callback(event): # print ("clicked at", event.x, event.y) controller.drawMouseOffSet(event.x, event.y) if controller.isInCollision(): setBackgroundColor(page1,"red") else: setBackgroundColor(page1,"green") workspace.label.bind("<Button-1>", callback) def moveRobotOnPath(val): if controller.isAllInitialized(): controller.setSolutionPathOnCurrentPos(int(val)) controller.drawCurrentPos() if controller.isInCollision(): setBackgroundColor(page1,"red") else: setBackgroundColor(page1,"green") slider = Scale(page1, from_=0, to=200, orient=HORIZONTAL, command=moveRobotOnPath) slider.config(length=600) def set_goal(): controller.setCurrentPosAsGoal() slider['from_'] = 0 slider['to_'] = len(configspace.solutionPath)-1 setGoalButton = ttk.Button(page1, text = 'Set Goal',command = set_goal) setGoalButton.pack(side=tkinter.RIGHT) def set_init(): controller.setCurrentPosAsInit() setInitButton = ttk.Button(page1, text = 'Set Init',command = set_init) setInitButton.pack(side=tkinter.RIGHT) slider.pack() root.mainloop()
def __init__(self, workspace, strict=True): ''' Object to manage working with Docker-Compose on the CLI. exposes a natural language for performing common tasks with docker in juju charms. @param workspace - Define the CWD for docker-compose execution @param strict - Enable/disable workspace validation ''' self.workspace = Workspace(workspace) if strict: self.workspace.validate()
def workspace_report(self, args): """ Reports the relevant information for the iRODS workspace. Export and event history can be limited by start and end dates. The end date is extended 1 day since the end date alone is not inclusive. :param args: optional start and end dates """ start_date = args.start_date end_date = args.end_date + datetime.timedelta(days=1) show_dataset_owners = args.show_dataset_owners workspace = Workspace(dashboard=self, start_date=start_date, end_date=end_date) workspace.display(show_dataset_owners)
def publish_collections(collection_set_specs, allow_collection_removal): """ Main method that publishes all collections for all defined targets """ try: oai_node_obj = oai_node.OAIFetchNode() workspace = Workspace(oai_node_obj, allow_collection_removal) # sets to publish if nothing is sent in will return a set of collections so that if called # every day, by the end of the month no matter what all collections will be ran collections = oai_node_obj.get_sets_to_publish(collection_set_specs) for targetPath, taragetName in settings.TARGETS: try: module = importlib.import_module(targetPath) target = getattr(module, taragetName)() except ImportError as e: raise ImportError( "Could not import target '%s' (Is it on sys.path? Is there an import error in the settings file?): %s" % (targetPath, e) ) log.info('Running publish process for target %s' % target) #The publish summary is a summary for all collections publish_summary = PublishSummary(target.title, target.target_settings['PUBLISH_URL']) for collection in collections: collection_name = collection[0] collection_id = collection[1] collection_library_format = collection[2] if collection_id: log.info('Starting publishing process for set %s' % collection_name) else: log.info('Starting publishing process for all sets.') # reset couch before we start updating the collection workspace.reset_collection() workspace.set_collection(target.title, collection_id, collection_name, collection_library_format) try: target.update_collection(workspace) except Exception, e: # exceptions should be handled inside the update_collection method, this # really should never occur unless one codes the target wrong publish_exception = PublishException("Un-caught exception during publish.", e) log.error(publish_exception) workspace.collection_summary.add_error(publish_exception) finally: # finally email the summary out workspace.collection_summary.email_summary() publish_summary.add_collection_summary(workspace.collection_summary) # After the full publish sleep for a bit to let the node indexer catch up time.sleep(10)
def initialise_workspaces(self): for workspace_config in config.get_config('workspace_config'): (name, geometry) = workspace_config if geometry is not None: new_workspace = Workspace(name=name, geometry=geometry, state=SCREEN_STATE.ACTIVE) self.viewable_screen_count += 1 else: new_workspace = Workspace(name=name) self.add_child(new_workspace) self.update_active_workspaces_statuses()
class rccd: def __init__(self): self.ws = Workspace() def find_component_path(self, searched_component): path = self.ws.find_only_component(searched_component) if (path): print(path) else: pass def list_comp(self): components = self.ws.list_components_names() for component in components: print(component)
def __init__(self, initial=None, workspace=None, policy='random', context=None, **kwargs): super(Executor, self).__init__(**kwargs) # Signals / Callbacks handlers will be invoked potentially at different # worker processes. State provides a local context to save data. self.subscribe('did_load_state', self._register_state_callbacks) # The main executor lock. Acquire this for accessing shared objects self._lock = manager.Condition(manager.RLock()) # Shutdown Event self._shutdown = manager.Event() # States on storage. Shared dict state name -> state stats self._states = manager.list() # Number of currently running workers. Initially no running workers self._running = manager.Value('i', 0) self._workspace = Workspace(self._lock, workspace) # Executor wide shared context if context is None: context = {} self._shared_context = manager.dict(context) #scheduling priority policy (wip) #Set policy policies = { 'random': Random, 'uncovered': Uncovered, 'branchlimited': BranchLimited, } self._policy = policies[policy](self) assert isinstance(self._policy, Policy) if self.load_workspace(): if initial is not None: logger.error("Ignoring initial state") else: if initial is not None: self.add(initial)
def add_workspace(self, name=None): if name is None: name = self.get_new_index() new_workspace = Workspace(name=name) self.add_child(new_workspace) return new_workspace
def create_nc_coverage_merage_resource(): ''' # NOTE: 尝试将创建 nc coverage 使用 -> resource.py -> Coverage 的方式实现 # TODO:[-] 20-03-23 ''' coverage_title = 'ceshi_coverage_01' # TODO:[*] 20-03-24 注意此处会引发严重bug,在指定 工作区 下若不存在指定的 store 会出现 错误 store_name = 'nmefc_2016072112_opdr' coverage_store = 'nmefc_wind' layer_name = 'ceshi_coverage_01' work_space = 'my_test_2' cat: Catalog = Catalog("http://localhost:8082/geoserver/rest", username="******", password="******") ws = Workspace(cat, work_space) store = CoverageStore(cat, ws, 'nmefc_wind_dir_xy') # layer = CoverageLayer(cat, 'ceshi_name', 'ceshi_native_name', 'ceshi_tile', 'ceshi_native_coveragename') # coverage = Coverage(cat, ws, store, 'view_nmefc_wind') # TODO:[-] 20-03-24 使用 -> customer_layer -> CoverageLayer # coverage = CoverageLayer(cat, WORK_SPACE) # coverage.create_layer(coverage_title, store_name, [dict(name='x_wind_10m'), dict(name='y_wind_10m')]) bands = [dict(name='x_wind_10m'), dict(name='y_wind_10m')] coverage_layer = CoverageLayer(cat, work_space, store_name) # TODO:[*] 20-03-24 此处若使用 layer_name:ceshi_coverage_01 而不使用 coverage_store:nmefc_wind 则会引发 msg 的bug coverage_layer.publish(layer_name, bands) pass
def update_NET_WORKAREA(): global properties properties["_NET_WORKAREA"] = ptxcb.XROOT.get_workarea() for mon in Workspace.iter_all_monitors(): mon.calculate_workarea()
def init_workspace_and_projects(self): """Initializes Workspace and ProjectsManager.""" assert self._projects is None assert self._workspace is None self._workspace = Workspace(factory=self) self._projects = ProjectsManager(factory=self) self._projects.init_workspace()
def test_create_workspace_without_params(): workspace = Workspace() assert workspace.name == None assert workspace.JSON['name'] == None assert workspace.JSON['projects'] == {} assert workspace.JSON['created'] == None assert workspace.JSON['edited'] == None assert workspace.JSON['path'] == None
def update_NET_NUMBER_OF_DESKTOPS(): global properties, xinerama old = properties["_NET_NUMBER_OF_DESKTOPS"] properties["_NET_NUMBER_OF_DESKTOPS"] = ptxcb.XROOT.get_number_of_desktops() # Add destops... if old < properties["_NET_NUMBER_OF_DESKTOPS"]: for wsid in xrange(old, properties["_NET_NUMBER_OF_DESKTOPS"]): Workspace.add(wsid) Monitor.add(wsid, xinerama) # Remove desktops elif old > properties["_NET_NUMBER_OF_DESKTOPS"]: for wsid in xrange(properties["_NET_NUMBER_OF_DESKTOPS"], old): Monitor.remove(wsid) Workspace.remove(wsid)
def test_get_json(): workspace = Workspace(None, JSON={ 'name': "New Workspace in JSON", 'projects': {}, 'created': "10/31/2019", 'edited': "10/31/2019", 'path': 'path' }) assert workspace.name == "New Workspace in JSON" test_json = workspace.get_json() assert test_json['name'] == "New Workspace in JSON" assert test_json['projects'] == {} assert test_json['created'] == "10/31/2019" assert test_json['edited'] == "10/31/2019" assert test_json['path'] == 'path'
def test_create_workspace_firstparam(): workspace = Workspace("New Workspace") assert workspace.name == "New Workspace" assert workspace.JSON['name'] == None assert workspace.JSON['projects'] == {} assert workspace.JSON['created'] == None assert workspace.JSON['edited'] == None assert workspace.JSON['path'] == None
async def set_workspace(ws, workspace_name): global workspace workspace = Workspace(workspace_name) await ws.send( json.dumps({ 'type': 'message', 'message': 'Switched to workspace %s.' % workspace.name }))
def __init__(self): self.viewable_screen_count = 0 self.last_active_window_id = None self.workspaces = [] for workspace_config in config.WORKSPACE_CONFIG: (name, geometry) = workspace_config if geometry is not None: new_workspace = Workspace(self, name, geometry, SCREEN_STATE.ACTIVE) self.viewable_screen_count += 1 else: new_workspace = Workspace(self, name) self.workspaces.append(new_workspace) self.update_active_workspaces_statuses()
def start(self): # Script statup steps logger.info('PolyEngine v1.0') config = Config('config.ini') project_name = config.check_setting('PolyEngine', 'Name') logger.info('Starting project {}', project_name) message = config.check_setting('PolyEngine', 'Message') logger.info(message) # Source directory of project based on config file source_directory = config.check_setting('Compile', 'SourceDirectory') # Create the temporary code modification workspace workspace = Workspace(source_directory) workspace.create_workspace() # Process the files for f in workspace.source_files: if f is not None: processor = Processing(f) processor.process() for f in workspace.header_files: if f is not None: processor = Processing(f) processor.process() # Initialize the compiler once information has been loaded output_file = config.check_setting('Compile', 'Output') commands = config.check_setting('Compile', 'Commands') compiler_option = config.check_setting('Compile', 'Compiler') if compiler_option == 'gcc' or compiler_option == 'g++': compiler = Compile(compiler_option, workspace.source_files, commands, output_file) compiler.compile() else: logger.error('Invalid compiler option selected.') exit('Invalid compiler.') # Cleanup workspace and exit print() Cleanup.clean_exit(workspace.work_path)
class rccd: def __init__(self): self.ws = Workspace() def save_filtered_component(self, searched_component): options = self.ws.find_components(searched_component) if options is not None: if len(options) == 1: save_output(f"{options[0]}") elif len(options) > 1: selected = self.ws.ask_for_path_selection(options) if selected is None: save_output("") else: save_output(selected) else: save_output("") else: save_output("")
def __init__(self, run): super(Window, self).__init__(1024, 600, caption="Copycat", vsync=False) glEnable(GL_BLEND) glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA) self.clock = pyglet.clock.ClockDisplay() self.show_fps = False self.done = False self.time = 0 self.speed = 15 self.playing = False self.run = run background = pyglet.resource.image("blackboard.png") self.background = pyglet.sprite.Sprite(background) self.saved_temp = 0 self.batch = pyglet.graphics.Batch() self.play = pyglet.resource.image("play.png") self.pause = pyglet.resource.image("pause.png") self.play.anchor_x = self.play.width / 2.0 self.play.anchor_y = self.play.height / 2.0 self.pause.anchor_x = self.pause.width / 2.0 self.pause.anchor_y = self.pause.height / 2.0 self.button = Button(self.play, 30, 580, self.on_play_button, self.batch) self.timer = pyglet.text.Label("0", "EraserDust", 18, x=512, y=574, color=(255,255,255, 125), batch=self.batch, halign="center", anchor_x="center") self.rule = pyglet.text.Label("", "EraserDust", 16, x=512, y=445, color=(255,255,255, 190), batch=self.batch, halign="center", anchor_x="center") self.slipnet = Slipnet(self.run.slipnet, 0, 0, 512, 300, self.batch) self.coderack = Coderack(self.run.coderack, 512, 0, 512, 300, self.batch) self.workspace = Workspace(self.run.workspace, 0, 300, 1024, 300, self.batch) pyglet.clock.schedule(self.update)
def __init__(self, X_origin, Y_origin, Z_origin, X_limit, Y_limit, L1, L2, L3): self.x_o = float(X_origin) self.y_o = float(Y_origin) self.z_o = float(Z_origin) self.MAX_X = float(X_limit) self.MAX_Y = float(Y_limit) self.L1 = float(L1) self.L2 = float(L2) self.L3 = float(L3) self.workspace = Workspace(X_origin, Y_origin, Z_origin, L1, L2, L3)
def main(): parser = argparse.ArgumentParser( description="provides various info about components/workspaces") parser.add_argument('argument', nargs='?', choices=['list', 'listws']) argcomplete.autocomplete(parser) args = parser.parse_args() ws = Workspace() if args.argument == 'list': try: ws.list_workspaces() except KeyboardInterrupt: print("\nCanceled") elif args.argument == 'listws': print("Registered workspaces are :") for workspace in ws.workspace_paths: print(f"\t{workspace}") else: parser.error("sorry no such option is available ")
def command_request(command): # Verify if the command is comming from slack if(request.form["token"] != verification_token): return "", 401 commandWorkspace = Workspace.get(Workspace.team_id == request.form['team_id']) if(commandWorkspace == None): return "Workspace not found", 404 andrew.emitEvent(CommandEvent(CommandEvent.COMMANDSEND,request.form, commandWorkspace)) return "", 200
def __init__(self, workspace, strict=True): ''' Object to manage working with Docker-Compose on the CLI. exposes a natural language for performing common tasks with docker in juju charms. @param workspace - Define the CWD for docker-compose execution @param strict - Enable/disable workspace validation ''' self.workspace = Workspace(workspace) if strict: self.workspace.validate()
def __init__(self, initial=None, workspace='', policy='random', context=None, **options): # Signals / Callbacks handlers will be invoked potentially at different # worker processes. State provides a local context to save data. #Executor signals self.will_start_run = Signal() self.will_finish_run = Signal() self.will_fork_state = Signal() self.will_store_state = Signal() self.will_load_state = Signal() self.will_terminate_state = Signal() self.will_generate_testcase = Signal() #Be sure every state will forward us their signals self.will_load_state += self._register_state_callbacks #The main executor lock. Acquire this for accessing shared objects self._lock = manager.Condition(manager.RLock()) #Shutdown Event self._shutdown = manager.Event() #States on storage. Shared dict state name -> state stats self._states = manager.list() #Number of currently running workers. Initially no runnign workers self._running = manager.Value('i', 0 ) self._workspace = Workspace(self._lock, workspace) #Executor wide shared context if context is None: context = {} self._shared_context = manager.dict(context) #scheduling priority policy (wip) self.policy = Random() if self.load_workspace(): if initial is not None: logger.error("Ignoring initial state") # We loaded state ids, now load the actual state current_state_id = self.get() initial = self._workspace.load_state(current_state_id) self._register_state_callbacks(initial, current_state_id) self.add(initial) ##FIXME PUBSUB We need to forward signals here so they get declared ##forward signals from initial state so they are declared here self._register_state_callbacks(initial, 0) # id param unused
def _move(self, direction, value): """ Moves object into direction by value. """ for view in Workspace().get3DView(): offset = Vector((0.0, 0.0, 0.0)) if direction == "horizontal": offset.x = value elif direction == "vertical": offset.y = value elif direction == "straightforward": offset.z = value bpy.context.scene.objects.active.location \ = view.view_rotation*offset + bpy.context.scene.objects.active.location
def test_create_workspace_allparams(): workspace = Workspace("New Workspace", JSON={ 'name': "New Workspace", 'projects': {}, 'created': "10/31/2019", 'edited': "10/31/2019", 'path': 'path' }) assert workspace.name == "New Workspace" assert workspace.JSON['projects'] == {} assert workspace.JSON['created'] == "10/31/2019" assert workspace.JSON['edited'] == "10/31/2019" assert workspace.JSON['path'] == 'path'
def prompt_for_workspace(self): no_args = len(self._args) == 0 if no_args: self.print_workspaces() return (None, []) index = self._parse_index(self._args[0]) (subdir, i) = index if i is None: self.print_workspaces(subdir) return (None, []) ws = Workspace.all(subdir) if i < 0 or i >= len(ws): print "Index out of range: %d" % i self.print_workspaces() return (None, []) return (ws[i], self._args[1:])
def createDockWindows(self): animate = animationWidget.QAnimationView(self) self.dockAnimate = QtGui.QDockWidget(self) self.dockAnimate.setWidget(animate) self.dockAnimate.setWindowTitle("Animation") #self.dockTemplate = DockTemplate(self) self.dockPlot = DockPlot(self) self.dockVariable = DockVariable(self) self.workspace = Workspace(self) self.varProp = VariableProperties(self) #self.workspace.addProject("Relative Humidity") #self.workspace.addProject("Total Cloudiness") #self.workspace.addProject("Temperature Anomaly") #self.workspace.addProject() self.dockCalculator = DockCalculator(self) self.plotProp = PlotProperties.instance(self) self.addDockWidget(QtCore.Qt.LeftDockWidgetArea, self.workspace) #self.addDockWidget(QtCore.Qt.LeftDockWidgetArea, self.dockTemplate) self.addDockWidget(QtCore.Qt.LeftDockWidgetArea, self.dockAnimate) #self.tabifyDockWidget(self.workspace, self.dockTemplate) self.addDockWidget(QtCore.Qt.LeftDockWidgetArea, self.dockPlot) #self.tabifyDockWidget(self.dockTemplate, self.dockPlot) self.workspace.raise_() self.varProp.hide() self.plotProp.hide() self.dockAnimate.hide() self.addDockWidget(QtCore.Qt.RightDockWidgetArea, self.dockVariable) #self.addDockWidget(QtCore.Qt.RightDockWidgetArea, self.varProp) self.addDockWidget(QtCore.Qt.RightDockWidgetArea, self.dockCalculator) self.tabifyDockWidget(self.dockCalculator, self.plotProp) try: # For now only puts the diagnostics widget if the metrics module is present import metrics from diagnosticsDockWidget import DiagnosticsDockWidget self.diagnosticsWidget = DiagnosticsDockWidget(self) self.diagnosticsWidget.hide() self.addDockWidget(QtCore.Qt.RightDockWidgetArea, self.diagnosticsWidget) self.tabifyDockWidget(self.plotProp, self.diagnosticsWidget) except: pass
class Robot_Kinematics: """ Constructor for Robot_Kin Class. The Robot's coordinates refers to the location of the base plate's center of mass that is connected to link 1 X_origin: Robot X coordinate in the world: float(inches) Y_origin: Robot Y coordinate in the world: float(inches) Z_origin: Robot Z coordinate in the world: float(inches) X_limit: The length of the field in the X direction: float(inches) Y_limt: The length of the field in the Y direction: float(inches) LX: The length of link X """ def __init__(self, X_origin, Y_origin, Z_origin, X_limit, Y_limit, L1, L2, L3): self.x_o = float(X_origin) self.y_o = float(Y_origin) self.z_o = float(Z_origin) self.MAX_X = float(X_limit) self.MAX_Y = float(Y_limit) self.L1 = float(L1) self.L2 = float(L2) self.L3 = float(L3) self.workspace = Workspace(X_origin, Y_origin, Z_origin, L1, L2, L3) """ Converts the coordinates of a point in the world system to coordinates of a point in the robots system, where the robot's location is the origin. To keep things simple, the axis of the robots system are alined with the axis of the world's: X: World's X coord: float Y: World's Y coord: float Z: World's Z coord: float returns tuple of (xp, yp, zp) of robot coordinates """ def convertWorldCoord(self, X, Y, Z): xr = self.x_o - X yr = self.y_o - Y zr = Z - self.z_o return (xr, yr, zr) """ Given the coordinates of Point C(the endpoint of Link 3 connected to Link 4), returns the angles of theta1, theta2,and theta3 in a tuple. XC: X coord of Point C: float YC: Y coord of Point C: float ZC: Y coord of Point C: float return tuple(theta1, theta2, theta3) in radians """ def findThetas(self, XC, YC, ZC): theta1 = math.atan2(YC, XC) # Theta1 # Point A Coords (Point connected to Link 1 and 2) XA = self.L1*math.cos(theta1) YA = self.L1*math.sin(theta1) ZA = 0.0 #Distance of Point A and Point C in XY Plane rc = math.sqrt(math.pow((XC-XA), 2) + math.pow((YC-YA),2)) #Distance of Point A and Point C in XYZ Space dc = math.sqrt(math.pow((ZC-ZA), 2) + math.pow(rc, 2)) gamma_arg = ((math.pow(dc,2) + math.pow(self.L2,2) - math.pow(self.L3,2))/(2*dc*self.L2)) theta2 = math.atan2(rc, ZC) - math.acos(gamma_arg) beta_arg = ((math.pow(self.L2, 2)+math.pow(self.L3, 2) - math.pow(dc, 2))/(2*self.L2*self.L3)) theta3 = math.pi - math.acos(beta_arg) return(theta1, theta2, theta3) """ Returns a boolean to determine if point is reachable(within the workspace of the robot) X: X coord in the world: float (inches) Y: Y coord in the world: float (inches) Z: Z coord in the wolrd: float (inches) """ def isReachable(self, X, Y, Z): return self.workspace.containsPoint(X, Y, Z) """ Creates the Jacobian representation for kinematics using theta 1, 2, and 3 """ def makeJacobian(theta1, theta2, theta3): #Forward kinematics derivative for theta1 Xd1 = self.L1*math.cos(theta1) + self.L2*math.sin(theta2)*math.cos(theta1) + self.L3*math.sin(theta2+theta3)*math.cos(theta1) Yd1 = (self.L1*math.sin(theta1)+self.L2*math.sin(theta2)*math.sin(theta1)+ self.L3*math.sin(theta2+theta3)*math.sin(theta1))*(-1) Zd1 = 0.0 #Forward kinematics derivative for theta2 Xd2 = self.L2*math.cos(theta2)*math.sin(theta1) + self.L3*math.cos(theta2+theta3)*math.sin(theta1) Yd2 = self.L2*math.cos(theta2)*math.cos(theta1) + self.L3*math.cos(theta2+theta3)*math.cos(theta1) Zd2 = self.L2*math.sin(theta2) + self.L3*math.sin(theta2+theta3) #Forward kinematics derivative for theta3 Xd3 = self.L3*math.cos(theta2+theta3)*math.sin(theta1) Yd3 = self.L3*math.cos(theta2+theta3)*math.cos(theta1) Zd3 = self.L3*math.sin(theta2+theta3) return ((Xd1, Xd2, Xd3),(Yd1, Yd2, Yd3), (Zd1, Zd2, Zd3)) """ Finds the torque 2 and 3 to order to provide Fx, Fy, and Fz """ def findTorques(Fx, Fy, theta1, theta2, theta3): Jacobian = makeJacobian(theta1, theta2, theta3) torque2 = Jacobian[0,1]*Fx + Jacobian[1,1]*Fy + Jacobian[2,1]*Fz torque3 = Jacobian[0,2]*Fx + Jacobian[1,2]*Fy + Jacobian[2,2]*Fz return(torque2, torque3)
class UVCDATMainWindow(QtGui.QMainWindow): def __init__(self, parent=None,customPath=None,styles=None): super(UVCDATMainWindow, self).__init__(parent) self.root=self self.ui = Ui_MainWindow() self.ui.setupUi(self) self.setDocumentMode(True) #init user options self.initCustomize(customPath,styles) self.root = self #self.tool_bar = mainToolbarWidget.QMainToolBarContainer(self) self.canvas=[] self.canvas.append(vcs.init()) self.colormapEditor =QColormapEditor(self) # Create the command recorder widget self.recorder = commandsRecorderWidget.QCommandsRecorderWidget(self) #Adds a shortcut to the record function self.record = self.recorder.record self.preferences = preferencesWidget.QPreferencesDialog(self) self.preferences.hide() self.cdmsCacheWidget = CdmsCacheWidget(self) # self.regridding = regriddingWidget.QRegriddingDialog(self) # self.regridding.hide() ########################################################### # Init Menu Widget ########################################################### self.mainMenu = mainMenuWidget.QMenuWidget(self) self.createDockWindows() self.createActions() self.updateMenuActions() self.embedSpreadsheet() self.connectSignals() self.resize(1150,800) def initCustomize(self,customPath,styles): if customPath is None: customPath=os.path.join(os.environ["HOME"],".uvcdat","customizeUVCDAT.py") if os.path.exists(customPath): execfile(customPath,customizeUVCDAT.__dict__,customizeUVCDAT.__dict__) if styles is None: styles=customizeUVCDAT.appStyles icon = QtGui.QIcon(customizeUVCDAT.appIcon) self.setWindowIcon(icon) ## cdms2 setup section cdms2.axis.time_aliases+=customizeUVCDAT.timeAliases cdms2.axis.level_aliases+=customizeUVCDAT.levelAliases cdms2.axis.latitude_aliases+=customizeUVCDAT.latitudeAliases cdms2.axis.longitude_aliases+=customizeUVCDAT.longitudeAliases cdms2.setNetcdfShuffleFlag(customizeUVCDAT.ncShuffle) cdms2.setNetcdfDeflateFlag(customizeUVCDAT.ncDeflate) cdms2.setNetcdfDeflateLevelFlag(customizeUVCDAT.ncDeflateLevel) ## StylesSheet st="" if isinstance(styles,str): st = styles elif isinstance(styles,dict): for k in styles.keys(): val = styles[k] if isinstance(val,QtGui.QColor): val = str(val.name()) st+="%s:%s; " % (k,val) if len(st)>0: self.setStyleSheet(st) ########################################################### ########################################################### ## Prettyness ########################################################### ########################################################### #self.setGeometry(0,0, 1100,800) self.setWindowTitle('The Ultrascale Visualization Climate Data Analysis Tools - (UV-CDAT)') ## self.resize(1100,800) #self.setMinimumWidth(1100) self.main_window_placement() def main_window_placement(self): screen = QtGui.QDesktopWidget().screenGeometry() size = self.geometry() self.move((screen.width()-size.width())/4, (screen.height()-size.height())/5) def createDockWindows(self): animate = animationWidget.QAnimationView(self) self.dockAnimate = QtGui.QDockWidget(self) self.dockAnimate.setWidget(animate) self.dockAnimate.setWindowTitle("Animation") #self.dockTemplate = DockTemplate(self) self.dockPlot = DockPlot(self) self.dockVariable = DockVariable(self) self.workspace = Workspace(self) self.varProp = VariableProperties(self) #self.workspace.addProject("Relative Humidity") #self.workspace.addProject("Total Cloudiness") #self.workspace.addProject("Temperature Anomaly") #self.workspace.addProject() self.dockCalculator = DockCalculator(self) self.plotProp = PlotProperties.instance(self) self.addDockWidget(QtCore.Qt.LeftDockWidgetArea, self.workspace) #self.addDockWidget(QtCore.Qt.LeftDockWidgetArea, self.dockTemplate) self.addDockWidget(QtCore.Qt.LeftDockWidgetArea, self.dockAnimate) #self.tabifyDockWidget(self.workspace, self.dockTemplate) self.addDockWidget(QtCore.Qt.LeftDockWidgetArea, self.dockPlot) #self.tabifyDockWidget(self.dockTemplate, self.dockPlot) self.workspace.raise_() self.varProp.hide() self.plotProp.hide() self.dockAnimate.hide() self.addDockWidget(QtCore.Qt.RightDockWidgetArea, self.dockVariable) #self.addDockWidget(QtCore.Qt.RightDockWidgetArea, self.varProp) self.addDockWidget(QtCore.Qt.RightDockWidgetArea, self.dockCalculator) self.tabifyDockWidget(self.dockCalculator, self.plotProp) try: # For now only puts the diagnostics widget if the metrics module is present import metrics from diagnosticsDockWidget import DiagnosticsDockWidget self.diagnosticsWidget = DiagnosticsDockWidget(self) self.diagnosticsWidget.hide() self.addDockWidget(QtCore.Qt.RightDockWidgetArea, self.diagnosticsWidget) self.tabifyDockWidget(self.plotProp, self.diagnosticsWidget) except: pass def createActions(self): # Quit Action self.actionExit = QtGui.QAction("Quit", self, triggered=self.quit) #VisTrails Window self.showBuilderWindowAct = QtGui.QAction("Builder", self, triggered=self.showBuilderWindowActTriggered) self.showVistrailsConsoleAct = QtGui.QAction("Console", self, triggered=self.showVistrailsConsoleActTriggered) #About Message self.showAboutMessageAct = QtGui.QAction("About UV-CDAT...", self, triggered=self.showAboutMessageActTriggered) def updateMenuActions(self): #menu File Actions self.ui.menuFile.addAction(self.workspace.btnNewProject) self.ui.menuFile.addAction(self.workspace.btnOpenProject) self.ui.menuFile.addSeparator() self.ui.menuFile.addAction(self.workspace.btnCloseProject) self.ui.menuFile.addSeparator() self.ui.menuFile.addAction(self.workspace.btnSaveProject) self.ui.menuFile.addAction(self.workspace.btnSaveProjectAs) self.ui.menuFile.addSeparator() self.ui.menuFile.addAction(self.actionExit) #menu View Actions self.ui.menuView.addAction(self.workspace.toggleViewAction()) #self.ui.menuView.addAction(self.dockTemplate.toggleViewAction()) self.ui.menuView.addAction(self.dockPlot.toggleViewAction()) self.ui.menuView.addAction(self.dockVariable.toggleViewAction()) self.ui.menuView.addAction(self.dockCalculator.toggleViewAction()) self.ui.menuView.addAction(self.plotProp.toggleViewAction()) #VisTrails Menu self.ui.menuVisTrails.addAction(self.showBuilderWindowAct) self.ui.menuVisTrails.addAction(self.showVistrailsConsoleAct) #About message self.ui.menuHelp.addAction(self.showAboutMessageAct) def showBuilderWindowActTriggered(self): from gui.vistrails_window import _app _app.show() _app.raise_() _app.qactions['history'].trigger() _app.get_current_tab().zoomToFit() _app.qactions['pipeline'].trigger() _app.get_current_tab().zoomToFit() #self.get_current_project_controller().re_layout_workflow() def showVistrailsConsoleActTriggered(self): from gui.shell import QShellDialog QShellDialog.instance().set_visible(True) def showAboutMessageActTriggered(self): import core.uvcdat import vistrails.core.system class About(QtGui.QLabel): def mousePressEvent(self, e): self.emit(QtCore.SIGNAL("clicked()")) dlg = QtGui.QDialog(self, QtCore.Qt.FramelessWindowHint) layout = QtGui.QVBoxLayout() layout.setMargin(0) layout.setSpacing(0) bgimage = About(dlg) #The application disclaimer image pixmap = QtGui.QPixmap( vistrails.core.system.vistrails_root_directory() + '/gui/uvcdat/resources/images/disclaimer.png') bgimage.setPixmap(pixmap) layout.addWidget(bgimage) dlg.setLayout(layout) text = "<font color=\"#105E99\"><b>%s</b></font>" % \ core.uvcdat.short_about_string() version = About(text, dlg) version.setGeometry(11,50,450,30) self.connect(bgimage, QtCore.SIGNAL('clicked()'), dlg, QtCore.SLOT('accept()')) self.connect(version, QtCore.SIGNAL('clicked()'), dlg, QtCore.SLOT('accept()')) dlg.setSizeGripEnabled(False) dlg.exec_() def connectSignals(self): self.connect(self.spreadsheetWindow.tabControllerStack, QtCore.SIGNAL("add_tab"), self.workspace.add_sheet_tab) self.connect(self.spreadsheetWindow.tabControllerStack, QtCore.SIGNAL("remove_tab"), self.workspace.remove_sheet_tab) self.connect(self.spreadsheetWindow.tabControllerStack, QtCore.SIGNAL("change_tab_text"), self.workspace.change_tab_text) def closeEvent(self, e): """ closeEvent(e: QCloseEvent) -> None Only hide the builder window """ if not self.quit(): e.ignore() def quit(self): #FIXME #ask to save projects print "quitting" if self.preferences.confirmB4Exit.isChecked(): # put here code to confirm exit pass if self.preferences.saveB4Exit.isChecked(): self.preferences.saveState() from gui.vistrails_window import _app _app._is_quitting = True if _app.close_all_vistrails(): # DAK: removing this call as it seems to cause a # RuntimeError with QVersionTreeScene.selectionChanged; # it also does not appear in the VisTrails code # _app.deleteLater() QtCore.QCoreApplication.quit() # In case the quit() failed (when Qt doesn't have the main # event loop), we have to return True still return True _app._is_quitting = False return False QtGui.QApplication.instance().quit() def showVariableProperties(self): varProp = VariableProperties.instance() varProp.show() def showPlotProperties(self): plotProp = PlotProperties.instance() plotProp.show() def embedSpreadsheet(self): self.spreadsheetWindow = spreadsheetController.findSpreadsheetWindow(show=False) self.setCentralWidget(self.spreadsheetWindow) self.spreadsheetWindow.setVisible(True) def cleanup(self): self.setCentralWidget(QtGui.QWidget()) self.spreadsheetWindow.setParent(None) def stick_defvar_into_main_dict(self,var): __main__.__dict__[var.id]=var def stick_main_dict_into_defvar(self,results=None): #First evaluate if there's any var in the result res = None if results is not None: tmp = __main__.__dict__[results] else: tmp=None added = [] remove =[] if isinstance(tmp,cdms2.tvariable.TransientVariable): __main__.__dict__[tmp.id]=tmp added.append(tmp.id) res = tmp.id elif tmp is not None: self.processList(tmp,added) if results is not None: del(__main__.__dict__[results]) for k in __main__.__dict__: if isinstance(__main__.__dict__[k],cdms2.tvariable.TransientVariable): if __main__.__dict__[k].id in added and k!=__main__.__dict__[k].id: remove.append( __main__.__dict__[k].id) res = k if not k in remove: __main__.__dict__[k].id=k self.dockVariable.widget().addVariable(__main__.__dict__[k]) # # Send information to controller so the Variable can be reconstructed # # later. The best way is by emitting a signal to be processed by the # # main window. When this panel becomes a global panel, then we will do # # that. For now I will talk to the main window directly. # # from api import get_current_project_controller # from vistrails.packages.uvcdat_cdms.init import CDMSVariable # controller = get_current_project_controller() # if controller.get_defined_variable(k) is None: # cdmsVar = CDMSVariable(filename=None, name=k) # controller.add_defined_variable(cdmsVar) for r in remove: del(__main__.__dict__[r]) return res def processList(self,myList,added): for v in myList: if isinstance(v,cdms2.tvariable.TransientVariable): __main__.__dict__[v.id]=v added.append(v.id) elif isinstance(v,(list,tuple)): self.processList(v,added) elif isinstance(v,dict): self.processList(dict.values(),added) return def get_current_project_controller(self): return self.workspace.get_current_project_controller() def get_project_controller_by_name(self, name): return self.workspace.get_project_controller_by_name(name) def link_registry(self): self.dockPlot.link_registry() def warning(self, msg): print "WARNING: %s" % msg if not get_vistrails_configuration().noDebugPopups: QtGui.QMessageBox.warning(self, "Warning", msg)
def apply_config(): Command.init() for mon in Workspace.iter_all_monitors(): if config.get_option("tile_on_startup", mon.workspace.id, mon.id): mon.tile(force_tiling=True)
def print_workspaces(self, subdir=None): ws = Workspace.all(subdir) for i in range(len(ws)): print "%d: %s" % (i, ws[i].summary_line())
class Window(pyglet.window.Window): """The main window keeps track of what scene is currently being viewed, manages the gui elements that are always on screen, and takes care of updating the simulation.""" def __init__(self, run): super(Window, self).__init__(1024, 600, caption="Copycat", vsync=False) glEnable(GL_BLEND) glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA) self.clock = pyglet.clock.ClockDisplay() self.show_fps = False self.done = False self.time = 0 self.speed = 15 self.playing = False self.run = run background = pyglet.resource.image("blackboard.png") self.background = pyglet.sprite.Sprite(background) self.saved_temp = 0 self.batch = pyglet.graphics.Batch() self.play = pyglet.resource.image("play.png") self.pause = pyglet.resource.image("pause.png") self.play.anchor_x = self.play.width / 2.0 self.play.anchor_y = self.play.height / 2.0 self.pause.anchor_x = self.pause.width / 2.0 self.pause.anchor_y = self.pause.height / 2.0 self.button = Button(self.play, 30, 580, self.on_play_button, self.batch) self.timer = pyglet.text.Label("0", "EraserDust", 18, x=512, y=574, color=(255,255,255, 125), batch=self.batch, halign="center", anchor_x="center") self.rule = pyglet.text.Label("", "EraserDust", 16, x=512, y=445, color=(255,255,255, 190), batch=self.batch, halign="center", anchor_x="center") self.slipnet = Slipnet(self.run.slipnet, 0, 0, 512, 300, self.batch) self.coderack = Coderack(self.run.coderack, 512, 0, 512, 300, self.batch) self.workspace = Workspace(self.run.workspace, 0, 300, 1024, 300, self.batch) pyglet.clock.schedule(self.update) def on_key_press(self, symbol, modifiers): if symbol == pyglet.window.key.ESCAPE: pyglet.app.exit() elif symbol == pyglet.window.key.F and modifiers == pyglet.window.key.MOD_CTRL: self.show_fps = not self.show_fps elif symbol == pyglet.window.key.SPACE: self.button.on_key_press(symbol, modifiers) def on_mouse_press(self, x, y, button, modifiers): self.button.on_mouse_press(x, y, button, modifiers) def on_mouse_release(self, x, y, button, modifiers): self.button.on_mouse_release(x, y, button, modifiers) def on_play_button(self): self.playing = not self.playing if self.playing: self.button.sprite.image = self.pause else: self.button.sprite.image = self.play def update(self, dt): self.button.update(dt) if self.done or not self.playing: return # Update each graphical module. self.slipnet.update(dt) self.coderack.update(dt) self.workspace.update(dt) # Check for completion. if self.run.workspace.answer_string: self.rule.text = self.run.workspace.rule.to_string() self.done = True # Update the timestep display. time = str(self.run.coderack.time / self.run.timestep) if self.timer.text != time: self.timer.text = time # Update the temperature display. target_temp = self.run.workspace.temperature * 2.55 if abs(self.saved_temp - target_temp) > .001: self.saved_temp += (target_temp - self.saved_temp) * dt self.background.color = (240, 255 - self.saved_temp / 1.4, 255 - self.saved_temp / 1.15) # Update the simulation at the given speed. self.time += dt if self.time >= 1.0 / self.speed: self.run.step() self.time = 0 def on_draw(self): self.clear() self.background.draw() self.batch.draw() if self.show_fps: self.clock.draw()
def print_subdirs(self): subdirs = Workspace.all_subdirs() for subdir in subdirs: print subdir
class Executor(object): ''' The executor guides the execution of an initial state or a paused previous run. It handles all exceptional conditions (system calls, memory faults, concretization, etc.) ''' def __init__(self, initial=None, workspace='', policy='random', context=None, **options): # Signals / Callbacks handlers will be invoked potentially at different # worker processes. State provides a local context to save data. #Executor signals self.will_start_run = Signal() self.will_finish_run = Signal() self.will_fork_state = Signal() self.will_store_state = Signal() self.will_load_state = Signal() self.will_terminate_state = Signal() self.will_generate_testcase = Signal() #Be sure every state will forward us their signals self.will_load_state += self._register_state_callbacks #The main executor lock. Acquire this for accessing shared objects self._lock = manager.Condition(manager.RLock()) #Shutdown Event self._shutdown = manager.Event() #States on storage. Shared dict state name -> state stats self._states = manager.list() #Number of currently running workers. Initially no runnign workers self._running = manager.Value('i', 0 ) self._workspace = Workspace(self._lock, workspace) #Executor wide shared context if context is None: context = {} self._shared_context = manager.dict(context) #scheduling priority policy (wip) self.policy = Random() if self.load_workspace(): if initial is not None: logger.error("Ignoring initial state") # We loaded state ids, now load the actual state current_state_id = self.get() initial = self._workspace.load_state(current_state_id) self._register_state_callbacks(initial, current_state_id) self.add(initial) ##FIXME PUBSUB We need to forward signals here so they get declared ##forward signals from initial state so they are declared here self._register_state_callbacks(initial, 0) # id param unused @contextmanager def locked_context(self): ''' Executor context is a shared memory object. All workers share this. It needs a lock. Its used like this: with executor.context() as context: vsited = context['visited'] visited.append(state.cpu.PC) context['visited'] = visited ''' with self._lock: yield self._shared_context def _register_state_callbacks(self, state, state_id): ''' Install forwarding callbacks in state so the events can go up. Going up, we prepend state in the arguments. ''' #Forward all state signals forward_signals(self, state, True) def add(self, state): ''' Enqueue state. Save state on storage, assigns an id to it, then add it to the priority queue ''' #save the state to secondary storage state_id = self._workspace.save_state(state) self.will_store_state(state, state_id) self.put(state_id) return state_id def load_workspace(self): #Browse and load states in a workspace in case we are trying to # continue from paused run loaded_state_ids = self._workspace.try_loading_workspace() if not loaded_state_ids: return False for id in loaded_state_ids: self._states.append(id) return True ############################################### # Synchronization helpers @sync def _start_run(self): #notify siblings we are about to start a run() self._running.value+=1 @sync def _stop_run(self): #notify siblings we are about to stop this run() self._running.value-=1 assert self._running.value >=0 self._lock.notify_all() ################################################ #Public API @property def running(self): ''' Report an estimate of how many workers are currently running ''' return self._running.value def shutdown(self): ''' This will stop all workers ''' self._shutdown.set() def is_shutdown(self): ''' Returns True if shutdown was requested ''' return self._shutdown.is_set() ############################################### # Priority queue @sync def put(self, state_id): ''' Enqueue it for processing ''' self._states.append(state_id) self._lock.notify_all() return state_id @sync def get(self): ''' Dequeue a state with the max priority ''' #A shutdown has been requested if self.is_shutdown(): return None #if not more states in the queue lets wait for some forks while len(self._states) == 0: #if no worker is running bail out if self.running == 0: return None #if a shutdown has been requested bail out if self.is_shutdown(): return None #if there is actually some workers running wait for state forks logger.debug("Waiting for available states") self._lock.wait() state_id = random.choice(self._states) del self._states[self._states.index(state_id)] return state_id ############################################################### # File Storage def list(self): ''' Returns the list of states ids currently queued ''' return list(self._states) def generate_testcase(self, state, message='Testcase generated'): ''' Simply announce that we're going to generate a testcase. Actual generation should be handled by the driver class (such as :class:`~manticore.Manticore`) :param state: The state to generate information about :param message: Accompanying message ''' #broadcast test generation. This is the time for other modules #to output whatever helps to understand this testcase self.will_generate_testcase(state, message) def fork(self, state, expression, policy='ALL', setstate=None): ''' Fork state on expression concretizations. Using policy build a list of solutions for expression. For the state on each solution setting the new state with setstate For example if expression is a Bool it may have 2 solutions. True or False. Parent (expression = ??) Child1 Child2 (expression = True) (expression = True) setstate(True) setstate(False) The optional setstate() function is supposed to set the concrete value in the child state. ''' assert isinstance(expression, Expression) if setstate is None: setstate = lambda x,y: None #Find a set of solutions for expression solutions = state.concretize(expression, policy) #We are about to fork current_state with self._lock: self.will_fork_state(state, expression, solutions, policy) #Build and enqueue a state for each solution children = [] for new_value in solutions: with state as new_state: new_state.constrain(expression == new_value) #We already know it's sat #and set the PC of the new state to the concrete pc-dest #(or other register or memory address to concrete) setstate(new_state, new_value) #enqueue new_state state_id = self.add(new_state) #maintain a list of childres for logging purpose children.append(state_id) logger.debug("Forking current state into states %r",children) return None def run(self): ''' Entry point of the Executor; called by workers to start analysis. ''' #policy_order=self.policy_order #policy=self.policy current_state = None current_state_id = None with WithKeyboardInterruptAs(self.shutdown): #notify siblings we are about to start a run self._start_run() logger.debug("Starting Manticore Symbolic Emulator Worker (pid %d).",os.getpid()) while not self.is_shutdown(): try: #select a suitable state to analyze if current_state is None: with self._lock: #notify siblings we are about to stop this run self._stop_run() #Select a single state_id current_state_id = self.get() #load selected state from secondary storage if current_state_id is not None: current_state = self._workspace.load_state(current_state_id) self.will_load_state(current_state, current_state_id) #notify siblings we have a state to play with self._start_run() #If current_state is still None. We are done. if current_state is None: logger.debug("No more states in the queue, byte bye!") break assert current_state is not None try: # Allows to terminate manticore worker on user request while not self.is_shutdown(): if not current_state.execute(): break else: #Notify this worker is done self.will_terminate_state(current_state, current_state_id, 'Shutdown') current_state = None #Handling Forking and terminating exceptions except Concretize as e: #expression #policy #setstate() logger.debug("Generic state fork on condition") self.fork(current_state, e.expression, e.policy, e.setstate) current_state = None except TerminateState as e: #Notify this worker is done self.will_terminate_state(current_state, current_state_id, e) logger.debug("Generic terminate state") if e.testcase: self.generate_testcase(current_state, str(e)) current_state = None except SolverException as e: import traceback print "*** print_exc:" traceback.print_exc() #Notify this state is done self.will_terminate_state(current_state, current_state_id, e) if solver.check(current_state.constraints): self.generate_testcase(current_state, "Solver failed" + str(e)) current_state = None except (Exception, AssertionError) as e: import traceback trace = traceback.format_exc() logger.error("Exception: %s\n%s", str(e), trace) #Notify this worker is done self.will_terminate_state(current_state, current_state_id, 'Exception') current_state = None logger.setState(None) assert current_state is None #notify siblings we are about to stop this run self._stop_run() #Notify this worker is done (not sure it's needed) self.will_finish_run()