Checks the the istransiting tag to see if the planet transits. Note that this only works as of catalogue
        version  ee12343381ae4106fd2db908e25ffc537a2ee98c (11th March 2014) where the istransiting tag was implemented
349941
def isTransiting(self):
        
        try:
            isTransiting = self.params['istransiting']
        except KeyError:
            return False

        if isTransiting == '1':
            return True
        else:
            return False
1154231
def is_correct(self):
        
        state = True

        # Ok just put None as modulation_period, means 24x7
        if not hasattr(self, 'modulation_period'):
            self.modulation_period = None

        if not hasattr(self, 'customs') or not self.customs:
            msg = "[macromodulation::%s] contains no macro definition" % (self.get_name())
            self.add_error(msg)
            state = False

        return super(MacroModulation, self).is_correct() and state
647401
private boolean checkRequiredTag(IfdTags metadata, String tagName, int cardinality) {
    return checkRequiredTag(metadata, tagName, cardinality, null);
  }
768458
def check_lato_blog_tag_parent
      tag_parent = LatoBlog::TagParent.find_by(id: lato_blog_tag_parent_id)
      if !tag_parent
        errors.add('Tag parent', 'not exist for the tag')
        throw :abort
        return
      end

      same_language_tag = tag_parent.tags.find_by(meta_language: meta_language)
      if same_language_tag && same_language_tag.id != id
        errors.add('Tag parent', 'has another tag for the same language')
        throw :abort
        return
      end
    end
602800
def read_gps_ifd(fh, byteorder, dtype, count, offsetsize):
    """"""
    return read_tags(fh, byteorder, offsetsize, TIFF.GPS_TAGS, maxifds=1)
985439
protected boolean involvedInTransaction() {

        final boolean isTracingEnabled = TraceComponent.isAnyTracingEnabled();

        if (state == STATE_TRAN_WRAPPER_INUSE) {

            if (isTracingEnabled && tc.isDebugEnabled()) {
                Tr.debug(this, tc, "involvedInTransaction: true");
            }

            return true;
        } else {

            if (isTracingEnabled && tc.isDebugEnabled()) {
                Tr.debug(this, tc, "involvedInTransaction: false");
            }

            return false;
        }

    }
159667
def check_existens_of_staging_tag_in_remote_repo():
        
        staging_tag = Git.create_git_version_tag(APISettings.GIT_STAGING_PRE_TAG)

        command_git = 'git ls-remote -t'
        command_awk = 'awk \'{print $2}\''
        command_cut_1 = 'cut -d \'/\' -f 3'
        command_cut_2 = 'cut -d \'^\' -f 1'
        command_sort = 'sort -b -t . -k 1,1nr -k 2,2nr -k 3,3r -k 4,4r -k 5,5r'
        command_uniq = 'uniq'

        command = command_git + ' | ' + command_awk + ' | ' + command_cut_1 + ' | ' + \
                  command_cut_2 + ' | ' + command_sort + ' | ' + command_uniq

        list_of_tags = str(check_output(command, shell=True))

        if staging_tag in list_of_tags:
            return True
        return False
319784
func (t *Tab) IsTransitioning() bool {
	if flag, ok := t.isTransitioningFlag.Load().(bool); ok {
		return flag
	}
	return false
}
638890
public boolean isPureTranslation() {
		if (isPureCrystalTranslation()) return true;
		if (SpaceGroup.deltaComp(matTransform.m00,1,SpaceGroup.DELTA) &&
			SpaceGroup.deltaComp(matTransform.m01,0,SpaceGroup.DELTA) &&
			SpaceGroup.deltaComp(matTransform.m02,0,SpaceGroup.DELTA) &&

			SpaceGroup.deltaComp(matTransform.m10,0,SpaceGroup.DELTA) &&
			SpaceGroup.deltaComp(matTransform.m11,1,SpaceGroup.DELTA) &&
			SpaceGroup.deltaComp(matTransform.m12,0,SpaceGroup.DELTA) &&

			SpaceGroup.deltaComp(matTransform.m20,0,SpaceGroup.DELTA) &&
			SpaceGroup.deltaComp(matTransform.m21,0,SpaceGroup.DELTA) &&
			SpaceGroup.deltaComp(matTransform.m22,1,SpaceGroup.DELTA) &&
			(	Math.abs(matTransform.m03-0.0)>SpaceGroup.DELTA ||
				Math.abs(matTransform.m13-0.0)>SpaceGroup.DELTA ||
				Math.abs(matTransform.m23-0.0)>SpaceGroup.DELTA)) {
			return true;
		}

		return false;
	}
978793
def is_correct(self):
        
        valid = True
        # We do not want a same hg to be explode again and again
        # so we tag it
        for timeperiod in list(self.items.values()):
            timeperiod.rec_tag = False

        for timeperiod in list(self.items.values()):
            for tmp_tp in list(self.items.values()):
                tmp_tp.rec_tag = False
            valid = timeperiod.check_exclude_rec() and valid

        # We clean the tags and collect the warning/erro messages
        for timeperiod in list(self.items.values()):
            del timeperiod.rec_tag

            # Now other checks
            if not timeperiod.is_correct():
                valid = False
                source = getattr(timeperiod, 'imported_from', "unknown source")
                msg = "Configuration in %s::%s is incorrect; from: %s" % (
                    timeperiod.my_type, timeperiod.get_name(), source
                )
                self.add_error(msg)

            self.configuration_errors += timeperiod.configuration_errors
            self.configuration_warnings += timeperiod.configuration_warnings

        # And check all timeperiods for correct (sunday is false)
        for timeperiod in self:
            valid = timeperiod.is_correct() and valid

        return valid
1290910
@Override
    public boolean isTransacted()
    {
        if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
        {
            SibTr.entry(this, tc, "isTransacted");
            SibTr.exit(this, tc, "isTransacted", Boolean.valueOf(transacted));
        }
        return transacted;
    }
476776
def check(self):
        

        status = True
        synced = True

        xbin = self.xbin.value()
        ybin = self.ybin.value()
        nwin = self.nwin.value()

        # individual window checks
        g = get_root(self).globals
        for xsw, ysw, nxw, nyw in \
                zip(self.xs[:nwin], self.ys[:nwin],
                    self.nx[:nwin], self.ny[:nwin]):

            xsw.config(bg=g.COL['main'])
            ysw.config(bg=g.COL['main'])
            nxw.config(bg=g.COL['main'])
            nyw.config(bg=g.COL['main'])
            status = status if xsw.ok() else False
            status = status if ysw.ok() else False
            status = status if nxw.ok() else False
            status = status if nyw.ok() else False
            xs = xsw.value()
            ys = ysw.value()
            nx = nxw.value()
            ny = nyw.value()

            # Are unbinned dimensions consistent with binning factors?
            if nx is None or nx % xbin != 0:
                nxw.config(bg=g.COL['error'])
                status = False
            elif (nx // xbin) % 4 != 0:
                """
                The NGC collects pixel data in chunks before transmission.
                As a result, to avoid loss of data from frames, the binned
                x-size must be a multiple of 4.
                """
                nxw.config(bg=g.COL['error'])
                status = False

            if ny is None or ny % ybin != 0:
                nyw.config(bg=g.COL['error'])
                status = False

            # Are the windows synchronised? This means that they
            # would be consistent with the pixels generated were
            # the whole CCD to be binned by the same factors
            # If relevant values are not set, we count that as
            # "synced" because the purpose of this is to enable
            # / disable the sync button and we don't want it to be
            # enabled just because xs or ys are not set.
            if (xs is not None and ys is not None and nx is not None and
                ny is not None):
                    if (xs < 1025 and ((xs - 1) % xbin != 0 or (ys - 1) % ybin != 0)
                        or ((xs-1025) % xbin != 0 or (ys - 1) % ybin != 0)):
                        synced = False

            # Range checks
            if xs is None or nx is None or xs + nx - 1 > xsw.imax:
                xsw.config(bg=g.COL['error'])
                status = False

            if ys is None or ny is None or ys + ny - 1 > ysw.imax:
                ysw.config(bg=g.COL['error'])
                status = False

        # Overlap checks. Compare each window with the next one, requiring
        # no y overlap and that the second is higher than the first
        if status:
            n1 = 0
            for ysw1, nyw1 in zip(self.ys[:nwin-1], self.ny[:nwin-1]):

                ys1 = ysw1.value()
                ny1 = nyw1.value()

                n1 += 1
                ysw2 = self.ys[n1]

                ys2 = ysw2.value()

                if ys2 < ys1 + ny1:
                    ysw2.config(bg=g.COL['error'])
                    status = False

        if synced:
            self.sbutt.config(bg=g.COL['main'])
            self.sbutt.disable()
        else:
            if not self.frozen:
                self.sbutt.enable()
            self.sbutt.config(bg=g.COL['warn'])

        return status
1166654
def check(self, version):
        

        for disjunct in self._disjuncts:
            if self._check_insersection(version, disjunct):
                return True

        return False
888118
def check_heading(self, m):
        ''''''
        if 'GPS_RAW_INT' in self.status.msgs:
            gps = self.status.msgs['GPS_RAW_INT']
            if gps.vel < 300:
                return
            diff = math.fabs(angle_diff(m.heading, gps.cog / 100.0))
        else:
            return
        self.report('heading', diff < 20, 'heading error %u' % diff)
679284
private boolean hasAnyTypeRelatedTags() {
    return currentInfo.isConstructor()
        || currentInfo.isInterface()
        || currentInfo.isAbstract()
        || currentInfo.getParameterCount() > 0
        || currentInfo.hasReturnType()
        || currentInfo.hasBaseType()
        || currentInfo.getExtendedInterfacesCount() > 0
        || currentInfo.hasLendsName()
        || currentInfo.hasThisType()
        || hasAnySingletonTypeTags();
  }
626159
def tag_has_inline_script?(tag_node)
      tag_with_inline_content = tag_with_inline_text(tag_node)
      return false unless inline_content = inline_node_content(tag_node)
      return false unless index = tag_with_inline_content.rindex(inline_content)

      index -= 1
      index -= 1 while [' ', '"', "'"].include?(tag_with_inline_content[index])

      tag_with_inline_content[index] == '='
    end
1176905
def is_after(self, ts):
        '''  '''
        if self.timestamp >= int(calendar.timegm(ts.timetuple())):
            return True
        return False