Use ConfigObj's get_extra_values() call to find any extra/unknown
        parameters we may have loaded.  Return a string similar to findTheLost.
        If deleteAlso is True, this will also delete any extra/unknown items.
339518
def listTheExtras(self, deleteAlso):
        
        # get list of extras
        extras = configobj.get_extra_values(self)
        # extras is in format: [(sections, key), (sections, key), ]
        # but we need: [(sections, key, result), ...] - set all results to
        # a bool just to make it the right shape.  BUT, since we are in
        # here anyway, make that bool mean something - hide info in it about
        # whether that extra item is a section (1) or just a single par (0)
        #
        # simplified, this is:  expanded = [ (x+(abool,)) for x in extras]
        expanded = [ (x+ \
                       ( bool(len(x[0])<1 and hasattr(self[x[1]], 'keys')), ) \
                     ) for x in extras]
        retval = ''
        if expanded:
            retval = flattened2str(expanded, extra=1)
        # but before we return, delete them (from ourself!) if requested to
        if deleteAlso:
            for tup_to_del in extras:
                target = self
                # descend the tree to the dict where this items is located.
                # (this works because target is not a copy (because the dict
                #  type is mutable))
                location = tup_to_del[0]
                for subdict in location: target = target[subdict]
                # delete it
                target.pop(tup_to_del[1])

        return retval
983534
def get_extra_restriction(self, where_class, alias, remote_alias):
        
        historic_sql = '''{alias}.version_start_date <= %s
                            AND ({alias}.version_end_date > %s
                                OR {alias}.version_end_date is NULL )'''
        current_sql = '''{alias}.version_end_date is NULL'''
        # How 'bout creating an ExtraWhere here, without params
        return where_class([VersionedExtraWhere(historic_sql=historic_sql,
                                                current_sql=current_sql,
                                                alias=alias,
                                                remote_alias=remote_alias)])
575799
public Map<String, Object> getExtra() {
        if (extra == null) {
            // `extra` *should* never be null, but there are scenarios such as
            // when an application is run through ProGuard which may cause deserialization
            // code to be removed (and thus silently not run). In this case, our overridden
            // `readObject` may never be called and `extra` will remain null. :(
            extra = new HashMap<>();
            _logger.warn("`extra` field was null, deserialization must not have been called,"
                    + " please check your ProGuard (or other obfuscation) configuration.");
        }

        return extra;
    }
1122317
public int findParam(String param) {
        param += "=";
        
        for (int i = 0; i < extraInfo.length; i++) {
            if (extraInfo[i].startsWith(param)) {
                return i;
            }
        }
        
        return -1;
    }
420228
def requires(self, extras=()):
        """"""
        dm = self._dep_map
        deps = []
        deps.extend(dm.get(None, ()))
        for ext in extras:
            try:
                deps.extend(dm[safe_extra(ext)])
            except KeyError:
                raise UnknownExtra(
                    "%s has no such extra feature %r" % (self, ext)
                )
        return deps
386968
def extra_hosts(self, value):
        
        if value is None:
            self._extra_hosts = value
        elif isinstance(value, list):
            # TODO: better validation
            self._extra_hosts = value
        elif isinstance(value, dict):
            converted_extra_hosts = []
            for k, v in sorted(six.iteritems(value)):
                if not is_valid_hostname(k):
                    raise ValueError("each key in extra hosts is required to be a valid hostname. {0} was passed".format(k))

                if not is_valid_ip(v):
                    raise ValueError("each value in extra hosts is required to be a valid ip address. {0} was passed".format(v))

                converted_extra_hosts.append('{0}:{1}'.format(k, v))

            self._extra_hosts = converted_extra_hosts
        else:
            raise TypeError("extra hosts must be a dict, list, or None. {0} was passed".format(value))
885135
private Set<String> getNotNullExtraKeys(Node actual, Set<String> extraKeys) {
        Set<String> notNullExtraKeys = new TreeSet<>();
        for (String extraKey : extraKeys) {
            if (!actual.get(extraKey).isNull()) {
                notNullExtraKeys.add(extraKey);
            }
        }
        return notNullExtraKeys;
    }
99178
def get_extra_info(self, name, default=None):
        
        if name == 'related_address':
            return self.__inner_protocol.transport.get_extra_info('sockname')
        elif name == 'sockname':
            return self.__relayed_address
        return default
392141
def remove_plus(orig):
    
    for ext in ["", ".idx", ".gbi", ".tbi", ".bai"]:
        if os.path.exists(orig + ext):
            remove_safe(orig + ext)
789590
def get_extra_functions(self) -> Dict[str, Callable]:
        
        if self.channel_type == ChannelType.Master:
            raise NameError("get_extra_function is not available on master channels.")
        methods = {}
        for mName in dir(self):
            m = getattr(self, mName)
            if callable(m) and getattr(m, "extra_fn", False):
                methods[mName] = m
        return methods
1293948
def contains_extra(marker):
    
    if not marker:
        return False
    marker = _ensure_marker(marker)
    return _markers_contains_extra(marker._markers)
958650
function extraFilters(options) {
        if (!options.staticPages && !options.status) {
            return null;
        }

        let filter = null;

        // CASE: "staticPages" is passed
        if (options.staticPages && options.staticPages !== 'all') {
            // CASE: convert string true/false to boolean
            if (!_.isBoolean(options.staticPages)) {
                options.staticPages = _.includes(['true', '1'], options.staticPages);
            }

            filter = `page:${options.staticPages}`;
        } else if (options.staticPages === 'all') {
            filter = 'page:[true, false]';
        }

        // CASE: "status" is passed, combine filters
        if (options.status && options.status !== 'all') {
            options.status = _.includes(ALL_STATUSES, options.status) ? options.status : 'published';

            if (!filter) {
                filter = `status:${options.status}`;
            } else {
                filter = `${filter}+status:${options.status}`;
            }
        } else if (options.status === 'all') {
            if (!filter) {
                filter = `status:[${ALL_STATUSES}]`;
            } else {
                filter = `${filter}+status:[${ALL_STATUSES}]`;
            }
        }

        delete options.status;
        delete options.staticPages;
        return filter;
    }
109827
def get_extra_data(self, data):
        """"""
        result = {}
        for key in list(data.keys()):
            if key.startswith(self.ctype + '-'):
                new_key = key.replace(self.ctype + '-', '')
                result[new_key] = data[key]
        return result
330342
def get_json_ld_extra(key, value):
    ''''''
    value = value.serialize() if hasattr(value, 'serialize') else value
    return {
        '@type': 'http://schema.org/PropertyValue',
        'name': key,
        'value': value,
    }
711992
def complete_extra(self, args):
        ""
        # treat the last arg as a path and complete it
        if len(args) == 0:
            return self._listdir('./')            
        return self._complete_path(args[-1])
951075
public function getExtraOptions()
    {
        $field = EnumRequestOption::EXTRA_OPTIONS;
        return isset($this->options[$field]) ? $this->options[$field] : [];
    }
366950
def check_extras(dist, attr, value):
    """"""
    try:
        list(itertools.starmap(_check_extra, value.items()))
    except (TypeError, ValueError, AttributeError):
        raise DistutilsSetupError(
            "'extras_require' must be a dictionary whose values are "
            "strings or lists of strings containing valid project/version "
            "requirement specifiers."
        )