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()
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 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 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 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_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 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 __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 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 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 __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 _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 test_create_workspace_secondparam(): 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" assert workspace.JSON['name'] == "New Workspace in JSON" assert workspace.JSON['projects'] == {} assert workspace.JSON['created'] == "10/31/2019" assert workspace.JSON['edited'] == "10/31/2019" assert workspace.JSON['path'] == 'path'
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 explore(self, path): try: os.chdir(path) except IOError: print "There is no such directory" for root, dirnames, filenames in os.walk(os.getcwd()): for dirname in fnmatch.filter(dirnames, "*.xcworkspace"): os.chdir(dirname) path = os.path.abspath("contents.xcworkspacedata") w = Workspace(path) projects = w.projects self.workspaces.append(w) if self.workspaces.count == 0: pass
def on_click_launch(self): dir = self.entry_path.get() # Create workspace name = os.path.basename(dir) workspace = Workspace(name) # Read all the projects for filename in os.listdir(dir): if filename.endswith(".xml"): # Open XML and create a project xml = None p = Project.load_from_xml(xml) if p is not None: workspace.projects.append(p) Workspace.current = workspace
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 display_properites(self): """ Convenience method to handle a key : value display of user properties. The iRODS system contains only user wdk ids. Full names and email addresses are gleaned from the account db. """ print("\nPROPERTIES") properties_table = PrettyTable(["Property", "Value"]) properties_table.align = "l" properties_table.add_row(["User Info", self.formatted_user()]) if self.datasets: total_size = reduce(lambda acc, value: acc + value, [dataset.size for dataset in self.datasets])/1E6 else: total_size = 0 properties_table.add_row(["Usage", str(total_size) + " Mb"]) quota = float(Workspace(dashboard=self.dashboard).get_default_quota()) properties_table.add_row(["% Quota Used", round(100 * total_size/quota, 1)]) print(properties_table)
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)
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 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 post_install(): auth_code = request.args['code'] sc = SlackClient("") auth_response = sc.api_call( "oauth.access", client_id=client_id, client_secret=client_secret, code=auth_code ) workspace_access_token = auth_response['access_token'] workspace_bot_token = auth_response['bot']['bot_access_token'] # Add team to database workspace = Workspace(name =auth_response['team_name'], url = 'slack.com', access_token = workspace_access_token, bot_token = workspace_bot_token, team_id = auth_response['team_id']) workspace.save() # Disable reload for now # Reload listeners # andrew.loadRtm(workspace) return 'success', 200