Does the current object contain any transparency.

        Returns
        ----------
        transparency: bool, does the current visual contain transparency
186554
def transparency(self):
        
        if 'vertex_colors' in self._data:
            a_min = self._data['vertex_colors'][:, 3].min()
        elif 'face_colors' in self._data:
            a_min = self._data['face_colors'][:, 3].min()
        else:
            return False

        return bool(a_min < 255)
511853
def ensureVisible(self):
        
        # make sure all parents are visible
        if self._parent and self._inheritVisibility:
            self._parent.ensureVisible()
        
        self._visible = True
        self.sync()
1075996
def visible(self):
        
        delete = self._element.delete_
        if delete is None:
            return False
        return False if delete.val else True
809260
def render_transparent_chit():
    

    if request.if_none_match.contains('chit') or request.if_modified_since:
        return 'Not modified', 304

    out_bytes = base64.b64decode(
        "R0lGODlhAQABAIAAAAAAAP///yH5BAEAAAAALAAAAAABAAEAAAIBRAA7")
    return out_bytes, {'Content-Type': 'image/gif', 'ETag': 'chit',
                       'Last-Modified': 'Tue, 31 Jul 1990 08:00:00 -0000'}
1145390
def btnstate(self, item= None):
        
        if not self.canvas.editing():
            return

        item = self.currentItem()
        if not item: # If not selected Item, take the first one
            item = self.labelList.item(self.labelList.count()-1)

        difficult = self.diffcButton.isChecked()

        try:
            shape = self.itemsToShapes[item]
        except:
            pass
        # Checked and Update
        try:
            if difficult != shape.difficult:
                shape.difficult = difficult
                self.setDirty()
            else:  # User probably changed item visibility
                self.canvas.setShapeVisible(shape, item.checkState() == Qt.Checked)
        except:
            pass
885645
private boolean isVisible(RuleInfo rule, ViewPort viewPort) {
		if (rule == null) {
			return true;
		}
		double minResolution = Double.MAX_VALUE;
		double maxResolution = Double.MIN_VALUE;

		if (rule.getMinScaleDenominator() != null && rule.getMinScaleDenominator().getMinScaleDenominator() != 0) {
			maxResolution = viewPort.toResolution(rule.getMinScaleDenominator().getMinScaleDenominator());
		}

		if (rule.getMaxScaleDenominator() != null && rule.getMaxScaleDenominator().getMaxScaleDenominator() != 0) {
			minResolution = viewPort.toResolution(rule.getMaxScaleDenominator().getMaxScaleDenominator());
		}

		return (maxResolution <= viewPort.getResolution() && viewPort.getResolution() < minResolution);
	}
658718
def visible(self):
        
        if not self.in_workspace():
            return False

        if not self.context.join_policy == "self":
            return False

        user = api.user.get_current()
        workspace = IWorkspace(self.context.acquire_workspace())
        if user.getUserName() in workspace.members:
            return False

        return True
586791
def isEmpty(self):
        
        if self.obj is None:
            return True
        if self._clean.isString():
            ret = self.obj.strip() is ""
        elif self._clean.isDict():
            ret = len(self.obj.keys()) == 0
        else:
            ret = len(self.obj) == 0
        return self._wrap(ret)
332670
def set_layer_visible(layer, visible):
        
        if layer is None:
            return

        QgsProject.instance().layerTreeRoot().findLayer(
            layer.id()).setItemVisibilityChecked(visible)
251382
def opacity(self, value):
        

        if value is not None:
            assert type(value) in (int, float), "'{0}' attribute: '{1}' type is not 'int' or 'float'!".format("opacity",
                                                                                                              value)
        if value > 1:
            value = 1
        elif value < 0:
            value = 0

        self.__opacity = float(value)
        self.__set_style_sheet()
426137
def isVisible(self, field, mode="view", default="visible"):
        
        if mode != "edit":
            return default

        # If this is a Secondary Analysis Request, this field is not editable
        if IAnalysisRequestSecondary.providedBy(self.context):
            return "invisible"

        return self.context.isOpen() and "visible" or "invisible"
374243
boolean isVisible() {
        List<? extends Run<?, ?>> builds = currentProject.getBuilds();
        for (Run run : builds) {
            if (run.getAction(PerformanceJobReportAction.class) != null) {
                return true;
            }
        }
        return false;
    }
1059668
function (obj, alpha) {
					obj.css({
						visibility: alpha > 0 ? 'visible' : 'hidden'
					});
					if (alpha > 0 && alpha < 100) {
						obj.css({
							opacity: mPrecision(alpha / 100, 4)
						});
					} else if (alpha == 0 || alpha == 100) {
						obj.css({
								opacity: ''
							});
					}
				}
217638
def _is_visible(cls, property_name):
        
        if isinstance(property_name, list):
            return [cls._is_visible(p) for p in property_name]
        if property_name.startswith('__') and property_name.endswith('__'):
            return False
        return property_name.startswith(cls.STARTS_WITH) and property_name.endswith(cls.ENDS_WITH)
612629
def show(self):
        
        if self._prev_contrast is not None:
            self.contrast(self._prev_contrast)
            self._prev_contrast = None
1122042
def has_face_color(self):
        """"""
        for v in (self._face_colors, self._face_colors_indexed_by_faces,
                  self._face_colors_indexed_by_edges):
            if v is not None:
                return True
        return False
409765
def show(self):
        
        self.visible = True
        if self.proxy_is_active:
            self.proxy.ensure_visible()