Displays a particular model.
189292
public function actionView()
	{
		$post=$this->loadModel();
		$comment=$this->newComment($post);

		$this->render('view',array(
			'model'=>$post,
			'comment'=>$comment,
		));
	}
128266
def imshow(self, key):
        """"""
        data = self.model.get_data()
        import spyder.pyplot as plt
        plt.figure()
        plt.imshow(data[key])
        plt.show()
404507
public void loadModel() {
        model = newModel();
        model.loadModel(this.modelPath);
        model.printModel();
        fm = FunctionMap.loadFunctionMap();
    }
1275691
def display(self):
        """"""
        lg.debug('GraphicsScene is between {}s and {}s'.format(self.minimum,
                                                               self.maximum))

        x_scale = 1 / self.parent.value('overview_scale')
        lg.debug('Set scene x-scaling to {}'.format(x_scale))

        self.scale(1 / self.transform().m11(), 1)  # reset to 1
        self.scale(x_scale, 1)

        self.scene = QGraphicsScene(self.minimum, 0,
                                    self.maximum,
                                    TOTAL_HEIGHT)
        self.setScene(self.scene)

        # reset annotations
        self.idx_markers = []
        self.idx_annot = []

        self.display_current()

        for name, pos in BARS.items():
            item = QGraphicsRectItem(self.minimum, pos['pos0'],
                                     self.maximum, pos['pos1'])
            item.setToolTip(pos['tip'])
            self.scene.addItem(item)

        self.add_timestamps()
1100428
public function loadModel()
    {
        $this->model = self::newModel();
        $this->model->loadModel($this->modelPath);
        $this->model->printModel();
        $this->fm = Model::LoadFunctionMap();
    }
758364
def show(self, m_a):
        
        bytecode.PrettyShow(m_a, m_a.basic_blocks.gets(), self.notes)
        bytecode.PrettyShowEx(m_a.exceptions.gets())
1276245
def inspect_model(self, model):
        
        # See which interesting fields the model holds.
        url_fields = sorted(f for f in model._meta.fields if isinstance(f, (PluginUrlField, models.URLField)))
        file_fields = sorted(f for f in model._meta.fields if isinstance(f, (PluginImageField, models.FileField)))
        html_fields = sorted(f for f in model._meta.fields if isinstance(f, (models.TextField, PluginHtmlField)))
        all_fields = [f.name for f in (file_fields + html_fields + url_fields)]
        if not all_fields:
            return []

        if model.__name__ in self.exclude:
            self.stderr.write("Skipping {0} ({1})\n".format(model.__name__, ", ".join(all_fields)))
            return []

        sys.stderr.write("Inspecting {0} ({1})\n".format(model.__name__, ", ".join(all_fields)))

        q_notnull = reduce(operator.or_, (Q(**{"{0}__isnull".format(f): False}) for f in all_fields))
        qs = model.objects.filter(q_notnull).order_by('pk')

        urls = []
        for object in qs:
            # HTML fields need proper html5lib parsing
            for field in html_fields:
                value = getattr(object, field.name)
                if value:
                    html_images = self.extract_html_urls(value)
                    urls += html_images

                    for image in html_images:
                        self.show_match(object, image)

            # Picture fields take the URL from the storage class.
            for field in file_fields:
                value = getattr(object, field.name)
                if value:
                    value = unquote_utf8(value.url)
                    urls.append(value)
                    self.show_match(object, value)

            # URL fields can be read directly.
            for field in url_fields:
                value = getattr(object, field.name)
                if value:
                    if isinstance(value, six.text_type):
                        value = force_text(value)
                    else:
                        value = value.to_db_value()  # AnyUrlValue

                    urls.append(value)
                    self.show_match(object, value)
        return urls
1209406
def views(model: "Model") -> list:
    
    if not isinstance(model, Model):
        raise TypeError("Expected a Model, not %r." % model)
    return model._model_views[:]
1007254
def _get_model(vehicle):
    """"""
    model = vehicle['model']
    model = model.replace(vehicle['year'], '')
    model = model.replace(vehicle['make'], '')
    return model.strip().split(' ')[0]
702165
def show(self):
        
        if self.isHidden():
            QWidget.show(self)
            self._qpart.updateViewport()
170436
public function display()
    {
        if (!$this->visible || count($this->view->model) < 2) {
            return;
        }

        parent::display();

        $this->createEmbeddedWidgets();

        $columns = $this->view->getVisibleColumns();

        $tr_tag = new SwatHtmlTag('tr');
        $tr_tag->id = $this->id;
        $tr_tag->class = $this->getCSSClassString();
        $tr_tag->open();

        // find checkbox column position
        $position = 0;
        foreach ($columns as $column) {
            if ($column === $this->column) {
                break;
            } else {
                $position++;
            }
        }

        if ($position > 0) {
            $td_before_tag = new SwatHtmlTag('td');
            $td_before_tag->setContent('&nbsp;', 'text/xml');
            if ($position > 1) {
                $td_before_tag->colspan = $position;
            }

            $td_before_tag->display();
        }

        $td_tag = new SwatHtmlTag('td');
        if (count($columns) - $position > 1) {
            $td_tag->colspan = count($columns) - $position;
        }

        $td_tag->open();
        if ($this->title !== null) {
            $this->check_all->title = $this->title;
            $this->check_all->content_type = $this->content_type;
        }

        $this->check_all->extended_count = $this->extended_count;
        $this->check_all->visible_count = $this->visible_count;
        $this->check_all->unit = $this->unit;
        $this->check_all->tab_index = $this->tab_index;
        $this->check_all->display();

        $td_tag->close();

        $tr_tag->close();
    }
1025341
def show(collector, **kwargs):
    """"""
    configuration = collector.configuration
    flat = configuration.get("harpoon.flat", False)
    only_pushable = configuration.get("harpoon.only_pushable", False)

    for index, layer in enumerate(Builder().layered(configuration["images"], only_pushable=only_pushable)):
        if flat:
            for _, image in layer:
                print(image.image_name)
        else:
            print("Layer {0}".format(index))
            for _, image in layer:
                print("    {0}".format(image.display_line()))
            print("")
649521
def show(self):
        """"""
        if self.brightness > 0.99:
            neopixel_write(self.pin, self.buf)
        else:
            neopixel_write(self.pin, bytearray([int(i * self.brightness) for i in self.buf]))
933651
def _load_model(self):
        
        super()._load_model()
        self.mujoco_robot = Sawyer()
        if self.has_gripper:
            self.gripper = gripper_factory(self.gripper_type)
            if not self.gripper_visualization:
                self.gripper.hide_visualization()
            self.mujoco_robot.add_gripper("right_hand", self.gripper)
295326
def show(self):
        
        self.iren.Initialize()
        self.ren_win.SetSize(800, 800)
        self.ren_win.SetWindowName(self.title)
        self.ren_win.Render()
        self.iren.Start()
833010
def display(self, image):
        
        assert(image.size == self.size)
        self._last_image = image

        self._count += 1
        filename = self._file_template.format(self._count)
        image = self.preprocess(image)
        surface = self.to_surface(image, alpha=self._contrast)
        logger.debug("Writing: {0}".format(filename))
        self._pygame.image.save(surface, filename)
1171934
def _ipython_display_(self):
        """"""
        from IPython.display import display

        self.build_widget()
        display(self.widget())