Fetches the TMDb account's configuration data.
 This method hits the following TMDb endpoints:
 - https://api.themoviedb.org/3/configuration
766287
def setup!
      configuration = Enceladus::Requester.get("configuration").images
      self.base_url = configuration.base_url.freeze
      self.secure_base_url = configuration.secure_base_url.freeze
      self.backdrop_sizes = configuration.backdrop_sizes.map(&:freeze).freeze
      self.logo_sizes = configuration.logo_sizes.map(&:freeze).freeze
      self.poster_sizes = configuration.poster_sizes.map(&:freeze).freeze
      self.profile_sizes = configuration.profile_sizes.map(&:freeze).freeze
      self.still_sizes = configuration.still_sizes.map(&:freeze).freeze
      self
    end
44844
def provider_factory(provider, **options):
    
    try:
        return {"tmdb": TMDb, "tvdb": TVDb}[provider.lower()](**options)
    except KeyError:
        msg = "Attempted to initialize non-existing DB Provider"
        log.error(msg)
        raise MapiException(msg)
975527
def QA_fetch_account(message={}, db=DATABASE):
    
    collection = DATABASE.account
    return [res for res in collection.find(message, {"_id": 0})]
728585
def fetch(self, ui_version=values.unset):
        
        params = values.of({'UiVersion': ui_version, })

        payload = self._version.fetch(
            'GET',
            self._uri,
            params=params,
        )

        return ConfigurationInstance(self._version, payload, )
449251
def external_data_configuration(self):
        
        prop = self._properties.get("externalDataConfiguration")
        if prop is not None:
            prop = ExternalConfig.from_api_repr(prop)
        return prop
1234136
def fetch(self):
        
        api = self.doapi_manager
        return api._action(api.request(self.url)["action"])
121879
def get(account):
        
        account = Account.get(account)
        if not account:
            return None

        acct_type = AccountType.get(account.account_type_id).account_type
        account_class = get_plugin_by_name(PLUGIN_NAMESPACES['accounts'], acct_type)

        return account_class(account)
224877
public Configuration getConfiguration() {
		final Configuration conf = new Configuration();
		for (Map.Entry<String, String> entry : data.entrySet()) {
			conf.setString(entry.getKey(), entry.getValue());
		}
		return conf;
	}
428353
async def get_config(self):
        
        config_facade = client.ModelConfigFacade.from_connection(
            self.connection()
        )
        result = await config_facade.ModelGet()
        config = result.config
        for key, value in config.items():
            config[key] = ConfigValue.from_json(value)
        return config
995002
def fetch(self):
        
        params = values.of({})

        payload = self._version.fetch(
            'GET',
            self._uri,
            params=params,
        )

        return MemberInstance(
            self._version,
            payload,
            account_sid=self._solution['account_sid'],
            queue_sid=self._solution['queue_sid'],
            call_sid=self._solution['call_sid'],
        )
1248830
def iam_configuration(self):
        
        info = self._properties.get("iamConfiguration", {})
        return IAMConfiguration.from_api_repr(info, self)
1079123
def fetch(self):
        
        params = values.of({})

        payload = self._version.fetch(
            'GET',
            self._uri,
            params=params,
        )

        return AssetVersionInstance(
            self._version,
            payload,
            service_sid=self._solution['service_sid'],
            asset_sid=self._solution['asset_sid'],
            sid=self._solution['sid'],
        )
1313063
private final Dictionary<String, Object> getConfigForEmbeddedResourceAdapter() throws UnableToAdaptException {
        BundleContext bundleContext = Utils.priv.getBundleContext(FrameworkUtil.getBundle(getClass()));
        ServiceReference<ConfigurationAdmin> configAdminRef = Utils.priv.getServiceReference(bundleContext, ConfigurationAdmin.class);
        ConfigurationAdmin configAdmin = Utils.priv.getService(bundleContext, configAdminRef);
        try {
            // go through all child resourceAdapter configurations until we find the right one, if any
            String parentPid = (String) config.get(SOURCE_PID); // TODO remove once the supertype of application is gone
            if (parentPid == null)
                parentPid = (String) config.get(Constants.SERVICE_PID);
            String filter = "(&(" + ConfigurationAdmin.SERVICE_FACTORYPID +
                            "=com.ibm.ws.jca.embeddedResourceAdapter)(config.parentPID=" + parentPid + "))";
            Configuration[] configurations = configAdmin.listConfigurations(filter);
            if (configurations != null)
                for (Configuration config : configAdmin.listConfigurations(filter)) {
                    Dictionary<String, Object> props = config.getProperties();
                    String id = (String) props.get("id");
                    if (moduleName.equals(id))
                        return props;
                }

            return null;
        } catch (Exception x) {
            throw new UnableToAdaptException(x);
        } finally {
            bundleContext.ungetService(configAdminRef);
        }
    }
1015271
def get_account_details(self):
        
        return self.make_api_request(
            'Account',
            'getAccountDetails',
            utils.get_kwargs(locals()),
            model=models.AccountDetailsResponse,
        )
475648
def _loadConfiguration(self):
        
        configPath = os.path.join(self.path, "config")
        if not os.path.isdir(configPath):
            return

        config = Config(configPath)

        Config.mergeDictionaries(config.getData(), self.application.config)
744713
def _getConfiguration(self):
        
        info =configuration.getConfiguration()

        try:            
            # This returns only the parameters needed by each wrapper. E. g., for Tor:
            # {
            #    "host" : "127.0.0.1"
            #    "port" : "9150"
            # }    
            return info[self.name]
            
        except KeyError, e:
            errMsg = "ERROR. WTF! There was not found any configuration for " + self.name + " in the configuration file!"
            raise Exception( errMsg )
63402
public Account getAccount(String sessionId) throws MovieDbException {
        TmdbParameters parameters = new TmdbParameters();
        parameters.add(Param.SESSION_ID, sessionId);

        URL url = new ApiUrl(apiKey, MethodBase.ACCOUNT).buildUrl(parameters);
        String webpage = httpTools.getRequest(url);

        try {
            return MAPPER.readValue(webpage, Account.class);
        } catch (IOException ex) {
            throw new MovieDbException(ApiExceptionType.MAPPING_FAILED, "Failed to get Account", url, ex);
        }
    }