Is self a superdomain of other?

        The notion of subdomain includes equality.
        @rtype: bool
2295
def is_superdomain(self, other):
        

        (nr, o, nl) = self.fullcompare(other)
        if nr == NAMERELN_SUPERDOMAIN or nr == NAMERELN_EQUAL:
            return True
        return False
1025455
def is_ens_domain(authority: str) -> bool:
    
    # check that authority ends with the tld '.eth'
    # check that there are either 2 or 3 subdomains in the authority
    # i.e. zeppelinos.eth or packages.zeppelinos.eth
    if authority[-4:] != ".eth" or len(authority.split(".")) not in [2, 3]:
        return False
    return True
1216806
def contains(self, other):
        
        return (self.left <= other.left and
                self.right >= other.right and
                self.top >= other.top and
                self.bottom <= other.bottom)
284596
def =~(other)
      other = coerce( other )
      return (other and 
              self.name == other.name and
              self.version.to_s == other.version.to_s and
              self.platform_string == other.platform_string )
    end
187702
def same_domain(self, other):
        
        return self.domain == other.domain or \
                len(self.domain.symmetric_difference(set(other.domain))) == 0
97680
def is_subdomains_enabled(blockstack_opts):
    
    if not is_atlas_enabled(blockstack_opts):
        log.debug("Subdomains are disabled")
        return False

    if 'subdomaindb_path' not in blockstack_opts:
        log.debug("Subdomains are disabled: no 'subdomaindb_path' path set")
        return False

    return True
1189481
def _issubclass(sub, sup):
    '''
    '''
    if sup is not object:
        try:
            return issubclass(sub, sup)
        except TypeError:
            pass
    return False
348433
def _is_sub_intrinsic(data):
        
        return isinstance(data, dict) and len(data) == 1 and LambdaUri._FN_SUB in data
461300
def entails(self, other):
        
        other = BoolCell.coerce(other)
        return other.is_entailed_by(self)
843488
def coerce(self, other, is_positive=True):
        
        if hasattr(other, 'get_domain') and hasattr(other, 'lower') and hasattr(other, 'upper'):
            if self.is_domain_equal(other):
                return other
            else:
                msg = "Cannot merge partial orders with different domains!"
                raise CellConstructionFailure(msg)
        if isinstance(other, LinearOrderedCell):
            # convert other's domain to a chain/dag
            # first ensure domain has same size and elements
            raise NotImplemented("Please Implement me!")
        domain = self.get_domain()
        if other in domain:
            c = self.__class__()
            if not is_positive:
                # add value to lower (negative example)
                c.lower = set([other])
                c.upper = set()
            else:
                # add value to upper (positive example)
                c.upper = set([other])
                c.lower = set()
            return c
        else:       
            raise CellConstructionFailure("Could not coerce value that is"+
                    " outside order's domain . (Other = %s) " % (str(other),))
20648
def equals(self, other):
        
        if self.is_(other):
            return True

        if not isinstance(other, Index):
            return False

        if not isinstance(other, MultiIndex):
            other_vals = com.values_from_object(ensure_index(other))
            return array_equivalent(self._ndarray_values, other_vals)

        if self.nlevels != other.nlevels:
            return False

        if len(self) != len(other):
            return False

        for i in range(self.nlevels):
            self_codes = self.codes[i]
            self_codes = self_codes[self_codes != -1]
            self_values = algos.take_nd(np.asarray(self.levels[i]._values),
                                        self_codes, allow_fill=False)

            other_codes = other.codes[i]
            other_codes = other_codes[other_codes != -1]
            other_values = algos.take_nd(
                np.asarray(other.levels[i]._values),
                other_codes, allow_fill=False)

            # since we use NaT both datetime64 and timedelta64
            # we can have a situation where a level is typed say
            # timedelta64 in self (IOW it has other values than NaT)
            # but types datetime64 in other (where its all NaT)
            # but these are equivalent
            if len(self_values) == 0 and len(other_values) == 0:
                continue

            if not array_equivalent(self_values, other_values):
                return False

        return True
549340
def is_domain_equal(self, other):
        
        domain = self.get_domain()
        other_domain = other.get_domain()
        # if they share the same instance of memory for the domain
        if domain == other_domain:
            return True
        else:
            return False
958363
def subdomain?(*jids)
      !jids.flatten.index do |jid|
        !component?(jid) && !pubsub?(jid)
      end
    end
1357366
private boolean bfsComparison(Node root, Node other) {
        if(root instanceof Content || other instanceof Content) {
            return root.equals(other);
        }
        if(! root.equals(other)) {
            return false;
        }

        List<Node> a = ((Element)root).getChildElements();
        List<Node> b = ((Element)other).getChildElements();
        if(a.size() != b.size()) {
            return false;
        }
        for(int i=0; i<a.size(); i++) {
            if(! a.get(i).equals(b.get(i))) {
                return false;
            }
        }

        for(int i=0; i<a.size(); i++) {
            if(! bfsComparison(a.get(i), b.get(i))) {
                return false;
            }
        }

        return true;
    }
956479
def equality(self, other):
        
        # Compare specified attributes for equality
        cname = self.__class__.__name__
        for aname in self.attributes:
            try:
                attr1 = getattr(self, aname)
                attr2 = getattr(other, aname)
            except AttributeError as error:
                logging.debug("%s.%s: %s", cname, aname, error)
                return False
            self.log(attr1, attr2, '==', cname=cname, aname=aname)
            eql = (attr1 == attr2)
            self.log(attr1, attr2, '==', cname=cname, aname=aname, result=eql)
            if not eql:
                return False

        return True
1208003
private boolean isWithinSubtree(X500Name other) {
        if (this == other) {
            return true;
        }
        if (other == null) {
            return false;
        }
        if (other.names.length == 0) {
            return true;
        }
        if (this.names.length == 0) {
            return false;
        }
        if (names.length < other.names.length) {
            return false;
        }
        for (int i = 0; i < other.names.length; i++) {
            if (!names[i].equals(other.names[i])) {
                return false;
            }
        }
        return true;
    }
1273141
def subdomains(self, value=None):
        
        if value is not None:
            return URL._mutate(self, host='.'.join(value))
        return self.host().split('.')