Esempio n. 1
0
 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")
Esempio n. 3
0
 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)
     )
Esempio n. 4
0
 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
Esempio n. 5
0
def dispatch_database_inspector(args):
    """
    Dispatch the database inspection tool
    :param args: Arguments passed to the script
    :return: None
    """
    inspector = Inspector(args)
    inspector.run()
Esempio n. 6
0
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()
Esempio n. 7
0
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()
Esempio n. 8
0
 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)
Esempio n. 9
0
    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
Esempio n. 10
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 = []
Esempio n. 11
0
    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)
Esempio n. 12
0
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
Esempio n. 14
0
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
Esempio n. 15
0
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')
Esempio n. 16
0
 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()
Esempio n. 17
0
    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
Esempio n. 18
0
 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)
Esempio n. 19
0
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
Esempio n. 20
0
	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)
Esempio n. 21
0
 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())
Esempio n. 22
0
    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())
Esempio n. 23
0
    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)
Esempio n. 24
0
    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)
Esempio n. 25
0
    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()
Esempio n. 26
0
 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)
Esempio n. 27
0
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
Esempio n. 28
0
 def __init__(self, klasses, klass, module):
     super(DetailPageRenderer, self).__init__(klasses)
     self.klass = klass
     self.module = module
     self.inspector = Inspector(self.klass, self.module)
Esempio n. 29
0
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)
Esempio n. 30
0
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
Esempio n. 31
0
 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)
Esempio n. 32
0
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)
Esempio n. 34
0
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())
Esempio n. 35
0
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()
Esempio n. 37
0
 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)
Esempio n. 38
0
 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)
Esempio n. 39
0
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> | 
Esempio n. 40
0
 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)
Esempio n. 41
0
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
Esempio n. 42
0
 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)
Esempio n. 43
0
	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()
Esempio n. 44
0
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())
Esempio n. 45
0
 def __init__(self):
     self.content_id = 0
     self.inspector = Inspector(contents[self.content_id], display_size)
     self.lock = Lock()
Esempio n. 46
0
 def inspect(self, inspector, view):
     i = Inspector(inspector, view)
     i.show()
     i.connect("close", self.handle_close_inspector)
     return i.webview
Esempio n. 47
0
 def swap(self, content_id):
     with self.lock:
         self.inspector = Inspector(contents[content_id], display_size)
     return 'Switched Content', HTTPStatus.OK