Return supported schemes.
967561
def schemes(self):
        """"""
        if not self._schemes:
            _schemes = []
            if self.types.keys() & _HTTP_PROTOS:
                _schemes.append('HTTP')
            if self.types.keys() & _HTTPS_PROTOS:
                _schemes.append('HTTPS')
            self._schemes = tuple(_schemes)
        return self._schemes
929960
public static IAtomContainerSet getAllAtomContainers(IReactionScheme scheme) {
        return getAllAtomContainers(scheme, scheme.getBuilder().newInstance(IAtomContainerSet.class));
    }
92477
def refs(self):
        """"""

        def set_bundle(s):
            s._bundle = self
            return s

        return list(set_bundle(s) for s in self.dataset.sources if not s.is_downloadable)
269718
def get_extensions(self, support=None):
        
        return [x for x in self.extensions.values() if support
                and support in x.supported or not support]
410666
def get_by_scheme(path, lookup, default):
    
    parsed = urlparse(path)
    class_name = lookup.get(parsed.scheme, default)
    if class_name is None:
        raise NotImplementedError("No implementation for scheme " + parsed.scheme)
    return class_name
1183062
private String checkScheme(String scheme) {
        // NOTE: OkHttp can not understand blip/blips
        if (scheme.equalsIgnoreCase(C4Replicator.C4_REPLICATOR_SCHEME_2)) { return WEBSOCKET_SCHEME; }

        if (scheme.equalsIgnoreCase(C4Replicator.C4_REPLICATOR_TLS_SCHEME_2)) {
            return WEBSOCKET_SECURE_CONNECTION_SCHEME;
        }

        return scheme;
    }
743367
def get_scheme_cartocss(column, scheme_info):
    """"""
    if 'colors' in scheme_info:
        color_scheme = '({})'.format(','.join(scheme_info['colors']))
    else:
        color_scheme = 'cartocolor({})'.format(scheme_info['name'])
    if not isinstance(scheme_info['bins'], int):
        bins = ','.join(str(i) for i in scheme_info['bins'])
    else:
        bins = scheme_info['bins']
    bin_method = scheme_info['bin_method']
    comparison = ', {}'.format(BinMethod.mapping.get(bin_method, '>='))
    return ('ramp([{column}], {color_scheme}, '
            '{bin_method}({bins}){comparison})').format(
                column=column,
                color_scheme=color_scheme,
                bin_method=bin_method,
                bins=bins,
                comparison=comparison)
1024148
def _get_url_scheme_regexes():
        
        output = sh("hg showconfig | grep '^schemes.'", shell=True).split('\n')
        log.debug(output)
        schemes = (
            l.split('.', 1)[1].split('=') for l in output if '=' in l)
        regexes = sorted(
            ((k, v, re.compile(v.replace('{1}', '(.*)')+'(.*)'))
                for k, v in schemes),
            key=lambda x: (len(x[0]), x),
            reverse=True)
        return regexes
435328
def getSupportedProtocols(self):
        """"""
        protocols = {}
        for td in self.TD:
            if td is not None:
                strprotocol = "T=%d" % (td & 0x0F)
                protocols[strprotocol] = True
        if not self.hasTD[0]:
            protocols['T=0'] = True
        return protocols
274966
def get_supported_types(resource_root, category_name):
  
  return call(resource_root.get,
      EXTERNAL_ACCOUNT_FETCH_PATH % ("supportedTypes", category_name,),
      ApiExternalAccountType, True)
643979
def _get_valid_with_defaults_modes(capabilities):
    """"""
    capability = capabilities[":with-defaults"]

    try:
        valid_modes = [capability.parameters["basic-mode"]]
    except KeyError:
        raise WithDefaultsError(
            "Invalid 'with-defaults' capability URI advertised by the server; "
            "missing 'basic-mode' parameter"
        )

    try:
        also_supported = capability.parameters["also-supported"]
    except KeyError:
        return valid_modes

    valid_modes.extend(also_supported.split(","))

    return valid_modes
1261536
def needs(self):
        """"""
        result = []
        for dep in self.dependencies:
            module = dep.split(".")[0].lower()
            if module not in result:
                result.append(module)

        return result
1024850
def supported_operations(self):
        
        return tuple(op for op in backend.FILE_OPS if self._operations & op)
902469
public Set<String> getSupportedUriSchemes() {
        Set<String> schemes = new HashSet<>();

        for (ConfigFileLoaderPlugin loaderPlugin: this.getLoaderPlugins()) {
            schemes.add(loaderPlugin.getUriScheme());
        }

        return schemes;
    }
752011
def get_all_supported_types_for_ext(self, ext_to_match: str, strict_type_matching: bool = False) -> Set[Type]:
        
        matching = self.find_all_matching_parsers(required_ext=ext_to_match, strict=strict_type_matching)[0]
        return {typ for types in [p.supported_types for p in (matching[0] + matching[1] + matching[2])]
                for typ in types}
29025
def override_supported_formats(formats):
    
    def decorator(function):
        @wraps(function)
        def wrapper(self, *args, **kwargs):
            self.supported_formats = formats
            return function(self, *args, **kwargs)
        return wrapper
    return decorator
992661
def _get_supported_for_any_abi(version=None, platform=None, impl=None, force_manylinux=False):
  """"""
  unique_tags = {
    tag for abi in _gen_all_abis(impl, version)
    for tag in _get_supported(version=version,
                              platform=platform,
                              impl=impl,
                              abi=abi,
                              force_manylinux=force_manylinux)
  }
  return list(unique_tags)