Returns set of extension support strings referenced in this Registry

        :return: set of extension support strings
347714
def get_supports(self):
        
        out = set()
        for ext in self.extensions.values():
            out.update(ext.get_supports())
        return out
678693
def get_methods(extension_name):
    
    extension = get_extension(extension_name)
    methods = {}
    for name, i in inspect.getmembers(extension):
        if hasattr(i, 'nago_access'):
            api_name = i.nago_name
            methods[api_name] = i
    return methods
862438
public function get_extensions()
    {
        if ($this->exts)
            return $this->exts;

        if (!$this->sieve)
            return $this->_set_error(self::ERROR_INTERNAL);

        $ext = $this->sieve->getExtensions();

        if (is_a($ext, 'PEAR_Error')) {
            return array();
        }

        // we're working on lower-cased names
        $ext = array_map('strtolower', (array) $ext);

        if ($this->script) {
            $supported = $this->script->get_extensions();
            foreach ($ext as $idx => $ext_name)
                if (!in_array($ext_name, $supported))
                    unset($ext[$idx]);
        }

        return array_values($ext);
    }
693965
def resolve_extensions(bot: commands.Bot, name: str) -> list:
    

    if name.endswith('.*'):
        module_parts = name[:-2].split('.')
        path = pathlib.Path(module_parts.pop(0))

        for part in module_parts:
            path = path / part

        return find_extensions_in(path)

    if name == '~':
        return list(bot.extensions.keys())

    return [name]
987127
def _get_registry_names(self, registry):
        
        return ', '.join(
            f.__name__ if not isinstance(f, tuple) else f[0].__name__
            for f in getattr(self, registry, []))
19191
def _archive_extensions():
        
        if six.PY3:
            ext_map = {}
            fmt_map = {}
            for key, exts, desc in shutil.get_unpack_formats():
                fmt_map[key] = exts[0]
                for ext in exts:
                    ext_map[ext] = key
        else:
            ext_map = {'.tar': 'tar',
                       '.tar.bz2': 'bztar',
                       '.tar.gz': 'gztar',
                       '.tar.xz': 'xztar',
                       '.tbz2': 'bztar',
                       '.tgz': 'gztar',
                       '.txz': 'xztar',
                       '.zip': 'zip'}
            fmt_map = {'bztar': '.tar.bz2',
                       'gztar': '.tar.gz',
                       'tar': '.tar',
                       'xztar': '.tar.xz',
                       'zip': '.zip'}
        return ext_map, fmt_map
530540
def base_fields(self):
        ''''''
        if self.extensions_start is None:
            return len(self.fields)
        return len(self.fields[:self.extensions_start])
670245
def get_cleaned_paths(reg_exp)
      paths_without_directories = Dir.glob(reg_exp).reject do |f|
        file_ext = File.extname(f)
        disallowed_extensions = [
          '.xcdatamodeld',
          '.xcassets',
          '.framework',
          '.bundle'
        ]

        File.directory?(f) && !disallowed_extensions.include?(file_ext)
      end
      paths = paths_without_directories.map do |f|
        Pathname.new(f).cleanpath.to_s
      end
      paths
    end
1297145
def regs(self):
        """"""
        regs = set()
        for operand in self.operands:
            if not operand.type.has_reg:
                continue
            regs.update(operand.regs)
        return regs
877198
def to_strings(self):
        
        result = []

        if not self.expansions:
            result.append(self.name)
        else:
            for expansion in self.expansions:
                result.extend('{}.{}'.format(self.name, es) for es in expansion.to_strings())

        return result
10932
def _is_valid_extension(extension):
    
    if not cfg.CONF.valid_extensions:
        return True

    valid = False
    for cext in cfg.CONF.valid_extensions:
        if not cext.startswith('.'):
            cext = '.%s' % cext
        if extension == cext:
            valid = True
            break

    return valid
732419
def installed_extensions(user=None,
                         host=None,
                         port=None,
                         maintenance_db=None,
                         password=None,
                         runas=None):
    '''
    

    '''
    exts = []
    query = (
        'select a.*, b.nspname as schema_name '
        'from pg_extension a,  pg_namespace b where a.extnamespace = b.oid;'
    )
    ret = psql_query(query, user=user, host=host, port=port,
                     maintenance_db=maintenance_db,
                     password=password, runas=runas)
    exts = {}
    for row in ret:
        if 'extversion' in row and 'extname' in row:
            exts[row['extname']] = row
    return exts
1045698
def get_exclude_paths(registry):
    
    # TODO(#63): remove deprecated `skip_validation` setting in v2.0.
    regexes = registry.settings.get(
        'pyramid_swagger.skip_validation',
        registry.settings.get(
            'pyramid_swagger.exclude_paths',
            DEFAULT_EXCLUDED_PATHS
        )
    )

    # being nice to users using strings :p
    if not isinstance(regexes, list) and not isinstance(regexes, tuple):
        regexes = [regexes]

    return [re.compile(r) for r in regexes]
453801
def is_extension_supported(request, extension_alias):
    
    extensions = list_extensions(request)
    for extension in extensions:
        if extension['alias'] == extension_alias:
            return True
    else:
        return False
278254
def _load_extensions(self):
        
        log.debug(u"loading all extensions : %s", self.extensions)

        self.loaded_extensions = []

        for f in self.extensions:
            if not os.path.isabs(f):
                f = os.path.abspath(f)

            if not os.path.exists(f):
                raise CoreError(u"Extension file: {0} not found on disk".format(f))

            self.loaded_extensions.append(imp.load_source("", f))

        log.debug(self.loaded_extensions)
        log.debug([dir(m) for m in self.loaded_extensions])
227075
@Override
    public Set<String> getExtensionClasses() {

        Set<String> serviceClazzes = new HashSet<>();

        if (getType() == ArchiveType.WEB_MODULE) {
            Resource webInfClassesMetaInfServicesEntry = getResource(CDIUtils.WEB_INF_CLASSES_META_INF_SERVICES_CDI_EXTENSION);
            serviceClazzes.addAll(CDIUtils.parseServiceSPIExtensionFile(webInfClassesMetaInfServicesEntry));
        }

        Resource metaInfServicesEntry = getResource(CDIUtils.META_INF_SERVICES_CDI_EXTENSION);
        serviceClazzes.addAll(CDIUtils.parseServiceSPIExtensionFile(metaInfServicesEntry));
        return serviceClazzes;
    }
636786
def getExtensions(self):
        """"""
        extensions = []
        if isinstance(self.supportedExtensions, list):
            for ext in self.supportedExtensions:
                extensionURL = self._url + "/exts/%s" % ext
                if ext == "SchematicsServer":
                    extensions.append(SchematicsService(url=extensionURL,
                                                        securityHandler=self._securityHandler,
                                                        proxy_url=self._proxy_url,
                                                        proxy_port=self._proxy_port))
            return extensions
        else:
            extensionURL = self._url + "/exts/%s" % self.supportedExtensions
            if self.supportedExtensions == "SchematicsServer":
                extensions.append(SchematicsService(url=extensionURL,
                                                    securityHandler=self._securityHandler,
                                                    proxy_url=self._proxy_url,
                                                    proxy_port=self._proxy_port))
            return extensions