<pre>
Configuration for third-party Python runtime libraries that are required
by the application.
Only returned in `GET` requests if `view=FULL` is set.
</pre>

<code>repeated .google.appengine.v1.Library libraries = 102;</code>
330402
public com.google.appengine.v1.LibraryOrBuilder getLibrariesOrBuilder(
      int index) {
    return libraries_.get(index);
  }
937432
public com.google.appengine.v1.ErrorHandlerOrBuilder getErrorHandlersOrBuilder(
      int index) {
    return errorHandlers_.get(index);
  }
772768
public static LibraryLoader loader() {
        String type = System.getProperty("com.lambdaworks.jni.loader");

        if (type != null) {
            if (type.equals("sys")) return new SysLibraryLoader();
            if (type.equals("nil")) return new NilLibraryLoader();
            if (type.equals("jar")) return new JarLibraryLoader();
            throw new IllegalStateException("Illegal value for com.lambdaworks.jni.loader: " + type);
        }

        String vmSpec = System.getProperty("java.vm.specification.name");
        return vmSpec.startsWith("Java") ? new JarLibraryLoader() : new SysLibraryLoader();
    }
896555
public com.google.appengine.v1.ApiConfigHandler getApiConfig() {
    return apiConfig_ == null ? com.google.appengine.v1.ApiConfigHandler.getDefaultInstance() : apiConfig_;
  }
13414
public Path getAppEngineSdkForJavaPath() {
    Path resolved = getPath().resolve(APPENGINE_SDK_FOR_JAVA_PATH);
    if (resolved == null) {
      throw new RuntimeException("Misconfigured App Engine SDK for Java");
    }
    return resolved;
  }
1371836
def appliance_api_version
      options = { 'Content-Type' => :none, 'X-API-Version' => :none, 'auth' => :none }
      response = rest_api(:get, '/rest/version', options)
      version = response_handler(response)['currentVersion']
      raise ConnectionError, "Couldn't get API version" unless version
      version = version.to_i if version.class != Integer
      version
    rescue ConnectionError
      @logger.warn "Failed to get OneView max api version. Using default (#{OneviewSDK::DEFAULT_API_VERSION})"
      OneviewSDK::DEFAULT_API_VERSION
    end
1062425
def config_apis
      source = "#{Dir.pwd}/app/apis/#{@project_name}/#{@scaffold_name}s/base_apis.rb"
      content = ['AppName','ScaffoldName', 'Model', 'model']
      replacement = ["#{@project_class}", "#{model_class}s", "#{model_class}", "#{@scaffold_name}"]
      for i in 0..3 do
        modify_content(source, content[i], replacement[i])
      end
    end
543286
def glymur_config():
    
    handles = (load_openjpeg_library(x) for x in ['openjp2', 'openjpeg'])
    handles = tuple(handles)

    if all(handle is None for handle in handles):
        msg = "Neither the openjp2 nor the openjpeg library could be loaded.  "
        warnings.warn(msg)
    return handles
1147315
function Library(options) {
  options = options || {};

  /**
   * `Client` instance that handles the library's API access.
   *
   * @property client
   * @type Client
   */
  this.client = options.client || new Client();

  /**
   * The library's group id. Note that the `user` property
   * takes precedence over `group`; thus, if changing a user
   * library instance to a group library, the `user` id
   * must be deleted.
   *
   * @property group
   * @type Number
   */
  if (options.group) this.group = options.group;

  /**
   * The library's user id. A library should have either this
   * or a `group` id defined.
   *
   * @property user
   * @type Number
   */
  if (options.user) this.user = options.user;

  /**
   * The API key to use for this library. The key will be
   * added automatically to every request made for this
   * library.
   *
   * @property key
   * @type String
   */
  if (options.key) this.key = options.key;

  /**
   * All options will be sent as parameters with every API call
   * issued by the library.
   *
   * @property options
   * @type Object
   */
  this.options = omit(options, 'client', 'user', 'group', 'key', 'headers');


  Object.defineProperties(this, {

    /**
     * HTTP headers to be included in
     * every request for this library.
     *
     * @property headers
     * @type Object
     */
    headers: {
      enumerable: true,
      value: extend({}, options.headers)
    },

    /**
     * Items proxy. Calls the library's `get` method and injects
     * 'items' into the path argument. The proxy accepts exactly
     * the same arguments as `get`.
     *
     * @example
     *     lib.items();
     *     //-> calls lib.get('items');
     *
     *     lib.items(42);
     *     //-> calls lib.get('items/42');
     *
     *     lib.items.top();
     *     //-> calls lib.get('items/top');
     *
     *     lib.items.top({ format: 'versions' });
     *     //-> calls lib.get('items/top', { format: 'versions' });
     *
     * @method items
     */
    items: {
      value: items(this)
    },

    collections: {
      value: collections(this)
    },

    tags: {
      value: proxy(this, 'get', 'tags', '', true)
    },

    searches: {
      value: proxy(this, 'get', 'searches')
    },

    groups: {
      value: proxy(this, 'get', 'groups')
    },

    keys: {
      value: proxy(this, 'get', 'keys')
    }
  });
}
843459
def interrogate(self, platformIdentifier, configuration, libraries, libOverrides = {}):
		
		
		# Determine which libraries need their modules parsed by UBT, and which are override-only
		libModules = list([lib for lib in libraries if lib not in libOverrides])
		
		# Check that we have at least one module to parse
		details = ThirdPartyLibraryDetails()
		if len(libModules) > 0:
			
			# Retrieve the list of third-party library modules from UnrealBuildTool
			modules = self._getThirdPartyLibs(platformIdentifier, configuration)
			
			# Filter the list of modules to include only those that were requested
			modules = [m for m in modules if m['Name'] in libModules]
			
			# Emit a warning if any of the requested modules are not supported
			names = [m['Name'] for m in modules]
			unsupported = ['"' + m + '"' for m in libModules if m not in names]
			if len(unsupported) > 0:
				Utility.printStderr('Warning: unsupported libraries ' + ','.join(unsupported))
			
			# Some libraries are listed as just the filename without the leading directory (especially prevalent under Windows)
			for module in modules:
				if len(module['PublicAdditionalLibraries']) > 0 and len(module['PublicLibraryPaths']) > 0:
					libPath = (self._absolutePaths(module['PublicLibraryPaths']))[0]
					libs = list([lib.replace('\\', '/') for lib in module['PublicAdditionalLibraries']])
					libs = list([os.path.join(libPath, lib) if '/' not in lib else lib for lib in libs])
					module['PublicAdditionalLibraries'] = libs
			
			# Flatten the lists of paths
			fields = [
				'Directory',
				'PublicAdditionalLibraries',
				'PublicLibraryPaths',
				'PublicSystemIncludePaths',
				'PublicIncludePaths',
				'PrivateIncludePaths',
				'PublicDefinitions'
			]
			flattened = {}
			for field in fields:
				transform = (lambda l: self._absolutePaths(l)) if field != 'Definitions' else None
				flattened[field] = self._flatten(field, modules, transform)
			
			# Compose the prefix directories from the module root directories, the header and library paths, and their direct parent directories
			libraryDirectories = flattened['PublicLibraryPaths']
			headerDirectories  = flattened['PublicSystemIncludePaths'] + flattened['PublicIncludePaths'] + flattened['PrivateIncludePaths']
			modulePaths        = flattened['Directory']
			prefixDirectories  = list(set(flattened['Directory'] + headerDirectories + libraryDirectories + [os.path.dirname(p) for p in headerDirectories + libraryDirectories]))
			
			# Wrap the results in a ThirdPartyLibraryDetails instance, converting any relative directory paths into absolute ones
			details = ThirdPartyLibraryDetails(
				prefixDirs  = prefixDirectories,
				includeDirs = headerDirectories,
				linkDirs    = libraryDirectories,
				definitions = flattened['PublicDefinitions'],
				libs        = flattened['PublicAdditionalLibraries']
			)
		
		# Apply any overrides
		overridesToApply = list([libOverrides[lib] for lib in libraries if lib in libOverrides])
		for override in overridesToApply:
			details.merge(override)
		
		return details
1191149
public static Map<String,String> getSystemConfiguration()
    {
        if(LibraryConfigurationLoader.systemConfiguration==null)
        {
            synchronized(LibraryConfigurationLoader.class)
            {
                if(LibraryConfigurationLoader.systemConfiguration==null)
                {
                    //read properties
                    Properties properties=LibraryConfigurationLoader.readInternalAndExternalConfiguration();

                    //convert to map
                    Map<String,String> map=new HashMap<String,String>(properties.size());
                    SpiUtil.copyPropertiesToMap(properties,map);

                    //normalize map
                    map=new HashMap<String,String>(map);
                    
                    //prevent changes
                    map=Collections.unmodifiableMap(map);

                    //set instance
                    LibraryConfigurationLoader.systemConfiguration=map;
                }
            }
        }
        
        return LibraryConfigurationLoader.systemConfiguration;
    }
1089100
public TemplateAvailabilityProvider getProvider(String view,
			ApplicationContext applicationContext) {
		Assert.notNull(applicationContext, "ApplicationContext must not be null");
		return getProvider(view, applicationContext.getEnvironment(),
				applicationContext.getClassLoader(), applicationContext);
	}
1254402
def get_default_library_patters():
    
    python_version = platform.python_version_tuple()
    python_implementation = platform.python_implementation()
    system = platform.system()
    if python_implementation == "PyPy":
        if python_version[0] == "2":
            return ["*/lib-python/%s.%s/*" % python_version[:2], "*/site-packages/*"]
        else:
            return ["*/lib-python/%s/*" % python_version[0], "*/site-packages/*"]
    else:
        if system == "Windows":
            return [r"*\lib\*"]
        return ["*/lib/python%s.%s/*" % python_version[:2], "*/lib64/python%s.%s/*" % python_version[:2]]
631072
def get_library(self, library):
        
        if library in self._library_cache:
            return self._library_cache[library]

        try:
            error = None
            lib = ArcticLibraryBinding(self, library)
            lib_type = lib.get_library_type()
        except (OperationFailure, AutoReconnect) as e:
            error = e

        if error:
            raise LibraryNotFoundException("Library %s was not correctly initialized in %s.\nReason: %r)" %
                                           (library, self, error))
        elif not lib_type:
            raise LibraryNotFoundException("Library %s was not correctly initialized in %s." %
                                           (library, self))
        elif lib_type not in LIBRARY_TYPES:
            raise LibraryNotFoundException("Couldn't load LibraryType '%s' for '%s' (has the class been registered?)" %
                                           (lib_type, library))
        instance = LIBRARY_TYPES[lib_type](lib)
        self._library_cache[library] = instance
        # The library official name may be different from 'library': e.g. 'library' vs 'user.library'
        self._library_cache[lib.get_name()] = instance
        return self._library_cache[library]
1045017
private static Platform findPlatform() {
    Provider androidOrAppEngineProvider =
        GrpcUtil.IS_RESTRICTED_APPENGINE ? getAppEngineProvider() : getAndroidSecurityProvider();
    if (androidOrAppEngineProvider != null) {
      // Attempt to find Android 2.3+ APIs.
      OptionalMethod<Socket> setUseSessionTickets
          = new OptionalMethod<>(null, "setUseSessionTickets", boolean.class);
      OptionalMethod<Socket> setHostname
          = new OptionalMethod<>(null, "setHostname", String.class);
      Method trafficStatsTagSocket = null;
      Method trafficStatsUntagSocket = null;
      OptionalMethod<Socket> getAlpnSelectedProtocol =
          new OptionalMethod<>(byte[].class, "getAlpnSelectedProtocol");
      OptionalMethod<Socket> setAlpnProtocols =
          new OptionalMethod<>(null, "setAlpnProtocols", byte[].class);

      // Attempt to find Android 4.0+ APIs.
      try {
        Class<?> trafficStats = Class.forName("android.net.TrafficStats");
        trafficStatsTagSocket = trafficStats.getMethod("tagSocket", Socket.class);
        trafficStatsUntagSocket = trafficStats.getMethod("untagSocket", Socket.class);
      } catch (ClassNotFoundException ignored) {
      } catch (NoSuchMethodException ignored) {
      }

      TlsExtensionType tlsExtensionType;
      if (GrpcUtil.IS_RESTRICTED_APPENGINE) {
        tlsExtensionType = TlsExtensionType.ALPN_AND_NPN;
      } else if (androidOrAppEngineProvider.getName().equals("GmsCore_OpenSSL")
          || androidOrAppEngineProvider.getName().equals("Conscrypt")
          || androidOrAppEngineProvider.getName().equals("Ssl_Guard")) {
        tlsExtensionType = TlsExtensionType.ALPN_AND_NPN;
      } else if (isAtLeastAndroid5()) {
        tlsExtensionType = TlsExtensionType.ALPN_AND_NPN;
      } else if (isAtLeastAndroid41()) {
        tlsExtensionType = TlsExtensionType.NPN;
      } else {
        tlsExtensionType = TlsExtensionType.NONE;
      }
      return new Android(
          setUseSessionTickets,
          setHostname,
          trafficStatsTagSocket,
          trafficStatsUntagSocket,
          getAlpnSelectedProtocol,
          setAlpnProtocols,
          androidOrAppEngineProvider,
          tlsExtensionType);
    }
    Provider sslProvider;
    try {
      sslProvider = SSLContext.getDefault().getProvider();
    } catch (NoSuchAlgorithmException nsae) {
      throw new RuntimeException(nsae);
    }

    // Find JDK9+ ALPN support
    try {
      // getApplicationProtocol() may throw UnsupportedOperationException, so first construct a
      // dummy SSLEngine and verify the method does not throw.
      SSLContext context = SSLContext.getInstance("TLS", sslProvider);
      context.init(null, null, null);
      SSLEngine engine = context.createSSLEngine();
      Method getEngineApplicationProtocol =
          AccessController.doPrivileged(
              new PrivilegedExceptionAction<Method>() {
                @Override
                public Method run() throws Exception {
                  return SSLEngine.class.getMethod("getApplicationProtocol");
                }
              });
      getEngineApplicationProtocol.invoke(engine);

      Method setApplicationProtocols =
          AccessController.doPrivileged(
              new PrivilegedExceptionAction<Method>() {
                @Override
                public Method run() throws Exception {
                  return SSLParameters.class.getMethod("setApplicationProtocols", String[].class);
                }
              });
      Method getApplicationProtocol =
          AccessController.doPrivileged(
              new PrivilegedExceptionAction<Method>() {
                @Override
                public Method run() throws Exception {
                  return SSLSocket.class.getMethod("getApplicationProtocol");
                }
              });
      return new JdkAlpnPlatform(sslProvider, setApplicationProtocols, getApplicationProtocol);
    } catch (NoSuchAlgorithmException ignored) {
    } catch (KeyManagementException ignored) {
    } catch (PrivilegedActionException ignored) {
    } catch (IllegalAccessException ignored) {
    } catch (InvocationTargetException ignored) {
    }

    // Find Jetty's ALPN extension for OpenJDK.
    try {
      String negoClassName = "org.eclipse.jetty.alpn.ALPN";
      Class<?> negoClass = Class.forName(negoClassName);
      Class<?> providerClass = Class.forName(negoClassName + "$Provider");
      Class<?> clientProviderClass = Class.forName(negoClassName + "$ClientProvider");
      Class<?> serverProviderClass = Class.forName(negoClassName + "$ServerProvider");
      Method putMethod = negoClass.getMethod("put", SSLSocket.class, providerClass);
      Method getMethod = negoClass.getMethod("get", SSLSocket.class);
      Method removeMethod = negoClass.getMethod("remove", SSLSocket.class);
      return new JdkWithJettyBootPlatform(
          putMethod, getMethod, removeMethod, clientProviderClass, serverProviderClass,
          sslProvider);
    } catch (ClassNotFoundException ignored) {
    } catch (NoSuchMethodException ignored) {
    }

    // TODO(ericgribkoff) Return null here
    return new Platform(sslProvider);
  }
291251
protected org.apache.commons.configuration.Configuration getConfiguration() {
        try {
            return ApplicationProperties.get();
        } catch (AtlasException e) {
            throw new RuntimeException("Unable to load configuration: " + ApplicationProperties.APPLICATION_PROPERTIES);
        }
    }
401487
def get_app_instance(request):
    
    app = None
    if getattr(request, 'current_page', None) and request.current_page.application_urls:
        app = apphook_pool.get_apphook(request.current_page.application_urls)
    if app and app.app_config:
        try:
            config = None
            with override(get_language_from_request(request, check_path=True)):
                namespace = resolve(request.path_info).namespace
                config = app.get_config(namespace)
            return namespace, config
        except Resolver404:
            pass
    return '', None