Returns if a planet is Void of Course.
        A planet is not VOC if has any exact or applicative aspects
        ignoring the sign status (associate or dissociate).
350976
def isVOC(self, ID):
        
        asps = self.aspectsByCat(ID, const.MAJOR_ASPECTS)
        applications = asps[const.APPLICATIVE]
        exacts = asps[const.EXACT]
        return len(applications) == 0 and len(exacts) == 0
366708
def is_none_or(self):
        
        if self._subject is None:
            return NoOpInspector(subject=self._subject, error_factory=self._error_factory)
        else:
            return self
1024679
def is_not_none(entity, prop, name):
    ""
    return is_not_empty(entity, prop, name) and name in entity._data and getattr(entity, name) is not None
126202
function isTrueEmpty(obj) {
  if (obj === undefined || obj === null || obj === '') return true;
  if (exports.isNumber(obj) && isNaN(obj)) return true;
  return false;
}
479531
private boolean hasFixedPart(final IAtomContainer mol) {
        if (afix.isEmpty()) return false;
        for (IAtom atom : mol.atoms())
            if (afix.contains(atom))
                return true;
        return false;
    }
1311585
def is_set(name):
  """"""
  val = os.environ.get(name, '0')
  assert val == '0' or val == '1', f"env var {name} has value {val}, expected 0 or 1"
  return val == '1'
784357
def _has_not_qual(ntd):
        """'"""
        for qual in ntd.Qualifier:
            if 'not' in qual:
                return True
            if 'NOT' in qual:
                return True
        return False
1029755
def is_absolute(self):
        """"""
        if not self._root:
            return False
        return not self._flavour.has_drv or bool(self._drv)
575346
def is_neg_unate(self, vs=None):
        
        """
        vs = self._expect_vars(vs)
        basis = self.support - set(vs)
        maxcov = [PC_ONE] * (1 << len(basis))
        # Test whether table entries are monotonically decreasing
        for cf in self.iter_cofactors(vs):
            for i, item in enumerate(cf.pcdata):
                if maxcov[i] == PC_ZERO and item == PC_ONE:
                    return False
                maxcov[i] = item
        return True
617061
def has_entities(status):
    
    try:
        if sum(len(v) for v in status.entities.values()) > 0:
            return True

    except AttributeError:
        if sum(len(v) for v in status['entities'].values()) > 0:
            return True

    return False
806322
function isEmptyObject(obj) {
  if (isEmpty(obj) === true) {
    return true;
  }
  if (Object.getOwnPropertyNames(obj).length === 0) {
    //if (Object.keys(obj).length === 0 && Object.getOwnPropertyNames(obj).length === 0) {
    return true;
  }
  return false;
}
378623
public BooleanExpression isEmpty() {
        if (isempty == null) {
            isempty = Expressions.booleanOperation(Ops.STRING_IS_EMPTY, mixin);
        }
        return isempty;
    }
1263619
public static boolean isEmpty(Entity<?> entity, boolean ignoreDefault) {
    try {
      for (final String attr : PropertyUtils.getWritableProperties(entity.getClass())) {
        Object value = PropertyUtils.getProperty(entity, attr);
        if (null == value) continue;
        if (ignoreDefault) {
          if (value instanceof Number) {
            if (((Number) value).intValue() != 0) { return false; }
          } else if (value instanceof String) {
            String str = (String) value;
            if (Strings.isNotEmpty(str)) { return false; }
          } else {
            return false;
          }
        } else {
          return false;
        }
      }
    } catch (Exception e) {
      logger.error("isEmpty error", e);
    }
    return true;
  }
1171572
def is_nonempty(self):
        
        if len(self._subject) == 0:
            raise self._error_factory(_format("Expected {} to be non-empty", self._subject))
        return ChainInspector(self._subject)
578132
def is_empty(self):
        
        for family in self.iter_package_families():
            for pkg in self.iter_packages(family):
                return False

        return True
754395
boolean isEmpty() {
    if (tc.isEntryEnabled())
      tc.entry(this,cclass, "isEmpty");
    boolean ans = super.isEmpty() && !haveEqualityMatches();
    if (tc.isEntryEnabled())
      tc.exit(this,cclass, "isEmpty", new Boolean(ans));
    return ans;        
  }
1328568
public function isExempt()
    {
        $ignoreEnvs = $this->app['config']->get('maintenancemode.exempt-environments', []);

        if(is_array($ignoreEnvs) && in_array($this->app->environment(), $ignoreEnvs))
        {
            return true;
        }

        // We did not have a match
        return false;
    }