Thin method that just uses the provider
335704
def export_disks(
        self,
        standalone=True,
        dst_dir=None,
        compress=False,
        collect_only=False,
        with_threads=True,
        *args,
        **kwargs
    ):
        
        return self.provider.export_disks(
            standalone, dst_dir, compress, collect_only, with_threads, *args,
            **kwargs
        )
129519
Provider getProvider(int index) {
        Provider p = configs[index].getProvider();
        return (p != null) ? p : EMPTY_PROVIDER;
    }
1047120
@Override
  public <T> Provider<T> provider(InjectionPoint<T> ip)
  {
    Objects.requireNonNull(ip);

    Provider<T> provider = lookupProvider(ip);

    if (provider != null) {
      return provider;
    }

    provider = autoProvider(ip);

    if (provider != null) {
      return provider;
    }

    return new ProviderNull(ip.key(), -10000, new InjectScopeSingleton());
  }
1074643
@SuppressWarnings("unchecked")
    public synchronized <T> T load(final PluggableService<T> service, final String providerName)
            throws ProviderLoaderException {
        final ProviderIdent ident = new ProviderIdent(service.getName(), providerName);
        debug("loadInstance for " + ident + ": " + pluginJar);

        if (null == pluginProviderDefs.get(ident)) {
            final String[] strings = getClassnames();
            for (final String classname : strings) {
                final Class<?> cls;
                try {
                    cls = loadClass(classname);
                    if (matchesProviderDeclaration(ident, cls)) {
                        pluginProviderDefs.put(ident, cls);
                    }
                } catch (PluginException e) {
                    log.error("Failed to load class from " + pluginJar + ": classname: " + classname + ": "
                            + e.getMessage());
                }
            }
        }
        final Class<T> cls = pluginProviderDefs.get(ident);
        if (null != cls) {
            try {
                return createProviderForClass(service, cls);
            } catch (PluginException e) {
                throw new ProviderLoaderException(e, service.getName(), providerName);
            }
        }
        return null;
    }
843730
function(providerObject) {
  const fixedProviderObject = Object.assign({}, providerObject);
  const oldGetAccountsMethod = providerObject.getAccounts;

  // fix get accounts
  if (typeof fixedProviderObject.getAccounts !== 'undefined') {
    fixedProviderObject.getAccounts = function(getAccountsCallback) {
      const oldCallback = getAccountsCallback;

      // build fixed callback with lowercased accounts
      const fixedCallback = function(accountsError, accountsResult) {
        const fixedAccountsResult = accountsResult.slice(0);

        // if no error, fixed result
        if (!accountsError) {
          fixedAccountsResult.map(function(item) {
            return String(item.toLowerCase());
          });
        }

        // fire oldd callback with new fix
        oldCallback(accountsError, fixedAccountsResult);
      }

      // fire get accounts method
      oldGetAccountsMethod(fixedCallback);
    };
  }

  // return fixed provider object
  return fixedProviderObject;
}
124630
def _get_provider_manager(self, osid, local=False):
        """"""
        return get_provider_manager(osid,
                                    runtime=self._runtime,
                                    proxy=getattr(self, '_proxy', None),
                                    local=local)
1071622
def bind(cls, app, *paths, methods=None, name=None, **kwargs):
        
        paths = paths or ['/%s(/{%s})?/?' % (cls.name, cls.name)]
        name = name or "api.%s" % cls.name
        return super(RESTHandler, cls).bind(app, *paths, methods=methods, name=name, **kwargs)
219517
private <TResponse> TResponse callServiceOwnerGetApi(
            String path, Class<TResponse> responseClass) throws AuthleteApiException
    {
        return callServiceOwnerGetApi(path, (Map<String, String>)null, responseClass);
    }
150057
def cli(self, method):
        """"""
        routes = getattr(method, '_hug_cli_routes', [])
        routes.append(self.route)
        method._hug_cli_routes = routes
        return method
838648
function proxyMethod(method, source, destination) {
    var oldMethod = source[method];
    source[method] = function() {
        var args = Array.prototype.slice.call(arguments);
        destination[method].apply(destination, args);
        return oldMethod.apply(source, args);
    };
}
185031
def _call_resource_method(self, cls, id, method_name, data):
        """"""

        if cls.api_root != "a":
            url_path = "/{name}/{id}/{method}".format(
                name=cls.collection_name, id=id, method=method_name
            )
        else:
            # Management method.
            url_path = "/a/{app_id}/{name}/{id}/{method}".format(
                app_id=self.app_id, name=cls.collection_name, id=id, method=method_name
            )

        url = URLObject(self.api_server).with_path(url_path)
        converted_data = convert_datetimes_to_timestamps(data, cls.datetime_attrs)

        session = self._get_http_session(cls.api_root)
        response = session.post(url, json=converted_data)

        result = _validate(response).json()
        return cls.create(self, **result)
1302706
def method_missing(method_name, *args, &block)
      if Array.wrap(Config.proxy_method_name).include?(method_name)
        UnitProxyProvider.class_eval do
          define_method(method_name) do |*_args|
            name = _args.first || Function.current_unit.try(:unit_name)
            if name && unit = Loader.load(name)
              UnitProxy.new(unit, self)
            end
          end
        end
        send(method_name, args.first)
      else
        super
      end
    end
981352
def request(self, method, url, **kwargs):
        """"""
        if not url.startswith('https'):
            url = '{}{}'.format(self.args.tc_api_path, url)
        return super(TcExSession, self).request(method, url, **kwargs)
544906
def statichttp(container = None):
    ""
    def decorator(func):
        @functools.wraps(func)
        def handler(event):
            return _handler(container, event, func)
        if hasattr(func, '__self__'):
            handler.__self__ = func.__self__
        return handler
    return decorator
436114
def get_provider(self, provider_name='default'):
        """"""
        try:
            if self._providers is None:
                self._providers = self._initialize_providers()
            return self._providers[provider_name]
        except KeyError:
            raise AssertionError(f'No Provider registered with name {provider_name}')
427898
private int loadAll() {
        if (allLoaded) {
            return configs.length;
        }
        if (debug != null) {
            debug.println("Loading all providers");
            new Exception("Call trace").printStackTrace();
        }
        int n = 0;
        for (int i = 0; i < configs.length; i++) {
            Provider p = configs[i].getProvider();
            if (p != null) {
                n++;
            }
        }
        if (n == configs.length) {
            allLoaded = true;
        }
        return n;
    }
14107
@SuppressWarnings("unchecked")
    @Nullable
    public <T> Provider<T> get(Class<T> type) {
        return (Provider<T>) providers.get(type.getName());
    }