def set_difficulty(self, difficulty): # with self.lock: print('difficulty') self.difficulty = difficulty content = self.contents[self.content_id](self.difficulty) self.inspector = Inspector(content, display_size) return 'New Content Created', HTTPStatus.OK
def __init__(self): self.start = self.set_attribute("start", lower_bound=2) self.cycles = self.set_attribute("cycles") self.constant = self.set_attribute("constant", is_bool=True) self.show_image = self.set_attribute("show_image", is_bool=True) self.save_image = self.set_attribute("save_image", is_bool=True) self.logger = self.set_attribute("logger", is_bool=True) self.global_command = False timer = time() print("\nGenerating objects...") self.object = Inspector(cycles=self.cycles, start=self.start, constant=self.constant, logger=self.logger) print(f"Done ({(time() - timer):.5}s).\n") timer = time() print("Performing initial benchmark...") self.object.benchmark() print(f"Done ({(time() - timer):.5}s).\n")
def setUp(self): self.ins = Inspector() exceptionHandler = ExceptionHandler() sys.excepthook = exceptionHandler.handler self.df_timeseries = pd.DataFrame( data=np.random.randn(10,2), index=pd.date_range('2016-10-29 22:00:00', periods=10) )
def __init__(self, data, **kw): i = Inspector(data) self.data = data self.options = GlobalOptions(kw) self.data_class = kw.get("class", i.data_class()) self.processors = processor.get_processors(self.data_class, exclude=kw.get("exclude", []), include=kw.get("include", [])) self.id = uuid.uuid1().hex self.name = i.name
def dispatch_database_inspector(args): """ Dispatch the database inspection tool :param args: Arguments passed to the script :return: None """ inspector = Inspector(args) inspector.run()
def main(): parser = argparse.ArgumentParser() parser.add_argument("--content", help="1: Point To Target" + " 2: Change Detection" + " 3: Odd One Out" + " 4: Visual Search" + " 5: Multiple Object Tracking" + " 6: Random Dot Motion Descrimination", type=int, default=1) args = parser.parse_args() content_type = args.content if content_type == CONTENT_POINT_TO_TARGET: content = PointToTargetContent() elif content_type == CONTENT_CHANGE_DETECTION: content = ChangeDetectionContent() elif content_type == CONTENT_ODD_ONE_OUT: content = OddOneOutContent() elif content_type == CONTENT_VISUAL_SEARCH: content = VisualSearchContent() elif content_type == CONTENT_MULTIPLE_OBJECT_TRACKING: content = MultipleObjectTrackingContent() else: content = RandomDotMotionDiscriminationContent() FPS = 60 display_size = (128 * 4 + 16, 500) inspector = Inspector(content, display_size) clock = pygame.time.Clock() running = True frame_count = 0 if RECORDING: writer = MovieWriter("out.mov", inspector.display_size, FPS) while running: for event in pygame.event.get(): if event.type == pygame.QUIT: running = False inspector.update() clock.tick(FPS) if RECORDING: d = inspector.get_frame() writer.add_frame(d) frame_count += 1 if frame_count > 1000: running = False if RECORDING: writer.close()
class HTTPWorker(Process): def __init__(self, name, headers, request_queue, url_filter, url_builder, result_queue, pause_time=0, allow_cookies=True): Process.__init__(self, name=name) self.__kill_event = None self.__request_queue = request_queue self.__url_filter = url_filter self.__url_builder = url_builder self.__pause_time = pause_time self.__exit = Event() self.__result_queue = result_queue self.inspector = Inspector() self.__session = requests.Session() self.__session.headers = headers if not allow_cookies: self.__session.cookies.set_policy(BlockCookiePolicy()) @property def kill_event(self): return self.__kill_event @kill_event.setter def kill_event(self, kill_event): self.__kill_event = kill_event def __request(self, log_entry): url = self.__url_builder.build(log_entry) try: start_request = datetime.datetime.now() response = self.__session.get(url) end_request = datetime.datetime.now() elapsed_time = end_request - start_request except requests.RequestException as e: self.inspector.inspect_fail(self.name, url, str(e.message)) else: self.inspector.inspect_succeed(self.name, url, log_entry, response, elapsed_time) def run(self): logging.debug('[%s] Starting worker', self.name) while (self.__kill_event and not self.__kill_event.is_set()) and (not self.__exit.is_set() or (not self.__request_queue.empty())): try: data = self.__request_queue.get(True, 0.5) if self.__url_filter.proceed(data): self.__request(data) except Empty: logging.debug('[%s] Queue is empty', self.name) except IOError as e: logging.error(e.message) else: sleep(self.__pause_time / 1000.0) self.__result_queue.put(self.inspector) logging.debug('[%s] Worker finished', self.name) def exit(self): self.__exit.set()
def set_content(self, content_id): with self.lock: self.content_id = content_id content = contents[self.content_id](self.difficulty) self.inspector = Inspector(content, display_size) ret = { 'difficulty_range': contents[content_id].difficulty_range, 'difficulty': -1, } return flask.jsonify(ret)
def __init__(self, locals={}, debug=False): if not isinstance(locals, PythonNamespace): self.locals = dict(PythonNamespace(locals)) else: self.locals = dict(locals) self.debug = debug self.trap = OutputTrap() self.inspector = Inspector() self.highlight = Highlight() self.index = 0
def __init__(self, trace: dict): self._filename = '<script>' self._source = trace['source'] self._input = trace['input'].splitlines() self._steps = trace['steps'] self._inspector = Inspector() self._result = None self._current_step = 0 self._input_index = 0 self._missing_input = False self._exec_call_frame = None # base frame (exec function call) self._print_cache = []
def __init__(self, parent, writer, corpus, log, color=(0, 0, 0)): wx.Panel.__init__(self, parent, style=wx.SUNKEN_BORDER) self.sourceboard = parent self.writer = writer self.color = color self.sizer = wx.BoxSizer(wx.VERTICAL) self.SetSizer(self.sizer) self.corpus = corpus self.name = corpus.documents[0].name self.log = log self.active = False self.weight = 100 self.suggestions = self.suggest(20) self.inspector = False self.sourcetile = SourceTile(self, self.name, self.log) self.sizer.Add(self.sourcetile) self.label = wx.StaticText(self, label='Weight') self.label.SetForegroundColour(self.color) self.sizer.Add(self.label) self.wt_slider = wx.Slider(self, value=100, minValue=0, maxValue=100) self.wt_slider.Bind(wx.EVT_COMMAND_SCROLL_THUMBRELEASE, self.OnWtSliderScroll) self.sizer.Add(self.wt_slider) """ self.f_label = wx.StaticText(self, label='Frequency') self.f_label.SetForegroundColour(self.color) self.sizer.Add(self.f_label) self.f_slider = wx.Slider(self, value=100, minValue=0, maxValue=100) self.f_slider.Bind(wx.EVT_COMMAND_SCROLL_THUMBRELEASE, self.OnFreqSliderScroll) self.sizer.Add(self.f_slider) self.sig_label = wx.StaticText(self, label='Sigscore') self.sig_label.SetForegroundColour(self.color) self.sizer.Add(self.sig_label) self.sig_slider = wx.Slider(self, value=100, minValue=0, maxValue=100) self.sig_slider.Bind(wx.EVT_COMMAND_SCROLL_THUMBRELEASE, self.OnSigSliderScroll) self.sizer.Add(self.sig_slider) """ #self.sourcetile.header.Bind(wx.EVT_LEFT_UP, self.OnClick) if self.inspector: self.sizer.Add( wx.StaticLine(self, -1, wx.Point(10, 30), wx.Size(200, 30))) self.inspector = Inspector(self, self.corpus.documents[0]) self.inspector.SetBackgroundColour((150, 150, 150)) self.sizer.Add(self.inspector)
class Runner(object): def __init__(self): self.content_id = 0 self.difficulty = -1 self.inspector = Inspector(contents[self.content_id](-1), display_size) self.lock = Lock() def init(self): self.set_content(0) self.set_difficulty(-1) return self.info() def info(self): return flask.jsonify({ 'content_range': len(contents), 'content': self.content_id, 'difficulty_range': contents[self.content_id].difficulty_range, 'difficulty': self.difficulty, }) def step(self): with self.lock: self.inspector.update() image = self.inspector.get_frame() data = cv2.imencode('.png', image)[1].tobytes() encoded = base64.encodestring(data) return make_response(encoded) def set_content(self, content_id): with self.lock: self.content_id = content_id content = contents[self.content_id](self.difficulty) self.inspector = Inspector(content, display_size) ret = { 'difficulty_range': contents[content_id].difficulty_range, 'difficulty': -1, } return flask.jsonify(ret) def set_difficulty(self, difficulty): with self.lock: self.difficulty = difficulty content = contents[self.content_id](self.difficulty) self.inspector = Inspector(content, display_size) return 'New Content Created', HTTPStatus.OK
class DetailPageRenderer(BasePageRenderer): template_name = 'detail_view.html' def __init__(self, klasses, klass, module): super(DetailPageRenderer, self).__init__(klasses) self.klass = klass self.module = module self.inspector = Inspector(self.klass, self.module) def get_context(self): context = super(DetailPageRenderer, self).get_context() available_versions = self.inspector.get_available_versions() context['other_versions'] = [ version for version in context['other_versions'] if version in available_versions ] context['name'] = self.klass context['ancestors'] = self.inspector.get_klass_mro() context['direct_ancestors'] = self.inspector.get_direct_ancestors() context['attributes'] = self.inspector.get_attributes() context['methods'] = self.inspector.get_methods() context['this_klass'] = next( ifilter(lambda x: x.__name__ == self.klass, self.klasses)) context['children'] = self.inspector.get_children() context['this_module'] = context['this_klass'].__module__ context[ 'unavailable_methods'] = self.inspector.get_unavailable_methods() return context
class Runner(object): def __init__(self): self.content_id = 0 self.inspector = Inspector(contents[self.content_id], display_size) self.lock = Lock() def step(self): with self.lock: self.inspector.update() image = self.inspector.get_frame() data = cv2.imencode('.png', image)[1].tobytes() encoded = base64.encodestring(data) return make_response(encoded) def swap(self, content_id): with self.lock: self.inspector = Inspector(contents[content_id], display_size) return 'Switched Content', HTTPStatus.OK
def test_inspector(): from inspector import Inspector ksy_file = os.path.join(tests_dir, 'data/png.ksy') test_file = os.path.join(tests_dir, 'data/sample.png') Inspector(ksy_file, test_file, verbose=True) print('OK')
def __init__(self): from inspector import Inspector from oculoenv import PointToTargetContent, ChangeDetectionContent, OddOneOutContent, VisualSearchContent, MultipleObjectTrackingContent, RandomDotMotionDiscriminationContent self.contents = [ PointToTargetContent, ChangeDetectionContent, OddOneOutContent, VisualSearchContent, MultipleObjectTrackingContent, RandomDotMotionDiscriminationContent, ] self.content_id = args.content self.difficulty = -1 self.inspector = Inspector( self.contents[args.content](-1), display_size, model_name=args.model_name, use_ppo_models=args.use_ppo_models ) self.lock = Lock()
def init_webview(self): self.webview = webkit.WebView() self.web_frame = self.webview.get_main_frame() self.web_scroll = gtk.ScrolledWindow() self.web_scroll.set_shadow_type(gtk.SHADOW_ETCHED_OUT) self.webview.get_settings().set_property("enable-developer-extras", True) self.webview.connect("document-load-finished", self.webkit_loaded_cb) self.webview.connect("hovering-over-link", self.over_link_cb) self.webview.connect_after("populate-popup", self.populate_popup_cb) Inspector(self.webview.get_web_inspector()) self.web_scroll.add(self.webview)
class DetailPageRenderer(BasePageRenderer): template_name = 'detail_view.html' def __init__(self, klasses, klass, module): super(DetailPageRenderer, self).__init__(klasses) self.klass = klass self.module = module self.inspector = Inspector(self.klass, self.module) def get_context(self): context = super(DetailPageRenderer, self).get_context() available_versions = self.inspector.get_available_versions() context['other_versions'] = [ version for version in context['other_versions'] if version in available_versions] context['name'] = self.klass context['ancestors'] = self.inspector.get_klass_mro() context['direct_ancestors'] = self.inspector.get_direct_ancestors() context['attributes'] = self.inspector.get_attributes() context['methods'] = self.inspector.get_methods() context['this_klass'] = next( ifilter(lambda x: x.__name__ == self.klass, self.klasses)) context['children'] = self.inspector.get_children() context['this_module'] = context['this_klass'].__module__ return context
def createMasterInspectionXML(self, delChildXMLs = False): lt = ListTool() os = OSTool() sort = Sorter() insp = Inspector() xmls = os.getFilesInDir('results/') xmls = lt.popByWord(xmls, self.masterInspectionPath) XMLInspections = insp.getInspections(xmls) if len(XMLInspections) == 0: print('No files read.') exit() XMLInspections = sort.sortInspectionList(XMLInspections) xWriter = XMLWriter() xWriter.writeMIXML(XMLInspections, self.masterInspectionPath) if delChildXMLs: for xml in xmls: os.deleteFile(xml)
def __init__(self, name, headers, request_queue, url_filter, url_builder, result_queue, pause_time=0, allow_cookies=True): Process.__init__(self, name=name) self.__kill_event = None self.__request_queue = request_queue self.__url_filter = url_filter self.__url_builder = url_builder self.__pause_time = pause_time self.__exit = Event() self.__result_queue = result_queue self.inspector = Inspector() self.__session = requests.Session() self.__session.headers = headers if not allow_cookies: self.__session.cookies.set_policy(BlockCookiePolicy())
def __init__(self, builder, theme): webkit.WebView.__init__(self) providers.ProviderHandler.__init__(self, "context_page") # HACK: so that the panel menu works self.tree = self self.connect_events() self.hover = '' self.theme = theme self.loaded = False self.currentpage = None self.nowplaying = None self.history = [] self.history_index = 0 self.builder = builder self.setup_dnd() self.setup_buttons() self.drag_source_set(gtk.gdk.BUTTON1_MASK, self.targets, gtk.gdk.ACTION_COPY | gtk.gdk.ACTION_MOVE) self.drag_source_set_icon_stock(gtk.STOCK_DND) event.add_callback(self.on_playback_start, 'playback_track_start', player.PLAYER) event.add_callback(self.on_playback_end, 'playback_track_end', player.PLAYER) event.add_callback(self.on_tags_parsed, 'tags_parsed', player.PLAYER) self.get_settings().set_property('enable-developer-extras', True) #FIXME: HACK! ajust zoom level for the new webkit version try: self.get_settings().get_property("enable-developer-extras") self.set_zoom_level(0.8) except: pass glib.idle_add(self.on_home_clicked) # javascript debugger inspector = Inspector(self.get_web_inspector())
def __init__(self): self.deck = Deck() self.remainingDeck = copy.deepcopy(self.deck) self.playedPile = PlayedPile() self.discardPile = DiscardPile() self.registeredPlayers = [] self.currPlayer = None self.numCluesAvailable = 8 self.livesRemaining = 3 self.moveHistory = [] self.numTurns = 0 self.inspector = Inspector(self)
def _construct_tab_view(self, web_view, url=None): web_view.connect("resource-request-starting", self._resource_cb) #web_view.connect('navigation-policy-decision-requested',self._navigation_cb) web_view.connect("hovering-over-link", self._hovering_over_link_cb) web_view.connect("populate-popup", self._populate_page_popup_cb) web_view.connect("load-finished", self._view_load_finished_cb) web_view.connect("create-web-view", self._new_web_view_request_cb) web_view.connect("title-changed", self._title_changed_cb) inspector = Inspector(web_view.get_web_inspector()) scrolled_window = gtk.ScrolledWindow() scrolled_window.props.hscrollbar_policy = gtk.POLICY_AUTOMATIC scrolled_window.props.vscrollbar_policy = gtk.POLICY_AUTOMATIC scrolled_window.add(web_view) scrolled_window.show_all() # create the tab label = TabLabel(url, scrolled_window) label.connect("close", self._close_tab) label.show_all() new_tab_number = self.append_page(scrolled_window, label) self.set_tab_label_packing(scrolled_window, False, False, gtk.PACK_START) self.set_tab_label(scrolled_window, label) # hide the tab if there's only one self.set_show_tabs(self.get_n_pages() > 1) self.show_all() self.set_current_page(new_tab_number) # load the content self._hovered_uri = None if not url: web_view.load_string(ABOUT_PAGE, "text/html", "iso-8859-15", "about") else: web_view.load_uri(url)
def __init__(self, opener): """ In this code, we set user-agent of this webkit view based on code from: http://nullege.com/codes/show/src%40p%40r%40PrisPy-HEAD%40PrisPy.py/33/webkit.WebView/python """ self.opener = opener webkit.WebView.__init__(self) self.set_highlight_text_matches(True) settings = self.get_settings() self.ua = settings.get_property('user-agent') if self.ua.find("AppleWebKit") > -1: # Without this, javascript will give many javascript # errors on item mouseover, TypeError: Result of # expression 'a' [null] is not an object. in # its.webkitVersion self.ua = USER_AGENT + ' ' + self.ua[self.ua.find("AppleWebKit"):] else: self.ua = USER_AGENT settings.set_property('user-agent', self.ua) # These might possibly improve dns response? #settings.set_property('enable-dns-prefetching', False) settings.set_property('enable-site-specific-quirks', True) # Enable inspector: settings.set_property("enable-developer-extras", True) self._inspector = Inspector(self.get_inspector()) self.set_settings(settings) # These signals are documented in webkit.WebView.__doc__ self.connect("load-finished", self.webKitLoaded) self.connect("navigation-policy-decision-requested", self.webkitGo) self.connect("new-window-policy-decision-requested", self.newWin) #requires webkit 1.1.4 self.connect("download-requested", self.downloadReq) current = os.path.dirname(os.path.realpath(__file__)) self.injectJavascript = file(os.path.join(current, "Javascript.js"), "r").read()
def createInspector(self): from inspector import Inspector self.inspector = Inspector(self, self.parent, -1, 'Inspector' \ , pos=(500,50) \ , size=wx.Size(450,550)) self.inspector.Show(True)
if content: print ("Content inspection selected") if request_type == "HEAD": print ("WARNING: HEAD requests make Content inspection useless") discriminator = args.discriminator if discriminator: print ("Discriminator active") if request_type == "HEAD": print ("WARNING: HEAD requests make Content inspection useless") autodiscriminator = args.autodiscriminator autodiscriminator_location = None if autodiscriminator: print ("Launching autodiscriminator") i = Inspector(target) r = i.check_this() if r[1] == Inspector.TEST404_URL: autodiscriminator_location = r[0] print ("404 ---> 302 ----> " + autodiscriminator_location) print ("Banned response codes: %s" % " ".join(banned_response_codes)) if not extension == [""]: print ("Extensions to probe: %s" % " ".join(extension)) uppercase = args.uppercase if uppercase: print ("All resource requests will be done in uppercase") request_delay = args.request_delay
def __init__(self, klasses, klass, module): super(DetailPageRenderer, self).__init__(klasses) self.klass = klass self.module = module self.inspector = Inspector(self.klass, self.module)
class Tracer: """ Traces python source and analyses its state after each instruction. """ def __init__(self, trace: dict): self._filename = '<script>' self._source = trace['source'] self._input = trace['input'].splitlines() self._steps = trace['steps'] self._inspector = Inspector() self._result = None self._current_step = 0 self._input_index = 0 self._missing_input = False self._exec_call_frame = None # base frame (exec function call) self._print_cache = [] def run(self): self._result = {"steps": []} globals = scope.sandbox_globals(self._filename) globals['__builtins__']['input'] = HookedInput(self._input_hook) globals['__builtins__']['print'] = HookedPrint(self._print_hook) try: compiled = compile(self._source, self._filename, 'exec') sys.settrace(self._trace) exec(compiled, globals) except TracerStopException as e: # UserWarning is generated by the tracer to stop (the only way to stop it) # These exceptions are not caused by the application, hence they use the cause field instead of exception self._result["steps"].append({'threw': {'cause': str(e)}}) pass except Exception as e: # Exceptions that caused the source program stop or the tracer program # They can be clearly distincted by their tracebacks self._result["steps"].append({'threw': {'exception': dump_exception(e, remove_lines=(1,))}}) finally: sys.settrace(None) return self._result def _trace(self, frame: types.FrameType, event: str, args): if not frame.f_code.co_filename == self._filename or not event in {'call', 'line', 'exception', 'return'}: return self._trace if self._exec_call_frame is None: self._exec_call_frame = frame.f_back self._current_step += 1 if self._current_step > self._steps: raise TracerStopException(f'reached maximum step: {self._steps}') if self._missing_input: raise TracerStopException('input not enough') self._result["steps"].append({ 'snapshot': self._inspector.inspect(frame, event, args, self._exec_call_frame), 'prints': self._print_cache }) self._print_cache = [] return self._trace def _input_hook(self, prompt: str): self._print_cache.append(prompt) if self._input_index < len(self._input): self._input_index += 1 return self._input[self._input_index - 1] self._missing_input = True return None def _print_hook(self, text: str): self._print_cache.append(text)
class WorkGroup(wx.Frame): def __init__(self, parent, empty=False): self.parent = parent self._preferences = Preferences(self) self.list_geo = [] self.list_space = [] self.list_field = [] self.stockUndo = [] self.stockRedo = [] self.createInspector() self.createViewer() # self.createFields() self.initialize(empty=empty) self.directAct = directActions(self) # needed when saving the workgroup self.filename = None # needed for temporary save t = localtime() tmp_file = "session-"\ +str(t.tm_year)+"-"+str(t.tm_mon)+"-"+str(t.tm_mday)\ +"_"+str(t.tm_hour)+"h"+str(t.tm_min)+"min"\ +".wkl" self.tmp_filename = tmp_file # auto save is activated by default self.auto_save = True self._macroRecording = False self._macro_script = scripture(self) self._pythonEditor = PythonEditor(self.parent, -1, '') self._pythonEditor.Show(False) @property def pythonEditor(self): return self._pythonEditor def set_pythonEditor(self, edt): self._pythonEditor = edt @property def preferences(self): return self._preferences def set_macroRecording(self, value): self._macroRecording = value @property def macroRecording(self): return self._macroRecording @property def macro_script(self): return self._macro_script def initialize(self, empty=False): """ create an empty geometry object """ if not empty: from geometry import geometry geo = geometry() self.add_geometry(geo) def createViewer(self): from viewer import Viewer self.viewer = Viewer(self, self.parent \ , pos=(500,50) \ , size=wx.Size(700,700)) self.viewer.Show(True) def createInspector(self): from inspector import Inspector self.inspector = Inspector(self, self.parent, -1, 'Inspector' \ , pos=(500,50) \ , size=wx.Size(450,550)) self.inspector.Show(True) def createSpaces(self): from spaces import Inspector self.spaces = Inspector(self, self.parent, -1, 'Spaces' \ , pos=(500,300) \ , size=wx.Size(450,550)) self.spaces.Show(True) def createFields(self): from fields import Inspector self.fields = Inspector(self, self.parent, -1, 'Fields' \ , pos=(500,300) \ , size=wx.Size(450,550)) self.fields.Show(True) def appendAction(self, undo): self.stockUndo.append(undo) if self.stockRedo: try: del self.stockRedo[:] except: print("problem occurs while deleting stockRedo") def add_geometry(self, geo, activeUndo=True): self.list_geo.append(geo) geoItem = self.inspector.add_geometry(geo) geo.set_treeItem(geoItem) # undo action if activeUndo: undo = UndoAddGeometry(self, geoItem, geo) self.appendAction(undo) self.Refresh() return geoItem def add_patch(self, geoItem, geo, patch, activeUndo=True): geo.append(patch) patchItem = self.inspector.add_patch(geoItem, geo, patch) # undo action if activeUndo: undo = UndoAddPatch(self, patchItem, patch, geo, geoItem) self.appendAction(undo) self.Refresh() return patchItem def add_space(self, geo, testcase=None): # create the Frame if list_space is empty if len(self.list_space) == 0: self.createSpaces() from pigasus.fem.basicPDE import basicPDE if testcase is None: testcase = {} testcase['AllDirichlet'] = True PDE = basicPDE(geometry=geo, testcase=testcase) V = PDE.space self.list_space.append(V) self.spaces.add_space(V) self.Refresh() def add_field(self, field): if len(self.list_field) == 0: self.createFields() self.list_field.append(field) self.fields.Show(True) self.fields.add_field(field) self.Refresh() def remove_geometry(self, geoItem, geo, activeUndo=True): # undo action if activeUndo: undo = UndoRemoveGeometry(self, geoItem, geo) self.appendAction(undo) # remove geo from the dictionary self.list_geo.remove(geo) # delete the corresponding item from the inspector self.inspector.remove_geometry(geoItem) self.inspector.reset_currentAll() # refresh the viewer self.Refresh() def remove_patch(self, patchItem, patch, geo=None, activeUndo=True): # remove patch from the dictionary if geo is None: geo = self.get_geometry_from_patch(patch) # undo action if activeUndo: geoItem = self.inspector.tree.GetItemParent(patchItem) undo = UndoRemovePatch(self, patchItem, patch, geo, geoItem) self.appendAction(undo) geo.remove_patch(patch) print("%") # delete the corresponding item from the inspector self.inspector.remove_patch(patchItem) print("%%") self.inspector.reset_currentAll() print("%%%") # refresh the viewer self.Refresh() def remove_field(self, fieldItem, field): # remove geo from the dictionary self.list_field.remove(field) # delete the corresponding item from the inspector self.fields.remove_field(fieldItem) self.fields.reset_currentAll() # refresh the viewer self.Refresh() def get_geometry_from_patch(self, patch): # remove patch from the dictionary print(("looking for patch ", id(patch))) for geo in self.list_geo: for nrb in geo: print((id(nrb))) if id(nrb) == id(patch): print("found.") return geo print("Not found.") def Refresh(self, inspector=False): if inspector: self.inspector.Refresh() # save in temp file if self.auto_save: self.save(filename=self.tmp_filename) self.viewer.drawWorld() self.viewer.Refresh() def message(self, txt): self.viewer.statusbar.SetStatusText(txt) def save(self, filename=None): if filename is None: filename = self.filename # this means that self.filename is also None if filename is None: # Create a save file dialog from global_vars import CAIDWorkGroupwildcard dialog = wx.FileDialog ( None\ , style = wx.SAVE | wx.OVERWRITE_PROMPT\ , wildcard=CAIDWorkGroupwildcard) # Show the dialog and get user input if dialog.ShowModal() == wx.ID_OK: filename = dialog.GetPath() self.filename = filename # The user did not select anything else: print('Nothing was selected.') # Destroy the dialog dialog.Destroy() # ... create xml doc from xml.dom.minidom import Document # Create the minidom document doc = Document() # Create the <theme> base element rootElt = self.viewer.theme.save(doc=doc) # Create the <caid> base element rootElt = doc.createElement("caid") # set camera attributs eye = self.viewer.lookAt.GetEye() rootElt.setAttribute("eye", str(eye)) center = self.viewer.lookAt.GetCenter() rootElt.setAttribute("center", str(center)) up = self.viewer.lookAt.GetUp() rootElt.setAttribute("up", str(up)) doc.appendChild(rootElt) # ... # ... themeElt, doc = self.viewer.theme.save(doc=doc) rootElt.appendChild(themeElt) # ... # ... from caid.io import XML io = XML() for geo in self.list_geo: geo.save_attributs() geoElt = doc.createElement("geometry") doc = io.geotoxml(geo, doc, geoElt) rootElt.appendChild(geoElt) # ... if filename is not None: with open(filename, 'w') as f: f.write(doc.toprettyxml()) else: print("No file was specified") def open(self, filename=None): if filename is not None: self.filename = filename else: from global_vars import CAIDWorkGroupwildcard # Create an open file dialog dialog = wx.FileDialog(None\ , style = wx.OPEN\ , wildcard=CAIDWorkGroupwildcard) # Show the dialog and get user input if dialog.ShowModal() == wx.ID_OK: self.filename = dialog.GetPath() # The user did not select anything else: print('Nothing was selected.') # Destroy the dialog dialog.Destroy() from caid.cad_geometry import cad_geometry from caid.io import XML from geometry import geometry io = XML() from xml.dom.minidom import parse doc = parse(self.filename) rootElt = doc.documentElement # read attributs # get camera attributs eye = strtoArray(rootElt.getAttribute("eye")) self.viewer.lookAt.SetEye(eye) center = strtoArray(rootElt.getAttribute("center")) self.viewer.lookAt.SetCenter(center) up = strtoArray(rootElt.getAttribute("up")) self.viewer.lookAt.SetUp(up) # get colors attributs # ... try: self.viewer.theme.load(rootElt=rootElt) except: print("Theme can not be loaded. Dark theme will be used.") self.viewer.theme.set_theme("dark") # ... for geoElt in rootElt.getElementsByTagName("geometry"): geo = cad_geometry() io.xmltogeo(geo, doc, geoElt) _geo = geometry(geo) _geo.load_attributs() self.add_geometry(_geo) self.Refresh() # sets the temporary file for auto-save tmp = self.filename.split('/')[-1] basedir = self.filename.split(tmp)[0] self.tmp_filename = basedir + "~" + tmp
def createSpaces(self): from spaces import Inspector self.spaces = Inspector(self, self.parent, -1, 'Spaces' \ , pos=(500,300) \ , size=wx.Size(450,550)) self.spaces.Show(True)
class WorkGroup(wx.Frame): def __init__(self, parent, empty=False): self.parent = parent self._preferences = Preferences(self) self.list_geo = [] self.list_space = [] self.list_field = [] self.stockUndo = [] self.stockRedo = [] self.createInspector() self.createViewer() # self.createFields() self.initialize(empty=empty) self.directAct = directActions(self) # needed when saving the workgroup self.filename = None # needed for temporary save t = localtime() tmp_file = "session-"\ +str(t.tm_year)+"-"+str(t.tm_mon)+"-"+str(t.tm_mday)\ +"_"+str(t.tm_hour)+"h"+str(t.tm_min)+"min"\ +".wkl" self.tmp_filename = tmp_file # auto save is activated by default self.auto_save = True self._macroRecording = False self._macro_script = scripture(self) self._pythonEditor = PythonEditor(self.parent, -1, '') self._pythonEditor.Show(False) @property def pythonEditor(self): return self._pythonEditor def set_pythonEditor(self, edt): self._pythonEditor = edt @property def preferences(self): return self._preferences def set_macroRecording(self, value): self._macroRecording = value @property def macroRecording(self): return self._macroRecording @property def macro_script(self): return self._macro_script def initialize(self, empty=False): """ create an empty geometry object """ if not empty: from geometry import geometry geo = geometry() self.add_geometry(geo) def createViewer(self): from viewer import Viewer self.viewer = Viewer(self, self.parent \ , pos=(500,50) \ , size=wx.Size(700,700)) self.viewer.Show(True) def createInspector(self): from inspector import Inspector self.inspector = Inspector(self, self.parent, -1, 'Inspector' \ , pos=(500,50) \ , size=wx.Size(450,550)) self.inspector.Show(True) def createSpaces(self): from spaces import Inspector self.spaces = Inspector(self, self.parent, -1, 'Spaces' \ , pos=(500,300) \ , size=wx.Size(450,550)) self.spaces.Show(True) def createFields(self): from fields import Inspector self.fields = Inspector(self, self.parent, -1, 'Fields' \ , pos=(500,300) \ , size=wx.Size(450,550)) self.fields.Show(True) def appendAction(self, undo): self.stockUndo.append( undo ) if self.stockRedo: try: del self.stockRedo[:] except: print("problem occurs while deleting stockRedo") def add_geometry(self, geo, activeUndo=True): self.list_geo.append(geo) geoItem = self.inspector.add_geometry(geo) geo.set_treeItem(geoItem) # undo action if activeUndo: undo = UndoAddGeometry(self, geoItem, geo) self.appendAction(undo) self.Refresh() return geoItem def add_patch(self, geoItem, geo, patch, activeUndo=True): geo.append(patch) patchItem = self.inspector.add_patch(geoItem, geo, patch) # undo action if activeUndo: undo = UndoAddPatch(self, patchItem, patch, geo, geoItem) self.appendAction(undo) self.Refresh() return patchItem def add_space(self, geo, testcase=None): # create the Frame if list_space is empty if len(self.list_space) == 0: self.createSpaces() from pigasus.fem.basicPDE import basicPDE if testcase is None: testcase = {} testcase['AllDirichlet'] = True PDE = basicPDE(geometry=geo, testcase=testcase) V = PDE.space self.list_space.append(V) self.spaces.add_space(V) self.Refresh() def add_field(self, field): if len(self.list_field) == 0: self.createFields() self.list_field.append(field) self.fields.Show(True) self.fields.add_field(field) self.Refresh() def remove_geometry(self, geoItem, geo, activeUndo=True): # undo action if activeUndo: undo = UndoRemoveGeometry(self, geoItem, geo) self.appendAction(undo) # remove geo from the dictionary self.list_geo.remove(geo) # delete the corresponding item from the inspector self.inspector.remove_geometry(geoItem) self.inspector.reset_currentAll() # refresh the viewer self.Refresh() def remove_patch(self, patchItem, patch, geo=None, activeUndo=True): # remove patch from the dictionary if geo is None: geo = self.get_geometry_from_patch(patch) # undo action if activeUndo: geoItem = self.inspector.tree.GetItemParent(patchItem) undo = UndoRemovePatch(self, patchItem, patch, geo, geoItem) self.appendAction(undo) geo.remove_patch(patch) print("%") # delete the corresponding item from the inspector self.inspector.remove_patch(patchItem) print("%%") self.inspector.reset_currentAll() print("%%%") # refresh the viewer self.Refresh() def remove_field(self, fieldItem, field): # remove geo from the dictionary self.list_field.remove(field) # delete the corresponding item from the inspector self.fields.remove_field(fieldItem) self.fields.reset_currentAll() # refresh the viewer self.Refresh() def get_geometry_from_patch(self, patch): # remove patch from the dictionary print(("looking for patch ", id(patch))) for geo in self.list_geo: for nrb in geo: print((id(nrb))) if id(nrb) == id(patch): print("found.") return geo print("Not found.") def Refresh(self, inspector=False): if inspector: self.inspector.Refresh() # save in temp file if self.auto_save: self.save(filename=self.tmp_filename) self.viewer.drawWorld() self.viewer.Refresh() def message(self, txt): self.viewer.statusbar.SetStatusText(txt) def save(self, filename=None): if filename is None: filename = self.filename # this means that self.filename is also None if filename is None: # Create a save file dialog from global_vars import CAIDWorkGroupwildcard dialog = wx.FileDialog ( None\ , style = wx.SAVE | wx.OVERWRITE_PROMPT\ , wildcard=CAIDWorkGroupwildcard) # Show the dialog and get user input if dialog.ShowModal() == wx.ID_OK: filename = dialog.GetPath() self.filename = filename # The user did not select anything else: print('Nothing was selected.') # Destroy the dialog dialog.Destroy() # ... create xml doc from xml.dom.minidom import Document # Create the minidom document doc = Document() # Create the <theme> base element rootElt = self.viewer.theme.save(doc=doc) # Create the <caid> base element rootElt = doc.createElement("caid") # set camera attributs eye = self.viewer.lookAt.GetEye() rootElt.setAttribute("eye", str(eye)) center = self.viewer.lookAt.GetCenter() rootElt.setAttribute("center", str(center)) up = self.viewer.lookAt.GetUp() rootElt.setAttribute("up", str(up)) doc.appendChild(rootElt) # ... # ... themeElt, doc = self.viewer.theme.save(doc=doc) rootElt.appendChild(themeElt) # ... # ... from caid.io import XML io = XML() for geo in self.list_geo: geo.save_attributs() geoElt = doc.createElement("geometry") doc = io.geotoxml(geo, doc, geoElt) rootElt.appendChild(geoElt) # ... if filename is not None: f = open(filename, 'wr') s = doc.toprettyxml() f.write(s) f.close() else: print("No file was specified") def open(self, filename=None): if filename is not None: self.filename = filename else: from global_vars import CAIDWorkGroupwildcard # Create an open file dialog dialog = wx.FileDialog(None\ , style = wx.OPEN\ , wildcard=CAIDWorkGroupwildcard) # Show the dialog and get user input if dialog.ShowModal() == wx.ID_OK: self.filename = dialog.GetPath() # The user did not select anything else: print('Nothing was selected.') # Destroy the dialog dialog.Destroy() from caid.cad_geometry import cad_geometry from caid.io import XML from geometry import geometry io = XML() from xml.dom.minidom import parse doc = parse(self.filename) rootElt = doc.documentElement # read attributs # get camera attributs eye = strtoArray(rootElt.getAttribute("eye")) self.viewer.lookAt.SetEye(eye) center = strtoArray(rootElt.getAttribute("center")) self.viewer.lookAt.SetCenter(center) up = strtoArray(rootElt.getAttribute("up")) self.viewer.lookAt.SetUp(up) # get colors attributs # ... try: self.viewer.theme.load(rootElt=rootElt) except: print("Theme can not be loaded. Dark theme will be used.") self.viewer.theme.set_theme("dark") # ... for geoElt in rootElt.getElementsByTagName("geometry"): geo = cad_geometry() io.xmltogeo(geo, doc, geoElt) _geo = geometry(geo) _geo.load_attributs() self.add_geometry(_geo) self.Refresh() # sets the temporary file for auto-save tmp = self.filename.split('/')[-1] basedir = self.filename.split(tmp)[0] self.tmp_filename = basedir+"~"+tmp
def __init__(self, replication_id): # BS: class constructor print('Simulation Start') self.running = True # Track current time self.clock = 0 # Instantiate logger EXCEL_DIR = os.path.join(LOG_DIR, 'excel') CSV_DIR = os.path.join(LOG_DIR, 'csv') os.makedirs(LOG_DIR, exist_ok=True) os.makedirs(EXCEL_DIR, exist_ok=True) os.makedirs(CSV_DIR, exist_ok=True) OUT_PATH = os.path.join(CSV_DIR, f'rep{replication_id}.log') self.log = Logger(OUT_PATH) self.log.write_header() # Track number of products output in order to calculate throughput self.num_P1 = 0 self.num_P2 = 0 self.num_P3 = 0 # Track time inspectors (either, or both) spend blocked self.blocked_time = 0 # blocked inspectors list self.blocked_inspectors = list() # Setup FEL self.event_list = PriorityQueue() # Create workstations ws_1 = Workstation(self, 'WS1', WS1_LAM, [ComponentType.C1], ProductType.P1) ws_2 = Workstation(self, 'WS2', WS2_LAM, [ComponentType.C1, ComponentType.C2], ProductType.P2) ws_3 = Workstation(self, 'WS3', WS3_LAM, [ComponentType.C1, ComponentType.C3], ProductType.P3) # LBS: without need to declare workstations as list self.workstations = [ws_1, ws_2, ws_3] # Create inspectors # LBS: ins_1_lambdas is a dict formatted as �� key: value...�� ins_1_lambdas = {ComponentType.C1: IN1_LAM} ins_1 = Inspector(self, 'IN1', ins_1_lambdas, [ComponentType.C1], [ws_1, ws_2, ws_3], OutputPolicy.NAIVE) ins_2_lambdas = { ComponentType.C2: IN2_LAM_C2, ComponentType.C3: IN2_LAM_C3 } ins_2 = Inspector(self, 'IN2', ins_2_lambdas, [ComponentType.C2, ComponentType.C3], [ws_2, ws_3], OutputPolicy.NAIVE) self.inspectors = [ins_1, ins_2] # Generate initial events # These should be the two inspectors' first component selections self.schedule_inspection(ins_1, ins_1.generate_time(0, ins_1.component)) self.schedule_inspection(ins_2, ins_2.generate_time(0, ins_2.component)) # As well as an end-simulation event self.schedule_event(EndSimulationEvent(END_TIME)) # Open Excel log self.TimeColumn = 0 self.CurrentEventColumn = 1 self.EventListColumn = 2 self.Inspector1Column = 3 self.Inspector2Column = 4 self.WS1_C1_Q_Column = 5 self.WS2_C1_Q_Column = 6 self.WS2_C2_Q_Column = 7 self.WS3_C1_Q_Column = 8 self.WS3_C3_Q_Column = 9 self.BLOCKED_IN1 = 10 self.BLOCKED_IN2 = 11 self.NUM_P1 = 12 self.NUM_P2 = 13 self.NUM_P3 = 14 self.BLOCK_INS_LIST = 15 self.WS1_BUSY = 16 self.WS2_BUSY = 17 self.WS3_BUSY = 18 self.now = time.strftime("%H-%M-%S") self.logfile = os.path.join(EXCEL_DIR, "Log" + str(replication_id) + ".xls") print("new file:" + self.logfile) self.workbook = xlwt.Workbook(self.logfile) self.worksheet = self.workbook.add_sheet('log1', cell_overwrite_ok=True) self.rows_old = 0 self.write_excel_xls_append("Time", self.TimeColumn) self.write_excel_xls_append("CurrentEvent", self.CurrentEventColumn) self.write_excel_xls_append("EventList", self.EventListColumn) self.write_excel_xls_append("Inspector1", self.Inspector1Column) self.write_excel_xls_append("Inspector2", self.Inspector2Column) self.write_excel_xls_append("WS1_C1_Q", self.WS1_C1_Q_Column) self.write_excel_xls_append("WS2_C1_Q", self.WS2_C1_Q_Column) self.write_excel_xls_append("WS2_C2_Q", self.WS2_C2_Q_Column) self.write_excel_xls_append("WS3_C1_Q", self.WS3_C1_Q_Column) self.write_excel_xls_append("WS3_C3_Q", self.WS3_C3_Q_Column) self.write_excel_xls_append("blocked_IN1", self.BLOCKED_IN1) self.write_excel_xls_append("blocked_IN2", self.BLOCKED_IN2) self.write_excel_xls_append("num_P1", self.NUM_P1) self.write_excel_xls_append("num_P2", self.NUM_P2) self.write_excel_xls_append("num_P3", self.NUM_P3) self.write_excel_xls_append("blockInsList", self.BLOCK_INS_LIST) self.write_excel_xls_append("ws1Busy", self.WS1_BUSY) self.write_excel_xls_append("ws2Busy", self.WS2_BUSY) self.write_excel_xls_append("ws3Busy", self.WS3_BUSY) # Print initial state to console self.print_current_state_beforeproc(None) self.print_inspectors() self.print_workstations() self.print_event_list() self.print_current_state_afterproc(None) # Print initial state to console self.print_current_state_beforeproc(None) self.print_inspectors() self.print_workstations() self.print_event_list() self.print_current_state_afterproc(None)
def cli(container, no_name, pretty): # TODO: -i, -t, -d as added options that override the inspection ins = Inspector(container, no_name, pretty) ins.inspect() print(ins.format_cli())
class PythonInterpreter(object): """Customized Python interpreter with two-stage evaluation. """ filename = '<online-lab>' def __init__(self, locals={}, debug=False): if not isinstance(locals, PythonNamespace): self.locals = dict(PythonNamespace(locals)) else: self.locals = dict(locals) self.debug = debug self.trap = OutputTrap() self.inspector = Inspector() self.highlight = Highlight() self.index = 0 def complete(self, source): """Get all completions for an initial source code. """ interrupted = False try: completer = rlcompleter.Completer(self.locals) matches = set([]) state = 0 while True: result = completer.complete(source, state) if result is not None: matches.add(result) state += 1 else: break completions = [] for match in sorted(matches): if match[-1] == '(': match = match[:-1] if '.' in match: name, attrs = match.split('.', 1) else: name, attrs = match, None try: obj = self.locals[name] except KeyError: obj = None else: if attrs is not None: for attr in attrs.split('.'): obj = getattr(obj, attr) if obj is not None: info = self.inspector.get_basic_info(obj) else: info = {'type': 'keyword'} completions.append({ 'match': match, 'info': info, }) except KeyboardInterrupt: completions = None interrupted = True return { 'completions': completions, 'interrupted': interrupted, } def evaluate(self, source): """Evaluate a piece of Python source code. """ source = source.replace('\r', '').rstrip() # XXX: make all this SIGINT aware if '\n' in source: exec_source, eval_source = self.split(source) else: exec_source, eval_source = None, source eval_source += '\n' try: self.compile(eval_source, 'eval') except (OverflowError, SyntaxError, ValueError): if '\n' not in source and self.is_inspect(source): return self.inspect(source) exec_source = source eval_source = None # If in debug mode, then don't setup output trap so that we can # run a debugger (e.g. pdb). Note that stdout and stderr won't # be captured and stored in the resulting dict object. if not self.debug: self.trap.set() try: try: del self.locals['__plots__'] except KeyError: pass interrupted = False traceback = False result = None start = time.clock() try: if exec_source is not None: try: exec_code = self.compile(exec_source, 'exec') except (OverflowError, SyntaxError, ValueError): traceback = self.syntaxerror() eval_source = None else: exec exec_code in self.locals if eval_source is not None: result = eval(eval_source, self.locals) sys.displayhook(result) except SystemExit: raise except KeyboardInterrupt: traceback = self.traceback() interrupted = True except: traceback = self.traceback() end = time.clock() try: plots = self.locals['__plots__'] except KeyError: plots = [] self.index += 1 if result is not None: self.locals['_%d' % self.index] = result self.locals['___'] = self.locals.get('__') self.locals['__'] = self.locals.get('_') self.locals['_'] = result result = { 'source': source, 'index': self.index, 'time': end - start, 'out': self.trap.out, 'err': self.trap.err, 'plots': plots, 'traceback': traceback, 'interrupted': interrupted, } if traceback: result['traceback_html'] = self.highlight.traceback(traceback) return result finally: self.trap.reset() def inspect(self, source): """Collect information about a Python object. """ text = source more = False if text.startswith('??'): text = text[2:] more = True if text.endswith('??'): text = text[:-2] more = True if not more: if text.startswith('?'): text = text[1:] if text.endswith('?'): text = text[:-1] text = text.strip() if '.' in text: name, attrs = text.split('.', 1) else: name, attrs = text, None try: obj = self.locals[name] except KeyError: obj = None else: if attrs is not None: for attr in attrs.split('.'): try: obj = getattr(obj, attr) except KeyError: obj = None break if obj is not None: info = self.inspector.get_pretty(obj, self.highlight) else: info = None self.index += 1 return { 'source': source, 'text': text, 'info': info, 'more': more, 'index': self.index, 'interrupted': False, } def is_inspect(self, source): """Return ``True`` if user requested code inspection. """ return source.startswith('?') or source.endswith('?') def split(self, source): """Extract last logical line from multi-line source code. """ string = StringIO(source).readline try: tokens = reversed(list(tokenize.generate_tokens(string))) except (OverflowError, SyntaxError, ValueError): return None, source for tok, _, (n, _), _, _ in tokens: if tok == tokenize.NEWLINE: lines = source.split('\n') exec_source = '\n'.join(lines[:n]) eval_source = '\n'.join(lines[n:]) return exec_source, eval_source else: return None, source def compile(self, source, mode): """Wrapper over Python's built-in :func:`compile` function. """ return compile(source, self.filename, mode) def traceback(self): """Return nicely formatted most recent traceback. """ type, value, tb = sys.exc_info() return ''.join(traceback.format_exception(type, value, tb.tb_next)) def syntaxerror(self): """Return nicely formatted syntax error. """ type, value, sys.last_traceback = sys.exc_info() sys.last_type = type sys.last_value = value if type is SyntaxError: try: msg, (dummy_filename, lineno, offset, line) = value except: pass else: value = SyntaxError(msg, (self.filename, lineno, offset, line)) sys.last_value = value header = "Traceback (most recent call last):\n" return ''.join([header] + traceback.format_exception_only(type, value))
def __init__(self, debug=False): super(PythonInterpreter, self).__init__(debug) self.namespace = PythonNamespace() self.inspector = Inspector()
def createFields(self): from fields import Inspector self.fields = Inspector(self, self.parent, -1, 'Fields' \ , pos=(500,300) \ , size=wx.Size(450,550)) self.fields.Show(True)
st.sidebar.subheader('Clustering') show_clusters = st.sidebar.checkbox('Compute clusters') if show_clusters: step_clustering = st.sidebar.slider('Evaluate clustering at time step:', min_value=5, max_value=149, value=149, step=1, key='cluster_step') # Load data configrun = df_filtered.loc[df_filtered['run_id'] == run_id].iloc[0] df_results = Inspector.results_for_run(configrun) # Perspective Table html_perspective = Inspector.get_persp( data=df_results, display_agent=agent_focus, step=step_focus).set_properties(**{ 'font-size': '9pt', 'font-family': 'Calibri', 'width': '200px' }).render() html_perspective = """ <p style='font-size:9pt;font-family:Calibri;'> <span style="color:Orange">newly added</span> | <span style="color:SlateBlue">marked for removal</span> | <b>written by agent</b> |
remove_slash = args.remove_slash if remove_slash: print("Requests without last /") discriminator = args.discriminator if discriminator: print("Discriminator active") if request_type == "HEAD": print("WARNING: HEAD requests make Content inspection useless") autodiscriminator = args.autodiscriminator autodiscriminator_location = None if autodiscriminator: print("Launching autodiscriminator") i = Inspector(target) r = i.check_this() if r[1] == Inspector.TEST404_URL: autodiscriminator_location = r[0] print("404 ---> 302 ----> " + autodiscriminator_location) print("Banned response codes: %s" % " ".join(banned_response_codes)) if not extension == ['']: print("Extensions to probe: %s" % " ".join(extension)) uppercase = args.uppercase if uppercase: print("All resource requests will be done in uppercase") request_delay = args.request_delay
def loadMasterInspection(self): insp = Inspector() self.XMLInspections = insp.getInspectionsStr(self.masterInspectionPath) if len(self.XMLInspections) == 0: print('Abort. No data found in', self.masterInspectionPath) exit()
def cli(container, no_name, pretty, publish_all, memory_limit): # TODO: -i, -t, -d as added options that override the inspection ins = Inspector(container, no_name, pretty, publish_all, memory_limit) ins.inspect() print(ins.format_cli())
def __init__(self): self.content_id = 0 self.inspector = Inspector(contents[self.content_id], display_size) self.lock = Lock()
def inspect(self, inspector, view): i = Inspector(inspector, view) i.show() i.connect("close", self.handle_close_inspector) return i.webview
def swap(self, content_id): with self.lock: self.inspector = Inspector(contents[content_id], display_size) return 'Switched Content', HTTPStatus.OK