troveclient/v1/clusters.py
class Cluster(base.Resource):
class Clusters(base.ManagerWithFind):
class ClusterStatus(object):
    def __repr__(self):
    def delete(self):
    def force_delete(self):
    def create(self, name, datastore, datastore_version, instances=None,
               locality=None, extended_properties=None, configuration=None):
    def list(self, limit=None, marker=None):
    def get(self, cluster):
    def delete(self, cluster):
    def reset_status(self, cluster):
    def _action(self, cluster, body):
    def add_shard(self, cluster):
    def grow(self, cluster, instances=None):
    def shrink(self, cluster, instances=None):
    def upgrade(self, cluster, datastore_version):
    ACTIVE = "ACTIVE"
    BUILD = "BUILD"
    FAILED = "FAILED"
    SHUTDOWN = "SHUTDOWN"
troveclient/v1/backup_strategy.py
class BackupStrategy(base.Resource):
class BackupStrategiesManager(base.ManagerWithFind):
    def __repr__(self):
    def list(self, instance_id=None, project_id=None):
    def create(self, instance_id=None, swift_container=None):
    def delete(self, instance_id=None, project_id=None):
troveclient/v1/security_groups.py
class SecurityGroup(base.Resource):
class SecurityGroups(base.ManagerWithFind):
class SecurityGroupRule(base.Resource):
class SecurityGroupRules(base.ManagerWithFind):
    def __repr__(self):
    def list(self, limit=None, marker=None):
    def get(self, security_group):
    def __repr__(self):
    def create(self, group_id, cidr):
    def delete(self, security_group_rule):
    def list(self):
troveclient/v1/datastores.py
class Datastore(base.Resource):
class DatastoreVersion(base.Resource):
class DatastoreVersionMember(base.Resource):
class Datastores(base.ManagerWithFind):
class DatastoreVersions(base.ManagerWithFind):
class DatastoreVersionMembers(base.ManagerWithFind):
    def __repr__(self):
    def __repr__(self):
    def update(self, visibility=None):
    def __repr__(self):
    def __repr__(self):
    def list(self, limit=None, marker=None):
    def get(self, datastore):
    def delete(self, datastore):
    def __repr__(self):
    def list(self, datastore, limit=None, marker=None):
    def get(self, datastore, datastore_version):
    def get_by_uuid(self, datastore_version):
    def update(self, datastore, datastore_version, visibility):
    def __repr__(self):
    def add(self, datastore, datastore_version, tenant):
    def delete(self, datastore, datastore_version, member_id):
    def list(self, datastore, datastore_version, limit=None, marker=None):
    def get(self, datastore, datastore_version, member_id):
    def get_by_tenant(self, datastore, tenant, limit=None, marker=None):
troveclient/v1/instances.py
REBOOT_SOFT = 'SOFT'
REBOOT_HARD = 'HARD'
    ACTIVE = "ACTIVE"
    BLOCKED = "BLOCKED"
    BUILD = "BUILD"
    FAILED = "FAILED"
    REBOOT = "REBOOT"
    RESIZE = "RESIZE"
    SHUTDOWN = "SHUTDOWN"
    RESTART_REQUIRED = "RESTART_REQUIRED"
    PROMOTING = "PROMOTING"
    EJECTING = "EJECTING"
    LOGGING = "LOGGING"
class Instance(base.Resource):
class DatastoreLog(base.Resource):
class Instances(base.ManagerWithFind):
class InstanceStatus(object):
    def list_databases(self):
    def delete(self):
    def force_delete(self):
    def restart(self):
    def detach_replica(self):
    def __repr__(self):
    def _get_swift_client(self):
    def create(self, name, flavor_id=None, volume=None, databases=None,
               users=None, restorePoint=None, availability_zone=None,
               datastore=None, datastore_version=None, nics=None,
               configuration=None, replica_of=None, replica_count=None,
               modules=None, locality=None, region_name=None, access=None,
               datastore_version_number=None, **kwargs):
    def modify(self, instance, configuration=None):
    def update(self, instance, configuration=None, name=None,
               detach_replica_source=False, remove_configuration=False,
               is_public=None, allowed_cidrs=None):
    def upgrade(self, instance, datastore_version):
    def list(self, limit=None, marker=None, include_clustered=False,
             detailed=False):
    def get(self, instance):
    def backups(self, instance, limit=None, marker=None):
    def delete(self, instance):
    def reset_status(self, instance):
    def force_delete(self, instance):
    def _action(self, instance, body):
    def resize_volume(self, instance, volume_size):
    def resize_instance(self, instance, flavor_id):
    def restart(self, instance):
    def configuration(self, instance):
    def promote_to_replica_source(self, instance):
    def eject_replica_source(self, instance):
    def modules(self, instance):
    def module_query(self, instance):
    def module_retrieve(self, instance, directory=None, prefix=None):
    def _modules_get(self, instance, from_guest=None, include_contents=None):
    def module_apply(self, instance, modules):
    def _get_module_list(self, modules):
    def module_remove(self, instance, module):
    def log_list(self, instance):
    def log_show(self, instance, log_name):
    def log_action(self, instance, log_name, enable=None, disable=None,
                   publish=None, discard=None):
    def _get_container_info(self, instance, log_name):
    def log_generator(self, instance, log_name, lines=50, swift=None):
        def _log_generator(instance, log_name, lines, swift):
    def log_save(self, instance, log_name, filename=None):
troveclient/v1/users.py
class User(base.Resource):
class Users(base.ManagerWithFind):
    def __repr__(self):
    def create(self, instance, users):
    def delete(self, instance, username, hostname=None):
    def list(self, instance, limit=None, marker=None):
    def get(self, instance, username, hostname=None):
    def update_attributes(self, instance, username, newuserattr=None,
                          hostname=None):
    def list_access(self, instance, username, hostname=None):
    def grant(self, instance, username, databases, hostname=None):
    def revoke(self, instance, username, database, hostname=None):
    def change_passwords(self, instance, users):
troveclient/v1/backups.py
class Backup(base.Resource):
class Schedule(base.Resource):
class ScheduleExecution(base.Resource):
class Backups(base.ManagerWithFind):
    def __repr__(self):
    def __repr__(self):
    def __repr__(self):
    def get(self, backup):
    def list(self, limit=None, marker=None, datastore=None, instance_id=None,
             all_projects=False, project_id=None):
    def create(self, name, instance, description=None,
               parent_id=None, incremental=False, swift_container=None,
               restore_from=None, restore_ds_version=None, restore_size=None):
    def delete(self, backup):
    def _get_mistral_client(self):
    def _build_schedule(self, cron_trigger, wf_input):
    def schedule_create(self, instance, pattern, name,
                        description=None, incremental=None,
                        mistral_client=None):
    def schedule_list(self, instance, mistral_client=None):
    def schedule_show(self, schedule, mistral_client=None):
    def schedule_delete(self, schedule, mistral_client=None):
    def execution_list(self, schedule, mistral_client=None,
                       marker='', limit=None):
        def mistral_execution_generator():
        def execution_list_generator():
    def execution_delete(self, execution, mistral_client=None):
troveclient/v1/databases.py
class Database(base.Resource):
class Databases(base.ManagerWithFind):
    def __repr__(self):
    def create(self, instance, databases):
    def delete(self, instance, dbname):
    def list(self, instance, limit=None, marker=None):
troveclient/client.py
class TroveClientMixin(object):
class HTTPClient(TroveClientMixin):
class SessionClient(adapter.LegacyJsonAdapter, TroveClientMixin):
    def get_database_api_version_from_endpoint(self):
    def __init__(self, user, password, projectid, auth_url, insecure=False,
                 timeout=None, tenant_id=None, proxy_tenant_id=None,
                 proxy_token=None, region_name=None,
                 endpoint_type='publicURL', service_type=None,
                 service_name=None, database_service_name=None, retries=None,
                 http_log_debug=False, cacert=None, bypass_url=None,
                 auth_system='keystone', auth_plugin=None):
    def http_log_req(self, args, kwargs):
    def http_log_resp(self, resp):
    def request(self, url, method, **kwargs):
    def _cs_request(self, url, method, **kwargs):
    def get(self, url, **kwargs):
    def patch(self, url, **kwargs):
    def post(self, url, **kwargs):
    def put(self, url, **kwargs):
    def delete(self, url, **kwargs):
    def _extract_service_catalog(self, url, resp, body, extract_token=True):
    def _fetch_endpoints_from_auth(self, url):
    def authenticate(self):
    def _plugin_auth(self, auth_url):
    def _v1_auth(self, url):
    def _v2_auth(self, url):
    def _authenticate(self, url, body):
    def __init__(self, session, auth, **kwargs):
    def request(self, url, method, **kwargs):
def _construct_http_client(username=None, password=None, project_id=None,
                           auth_url=None, insecure=False, timeout=None,
                           proxy_tenant_id=None, proxy_token=None,
                           region_name=None, endpoint_type='publicURL',
                           service_type='database',
                           service_name=None, database_service_name=None,
                           retries=None,
                           http_log_debug=False,
                           auth_system='keystone', auth_plugin=None,
                           cacert=None, bypass_url=None, tenant_id=None,
                           session=None,
                           **kwargs):
def get_version_map():
def Client(version, *args, **kwargs):
    USER_AGENT = 'python-troveclient'
troveclient/v1/management.py
class RootHistory(base.Resource):
class Management(base.ManagerWithFind):
class MgmtClusters(base.ManagerWithFind):
class MgmtFlavors(base.ManagerWithFind):
class MgmtConfigurationParameters(configurations.ConfigurationParameters):
class MgmtDatastoreVersions(base.ManagerWithFind):
    def __repr__(self):
    def show(self, instance):
    def index(self, **kwargs):
    def list(self, limit=None, marker=None, deleted=False, **kwargs):
    def root_enabled_history(self, instance):
    def _action(self, instance_id, body):
    def stop(self, instance_id):
    def reboot(self, instance_id):
    def migrate(self, instance_id, host=None):
    def update(self, instance_id):
    def reset_task_status(self, instance_id):
    def rebuild(self, instance_id, image_id):
    def list(self):
    def show(self, cluster):
    def index(self, deleted=None, limit=None, marker=None):
    def _action(self, cluster_id, body):
    def reset_task(self, cluster_id):
    def __repr__(self):
    def list(self):
    def create(self, name, ram, disk, vcpus,
               flavorid="auto", ephemeral=None, swap=None, rxtx_factor=None,
               service_type=None):
    def create(self, version, name, restart_required, data_type,
               max_size=None, min_size=None):
    def list_all_parameter_by_version(self, version):
    def get_any_parameter_by_version(self, version, key):
    def modify(self, version, name, restart_required, data_type,
               max_size=None, min_size=None):
    def delete(self, version, name):
    def list(self, limit=None, marker=None):
    def get(self, datastore_version_id):
    def create(self, name, datastore_name, datastore_manager, image,
               packages=None, active='true', default='false', image_tags=[],
               version=None):
    def edit(self, datastore_version_id, datastore_manager=None, image=None,
             packages=None, active=None, default=None, image_tags=None,
             name=None):
    def delete(self, datastore_version_id):
troveclient/v1/quota.py
class Quotas(base.ManagerWithFind):
    def show(self, tenant_id):
    def update(self, id, quotas):
    def list(self):
troveclient/v1/configurations.py
class Configuration(base.Resource):
class Configurations(base.ManagerWithFind):
class ConfigurationParameter(base.Resource):
class ConfigurationParameters(base.ManagerWithFind):
    def __repr__(self):
    def get(self, configuration):
    def instances(self, configuration, limit=None, marker=None):
    def list(self, limit=None, marker=None):
    def create(self, name, values, description=None, datastore=None,
               datastore_version=None, datastore_version_number=None):
    def update(self, configuration, values, name=None, description=None):
    def edit(self, configuration, values):
    def delete(self, configuration):
    def __repr__(self):
    def parameters(self, datastore, version):
    def get_parameter(self, datastore, version, key):
    def parameters_by_version(self, version):
    def get_parameter_by_version(self, version, key):
    def list(self):
troveclient/v1/limits.py
class Limit(base.Resource):
class Limits(base.ManagerWithFind):
    def __repr__(self):
    def __repr__(self):
    def _list(self, url, response_key):
    def list(self):


Question: from troveclient import client as trove_client
from troveclient.v1 import backup_strategy
from troveclient.v1 import backups
from troveclient.v1 import clusters
from troveclient.v1 import configurations
from troveclient.v1 import databases
from troveclient.v1 import datastores
from troveclient.v1 import flavors
from troveclient.v1 import instances
from troveclient.v1 import limits
from troveclient.v1 import management
from troveclient.v1 import metadata
from troveclient.v1 import modules
from troveclient.v1 import quota
from troveclient.v1 import root
from troveclient.v1 import security_groups
from troveclient.v1 import users
from troveclient.v1 import volume_types
# Copyright 2011 OpenStack Foundation
# Copyright 2013 Rackspace Hosting
# All Rights Reserved.
#
#    Licensed under the Apache License, Version 2.0 (the "License"); you may
#    not use this file except in compliance with the License. You may obtain
#    a copy of the License at
#
#         http://www.apache.org/licenses/LICENSE-2.0
#
#    Unless required by applicable law or agreed to in writing, software
#    distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
#    WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
#    License for the specific language governing permissions and limitations
#    under the License.



class Client(object):
    """Top-level object to access the OpenStack Database API.

    Create an instance with your creds::

        >> client = Client(USERNAME,
                           PASSWORD,
                           project_id=TENANT_NAME,
                           auth_url=AUTH_URL)

    Then call methods on its managers::

        >> client.instances.list()
        ...

    """

    def __init__(self, username=None, password=None, project_id=None,
                 auth_url='',
                 insecure=False, timeout=None, tenant_id=None,
                 proxy_tenant_id=None, proxy_token=None, region_name=None,
                 endpoint_type='publicURL', extensions=None,
                 service_type='database', service_name=None,
                 database_service_name=None, retries=None,
                 http_log_debug=False,
                 cacert=None, bypass_url=None,
                 auth_system='keystone', auth_plugin=None, session=None,
                 auth=None, **kwargs):
        # self.limits = limits.LimitsManager(self)

        # extensions
        self.flavors = flavors.Flavors(self)
        self.volume_types = volume_types.VolumeTypes(self)
        self.users = users.Users(self)
        self.databases = databases.Databases(self)
        self.backups = backups.Backups(self)
        self.backup_strategies = backup_strategy.BackupStrategiesManager(self)
        self.clusters = clusters.Clusters(self)
        self.instances = instances.Instances(self)
        self.limits = limits.Limits(self)
        self.root = root.Root(self)
        self.security_group_rules = security_groups.SecurityGroupRules(self)
        self.security_groups = security_groups.SecurityGroups(self)
        self.datastores = datastores.Datastores(self)
        self.datastore_versions = datastores.DatastoreVersions(self)
        self.configurations = configurations.Configurations(self)
        self.configuration_parameters = configurations.ConfigurationParameters(
            self)
        self.metadata = metadata.Metadata(self)
        self.modules = modules.Modules(self)

Answer:         self.quota = quota.Quotas(self)