An analog to loader.get covering execution of all three layers (real declarative, simulated declarative, simulated dynamic)
488775
function getModule(name, loader) {
    var exports;
    var entry = loader.defined[name];

    if (!entry) {
      exports = loader.get(name);
      if (!exports)
        throw new Error('Unable to load dependency ' + name + '.');
    }

    else {
      if (entry.declarative)
        ensureEvaluated(name, entry, [], loader);
    
      else if (!entry.evaluated)
        linkDynamicModule(entry, loader);

      exports = entry.module.exports;
    }

    if ((!entry || entry.declarative) && exports && exports.__useDefault)
      return exports['default'];
    
    return exports;
  }
546735
def loader(pattern, dimensions=None, distributed_dim='time', read_only=False):
    
    if dimensions:
        root = tailor(pattern, dimensions, distributed_dim, read_only=read_only)
    else:
        root, _ = open(pattern, read_only=read_only)
    yield root
    root.close()
85051
def get(cls):
    """"""
    return {
      SourceRootConfig,
      Reporting,
      Reproducer,
      RunTracker,
      Changed,
      BinaryUtil.Factory,
      Subprocess.Factory
    }
151965
def load(cls, filename, dir=None, main=False, **kwargs):
        
        name = main and "__main__" or Path(filename).stem
        loader = cls(name, str(filename), **kwargs)
        module = module_from_spec(FileModuleSpec(name, loader, origin=loader.path))
        cwd = str(Path(loader.path).parent)
        try:
            with ExitStack() as stack:
                sys.path.append(cwd)
                loader.name != "__main__" and stack.enter_context(_installed_safely(module))
                loader.exec_module(module)
        finally:
            sys.path.pop()

        return module
668012
def _tf_load_model(sess, model_dir):
  """"""

  meta_graph_pb = tf.saved_model.loader.load(
      sess=sess,
      tags=[tf.saved_model.tag_constants.SERVING],
      export_dir=model_dir)

  signature = meta_graph_pb.signature_def[signature_constants.DEFAULT_SERVING_SIGNATURE_DEF_KEY]
  input_alias_map = {friendly_name: tensor_info_proto.name
                     for (friendly_name, tensor_info_proto) in signature.inputs.items()}
  output_alias_map = {friendly_name: tensor_info_proto.name
                      for (friendly_name, tensor_info_proto) in signature.outputs.items()}

  return input_alias_map, output_alias_map
1330983
def on_train_end(self, **kwargs):
        ""

        if self.save_model:
            # Adapted from fast.ai "SaveModelCallback"
            if self.model_path.is_file():
                with self.model_path.open('rb') as model_file:
                    self.learn.load(model_file, purge=False)
                    print(f'Loaded best saved model from {self.model_path}')
177721
function generateLoaders(loader, loaderOptions) {
    const loaders = [ cssLoader ];
    if (loader) {
      loaders.push({
        loader: loader + '-loader',
        options: Object.assign({}, loaderOptions, {
          sourceMap: options.sourceMap,
        }),
      });
    }

    // Extract CSS when that option is specified
    // (which is the case during production build)
    if (options.extract) {
      return [ MiniCssExtractPlugin.loader ].concat(loaders);
    }
    return [ 'vue-style-loader' ].concat(loaders);
  }
280842
function( loadClass, loadSpecs, name, callback ) {

		// Trigger bundle loader and return TRUE if this
		// was handled by this loader.
		return BundleLoader.load( loadClass, loadSpecs, function( data, extra ) {

			// Prepare response array
			var objects = {};
			objects[name] = data;
			if (extra) objects[name+':extra'] = extra;

			// Notify that we are compiled
			callback( null, objects );

		});


	}
275209
def load_imports
      while fn = @pending_imports.shift
        next if @imported.member?(fn)
        if fn_task = lookup(fn)
          fn_task.invoke
        end
        ext = File.extname(fn)
        loader = @loaders[ext] || @default_loader
        loader.load(fn)
        @imported << fn
      end
    end
22747
function(all) {
      var tasks = all? ['load-api']:['pack-prepare','load-api'];
      ss.bundler.forEach(function(bundler){
        if (all) {
          tasks.push(bundler.client.name + ':pack');
        } else if (bundler.packNeeded) {
          tasks.push(bundler.client.name + ':pack-needed');
          tasks.push(bundler.client.name + ':pack');
        } else {
          tasks.push(bundler.client.name + ':pack-unneeded');
        }
      });
      return tasks;
    }
390950
function Repository(loader, environment) {

    /**
     * The loader implementation.
     *
     * @var {FileLoader}
     * @protected
     */
    this.__loader = loader;

    /**
     * The current environment.
     *
     * @var {string}
     * @protected
     */
    this.__environment = environment;

    /**
     * All of the configuration items.
     *
     * @var {Array}
     * @protected
     */
    this.__items = [];

    /**
     * The after load callbacks for namespaces.
     *
     * @var {Array}
     * @protected
     */
    this.__afterLoad = [];

    // call super class constructor
    Repository.super_.call(this);

}
1366160
def _get_schema_loader(self, strict=False):
        
        return functools.partial(schema.load_schema, version=self.version,
                                 strict=strict)
619586
def default_loader(obj, defaults=None):
    """"""
    defaults = defaults or {}
    default_settings_values = {
        key: value
        for key, value in default_settings.__dict__.items()  # noqa
        if key.isupper()
    }

    all_keys = deduplicate(
        list(defaults.keys()) + list(default_settings_values.keys())
    )

    for key in all_keys:
        if not obj.exists(key):
            value = defaults.get(key, default_settings_values.get(key))
            obj.logger.debug("loading: %s:%s", key, value)
            obj.set(key, value)

    # start dotenv to get default env vars from there
    # check overrides in env vars
    default_settings.start_dotenv(obj)

    # Deal with cases where a custom ENV_SWITCHER_IS_PROVIDED
    # Example: Flask and Django Extensions
    env_switcher = defaults.get(
        "ENV_SWITCHER_FOR_DYNACONF", "ENV_FOR_DYNACONF"
    )

    for key in all_keys:
        if key not in default_settings_values.keys():
            continue

        env_value = obj.get_environ(
            env_switcher if key == "ENV_FOR_DYNACONF" else key,
            default="_not_found",
        )

        if env_value != "_not_found":
            obj.logger.debug("overriding from envvar: %s:%s", key, env_value)
            obj.set(key, env_value, tomlfy=True)
202792
def loadstring_and_call(s, bndng, filename, lineno)

      bottom = stack_top
      chunk = filename ? "#{filename}:#{lineno}" : 'line'

      err = Lib.luaL_loadbuffer(@pointer, s, s.bytesize, chunk)
      fail_if_error('eval:compile', err, bndng, filename, lineno)

      pcall(bottom, 0, bndng, filename, lineno) # arg_count is set to 0
    end
146676
def post_loader(*decorator_args, serializer):
    
    def wrapped(fn):
        @wraps(fn)
        def decorated(*args, **kwargs):
            return fn(*serializer.load(request.get_json()))
        return decorated

    if decorator_args and callable(decorator_args[0]):
        return wrapped(decorator_args[0])
    return wrapped
550056
def iterGet(self, objectType, *args, **coolArgs) :
		""""""

		for e in self._makeLoadQuery(objectType, *args, **coolArgs).iterRun() :
			if issubclass(objectType, pyGenoRabaObjectWrapper) :
				yield objectType(wrapped_object_and_bag = (e, self.bagKey))
			else :
				yield e
918139
def main():  # suppress(unused-function)
    """"""
    description = ("""Pre-populate cache for polysquare-generic-file-linter and spellcheck-linter.""")
    parser = argparse.ArgumentParser(description=description)
    parser.add_argument("cache_path",
                        metavar=("PATH"),
                        help="""PATH to cache""",
                        type=str)
    parser.add_argument("--technical-terms",
                        metavar=("FILE"),
                        help="""FILE containing technical terms""",
                        type=str)
    arguments = parser.parse_args(sys.argv[1:])
    valid_words_dictionary.create(arguments.cache_path)
    technical_words_dictionary.create(arguments.technical_terms,
                                      arguments.cache_path)
    return 0