_toPy = {'servers': 'servers'}
def __init__(self, servers=None, **unknown_fields):
'''
- servers : typing.Sequence<+T_co>[~HostPort]<~HostPort>
+ servers : typing.Sequence[~HostPort]
'''
self.servers = [HostPort.from_json(o) for o in servers or []]
def __init__(self, name=None, parameters=None, receiver=None, tag=None, **unknown_fields):
'''
name : str
- parameters : typing.Mapping<~KT, +VT_co>[str, typing.Any]
+ parameters : typing.Mapping[str, typing.Any]
receiver : str
tag : str
'''
'''
action_tag : str
message : str
- results : typing.Mapping<~KT, +VT_co>[str, typing.Any]
+ results : typing.Mapping[str, typing.Any]
status : str
'''
self.action_tag = action_tag
_toPy = {'results': 'results'}
def __init__(self, results=None, **unknown_fields):
'''
- results : typing.Sequence<+T_co>[~ActionExecutionResult]<~ActionExecutionResult>
+ results : typing.Sequence[~ActionExecutionResult]
'''
self.results = [ActionExecutionResult.from_json(o) for o in results or []]
+class ActionPruneArgs(Type):
+ _toSchema = {'max_history_mb': 'max-history-mb', 'max_history_time': 'max-history-time'}
+ _toPy = {'max-history-mb': 'max_history_mb', 'max-history-time': 'max_history_time'}
+ def __init__(self, max_history_mb=None, max_history_time=None, **unknown_fields):
+ '''
+ max_history_mb : int
+ max_history_time : int
+ '''
+ self.max_history_mb = max_history_mb
+ self.max_history_time = max_history_time
+
+
+
class ActionResult(Type):
_toSchema = {'action': 'action', 'completed': 'completed', 'enqueued': 'enqueued', 'error': 'error', 'message': 'message', 'output': 'output', 'started': 'started', 'status': 'status'}
_toPy = {'action': 'action', 'completed': 'completed', 'enqueued': 'enqueued', 'error': 'error', 'message': 'message', 'output': 'output', 'started': 'started', 'status': 'status'}
enqueued : str
error : Error
message : str
- output : typing.Mapping<~KT, +VT_co>[str, typing.Any]
+ output : typing.Mapping[str, typing.Any]
started : str
status : str
'''
_toPy = {'results': 'results'}
def __init__(self, results=None, **unknown_fields):
'''
- results : typing.Sequence<+T_co>[~ActionResult]<~ActionResult>
+ results : typing.Sequence[~ActionResult]
'''
self.results = [ActionResult.from_json(o) for o in results or []]
def __init__(self, description=None, params=None, **unknown_fields):
'''
description : str
- params : typing.Mapping<~KT, +VT_co>[str, typing.Any]
+ params : typing.Mapping[str, typing.Any]
'''
self.description = description
self.params = params
_toPy = {'actions': 'actions'}
def __init__(self, actions=None, **unknown_fields):
'''
- actions : typing.Sequence<+T_co>[~Action]<~Action>
+ actions : typing.Sequence[~Action]
'''
self.actions = [Action.from_json(o) for o in actions or []]
_toPy = {'actions': 'actions', 'error': 'error', 'name': 'name'}
def __init__(self, actions=None, error=None, name=None, **unknown_fields):
'''
- actions : typing.Sequence<+T_co>[~ActionResult]<~ActionResult>
+ actions : typing.Sequence[~ActionResult]
error : Error
name : str
'''
_toPy = {'actions': 'actions'}
def __init__(self, actions=None, **unknown_fields):
'''
- actions : typing.Sequence<+T_co>[~ActionsByName]<~ActionsByName>
+ actions : typing.Sequence[~ActionsByName]
'''
self.actions = [ActionsByName.from_json(o) for o in actions or []]
_toPy = {'actions': 'actions', 'error': 'error', 'receiver': 'receiver'}
def __init__(self, actions=None, error=None, receiver=None, **unknown_fields):
'''
- actions : typing.Sequence<+T_co>[~ActionResult]<~ActionResult>
+ actions : typing.Sequence[~ActionResult]
error : Error
receiver : str
'''
_toPy = {'actions': 'actions'}
def __init__(self, actions=None, **unknown_fields):
'''
- actions : typing.Sequence<+T_co>[~ActionsByReceiver]<~ActionsByReceiver>
+ actions : typing.Sequence[~ActionsByReceiver]
'''
self.actions = [ActionsByReceiver.from_json(o) for o in actions or []]
+class AddApplicationOffer(Type):
+ _toSchema = {'application_description': 'application-description', 'application_name': 'application-name', 'endpoints': 'endpoints', 'model_tag': 'model-tag', 'offer_name': 'offer-name'}
+ _toPy = {'application-description': 'application_description', 'application-name': 'application_name', 'endpoints': 'endpoints', 'model-tag': 'model_tag', 'offer-name': 'offer_name'}
+ def __init__(self, application_description=None, application_name=None, endpoints=None, model_tag=None, offer_name=None, **unknown_fields):
+ '''
+ application_description : str
+ application_name : str
+ endpoints : typing.Mapping[str, str]
+ model_tag : str
+ offer_name : str
+ '''
+ self.application_description = application_description
+ self.application_name = application_name
+ self.endpoints = endpoints
+ self.model_tag = model_tag
+ self.offer_name = offer_name
+
+
+
+class AddApplicationOffers(Type):
+ _toSchema = {'offers': 'Offers'}
+ _toPy = {'Offers': 'offers'}
+ def __init__(self, offers=None, **unknown_fields):
+ '''
+ offers : typing.Sequence[~AddApplicationOffer]
+ '''
+ self.offers = [AddApplicationOffer.from_json(o) for o in offers or []]
+
+
+
class AddApplicationUnits(Type):
_toSchema = {'application': 'application', 'num_units': 'num-units', 'placement': 'placement'}
_toPy = {'application': 'application', 'num-units': 'num_units', 'placement': 'placement'}
'''
application : str
num_units : int
- placement : typing.Sequence<+T_co>[~Placement]<~Placement>
+ placement : typing.Sequence[~Placement]
'''
self.application = application
self.num_units = num_units
_toPy = {'units': 'units'}
def __init__(self, units=None, **unknown_fields):
'''
- units : typing.Sequence<+T_co>[str]
+ units : typing.Sequence[str]
'''
self.units = units
+class AddCloudArgs(Type):
+ _toSchema = {'cloud': 'cloud', 'name': 'name'}
+ _toPy = {'cloud': 'cloud', 'name': 'name'}
+ def __init__(self, cloud=None, name=None, **unknown_fields):
+ '''
+ cloud : Cloud
+ name : str
+ '''
+ self.cloud = Cloud.from_json(cloud) if cloud else None
+ self.name = name
+
+
+
class AddMachineParams(Type):
_toSchema = {'addresses': 'addresses', 'constraints': 'constraints', 'container_type': 'container-type', 'disks': 'disks', 'hardware_characteristics': 'hardware-characteristics', 'instance_id': 'instance-id', 'jobs': 'jobs', 'nonce': 'nonce', 'parent_id': 'parent-id', 'placement': 'placement', 'series': 'series'}
_toPy = {'addresses': 'addresses', 'constraints': 'constraints', 'container-type': 'container_type', 'disks': 'disks', 'hardware-characteristics': 'hardware_characteristics', 'instance-id': 'instance_id', 'jobs': 'jobs', 'nonce': 'nonce', 'parent-id': 'parent_id', 'placement': 'placement', 'series': 'series'}
def __init__(self, addresses=None, constraints=None, container_type=None, disks=None, hardware_characteristics=None, instance_id=None, jobs=None, nonce=None, parent_id=None, placement=None, series=None, **unknown_fields):
'''
- addresses : typing.Sequence<+T_co>[~Address]<~Address>
+ addresses : typing.Sequence[~Address]
constraints : Value
container_type : str
- disks : typing.Sequence<+T_co>[~Constraints]<~Constraints>
+ disks : typing.Sequence[~Constraints]
hardware_characteristics : HardwareCharacteristics
instance_id : str
- jobs : typing.Sequence<+T_co>[str]
+ jobs : typing.Sequence[str]
nonce : str
parent_id : str
placement : Placement
_toPy = {'params': 'params'}
def __init__(self, params=None, **unknown_fields):
'''
- params : typing.Sequence<+T_co>[~AddMachineParams]<~AddMachineParams>
+ params : typing.Sequence[~AddMachineParams]
'''
self.params = [AddMachineParams.from_json(o) for o in params or []]
_toPy = {'machines': 'machines'}
def __init__(self, machines=None, **unknown_fields):
'''
- machines : typing.Sequence<+T_co>[~AddMachinesResult]<~AddMachinesResult>
+ machines : typing.Sequence[~AddMachinesResult]
'''
self.machines = [AddMachinesResult.from_json(o) for o in machines or []]
'''
addcharmwithauthorization : AddCharmWithAuthorization
entity : Entity
- resources : typing.Sequence<+T_co>[~CharmResource]<~CharmResource>
+ resources : typing.Sequence[~CharmResource]
'''
self.addcharmwithauthorization = AddCharmWithAuthorization.from_json(addcharmwithauthorization) if addcharmwithauthorization else None
self.entity = Entity.from_json(entity) if entity else None
def __init__(self, errorresult=None, pending_ids=None, **unknown_fields):
'''
errorresult : ErrorResult
- pending_ids : typing.Sequence<+T_co>[str]
+ pending_ids : typing.Sequence[str]
'''
self.errorresult = ErrorResult.from_json(errorresult) if errorresult else None
self.pending_ids = pending_ids
_toPy = {'endpoints': 'endpoints'}
def __init__(self, endpoints=None, **unknown_fields):
'''
- endpoints : typing.Sequence<+T_co>[str]
+ endpoints : typing.Sequence[str]
'''
self.endpoints = endpoints
_toPy = {'endpoints': 'endpoints'}
def __init__(self, endpoints=None, **unknown_fields):
'''
- endpoints : typing.Mapping<~KT, +VT_co>[str, ~CharmRelation]<~CharmRelation>
+ endpoints : typing.Mapping[str, ~CharmRelation]
'''
self.endpoints = endpoints
+class AddStorageDetails(Type):
+ _toSchema = {'storage_tags': 'storage-tags'}
+ _toPy = {'storage-tags': 'storage_tags'}
+ def __init__(self, storage_tags=None, **unknown_fields):
+ '''
+ storage_tags : typing.Sequence[str]
+ '''
+ self.storage_tags = storage_tags
+
+
+
+class AddStorageResult(Type):
+ _toSchema = {'error': 'error', 'result': 'result'}
+ _toPy = {'error': 'error', 'result': 'result'}
+ def __init__(self, error=None, result=None, **unknown_fields):
+ '''
+ error : Error
+ result : AddStorageDetails
+ '''
+ self.error = Error.from_json(error) if error else None
+ self.result = AddStorageDetails.from_json(result) if result else None
+
+
+
+class AddStorageResults(Type):
+ _toSchema = {'results': 'results'}
+ _toPy = {'results': 'results'}
+ def __init__(self, results=None, **unknown_fields):
+ '''
+ results : typing.Sequence[~AddStorageResult]
+ '''
+ self.results = [AddStorageResult.from_json(o) for o in results or []]
+
+
+
class AddSubnetParams(Type):
_toSchema = {'space_tag': 'space-tag', 'subnet_provider_id': 'subnet-provider-id', 'subnet_tag': 'subnet-tag', 'zones': 'zones'}
_toPy = {'space-tag': 'space_tag', 'subnet-provider-id': 'subnet_provider_id', 'subnet-tag': 'subnet_tag', 'zones': 'zones'}
space_tag : str
subnet_provider_id : str
subnet_tag : str
- zones : typing.Sequence<+T_co>[str]
+ zones : typing.Sequence[str]
'''
self.space_tag = space_tag
self.subnet_provider_id = subnet_provider_id
_toPy = {'subnets': 'subnets'}
def __init__(self, subnets=None, **unknown_fields):
'''
- subnets : typing.Sequence<+T_co>[~AddSubnetParams]<~AddSubnetParams>
+ subnets : typing.Sequence[~AddSubnetParams]
'''
self.subnets = [AddSubnetParams.from_json(o) for o in subnets or []]
def __init__(self, error=None, secret_key=None, tag=None, **unknown_fields):
'''
error : Error
- secret_key : typing.Sequence<+T_co>[int]
+ secret_key : typing.Sequence[int]
tag : str
'''
self.error = Error.from_json(error) if error else None
_toPy = {'results': 'results'}
def __init__(self, results=None, **unknown_fields):
'''
- results : typing.Sequence<+T_co>[~AddUserResult]<~AddUserResult>
+ results : typing.Sequence[~AddUserResult]
'''
self.results = [AddUserResult.from_json(o) for o in results or []]
_toPy = {'users': 'users'}
def __init__(self, users=None, **unknown_fields):
'''
- users : typing.Sequence<+T_co>[~AddUser]<~AddUser>
+ users : typing.Sequence[~AddUser]
'''
self.users = [AddUser.from_json(o) for o in users or []]
'''
container_type : str
error : Error
- jobs : typing.Sequence<+T_co>[str]
+ jobs : typing.Sequence[str]
life : str
'''
self.container_type = container_type
_toPy = {'entities': 'entities'}
def __init__(self, entities=None, **unknown_fields):
'''
- entities : typing.Sequence<+T_co>[~AgentGetEntitiesResult]<~AgentGetEntitiesResult>
+ entities : typing.Sequence[~AgentGetEntitiesResult]
'''
self.entities = [AgentGetEntitiesResult.from_json(o) for o in entities or []]
_toPy = {'deltas': 'deltas'}
def __init__(self, deltas=None, **unknown_fields):
'''
- deltas : typing.Sequence<+T_co>[~Delta]<~Delta>
+ deltas : typing.Sequence[~Delta]
'''
self.deltas = [Delta.from_json(o) for o in deltas or []]
_toPy = {'annotations': 'annotations', 'entity': 'entity', 'error': 'error'}
def __init__(self, annotations=None, entity=None, error=None, **unknown_fields):
'''
- annotations : typing.Mapping<~KT, +VT_co>[str, str]
+ annotations : typing.Mapping[str, str]
entity : str
error : ErrorResult
'''
_toPy = {'results': 'results'}
def __init__(self, results=None, **unknown_fields):
'''
- results : typing.Sequence<+T_co>[~AnnotationsGetResult]<~AnnotationsGetResult>
+ results : typing.Sequence[~AnnotationsGetResult]
'''
self.results = [AnnotationsGetResult.from_json(o) for o in results or []]
_toPy = {'annotations': 'annotations'}
def __init__(self, annotations=None, **unknown_fields):
'''
- annotations : typing.Sequence<+T_co>[~EntityAnnotations]<~EntityAnnotations>
+ annotations : typing.Sequence[~EntityAnnotations]
'''
self.annotations = [EntityAnnotations.from_json(o) for o in annotations or []]
+class ApplicationCharm(Type):
+ _toSchema = {'charm_modified_version': 'charm-modified-version', 'force_upgrade': 'force-upgrade', 'sha256': 'sha256', 'url': 'url'}
+ _toPy = {'charm-modified-version': 'charm_modified_version', 'force-upgrade': 'force_upgrade', 'sha256': 'sha256', 'url': 'url'}
+ def __init__(self, charm_modified_version=None, force_upgrade=None, sha256=None, url=None, **unknown_fields):
+ '''
+ charm_modified_version : int
+ force_upgrade : bool
+ sha256 : str
+ url : str
+ '''
+ self.charm_modified_version = charm_modified_version
+ self.force_upgrade = force_upgrade
+ self.sha256 = sha256
+ self.url = url
+
+
+
class ApplicationCharmActionsResult(Type):
_toSchema = {'actions': 'actions', 'application_tag': 'application-tag', 'error': 'error'}
_toPy = {'actions': 'actions', 'application-tag': 'application_tag', 'error': 'error'}
def __init__(self, actions=None, application_tag=None, error=None, **unknown_fields):
'''
- actions : typing.Mapping<~KT, +VT_co>[str, ~ActionSpec]<~ActionSpec>
+ actions : typing.Mapping[str, ~ActionSpec]
application_tag : str
error : Error
'''
_toPy = {'charm-relations': 'charm_relations'}
def __init__(self, charm_relations=None, **unknown_fields):
'''
- charm_relations : typing.Sequence<+T_co>[str]
+ charm_relations : typing.Sequence[str]
'''
self.charm_relations = charm_relations
+class ApplicationCharmResult(Type):
+ _toSchema = {'error': 'error', 'result': 'result'}
+ _toPy = {'error': 'error', 'result': 'result'}
+ def __init__(self, error=None, result=None, **unknown_fields):
+ '''
+ error : Error
+ result : ApplicationCharm
+ '''
+ self.error = Error.from_json(error) if error else None
+ self.result = ApplicationCharm.from_json(result) if result else None
+
+
+
+class ApplicationCharmResults(Type):
+ _toSchema = {'results': 'results'}
+ _toPy = {'results': 'results'}
+ def __init__(self, results=None, **unknown_fields):
+ '''
+ results : typing.Sequence[~ApplicationCharmResult]
+ '''
+ self.results = [ApplicationCharmResult.from_json(o) for o in results or []]
+
+
+
+class ApplicationConfigSet(Type):
+ _toSchema = {'application': 'application', 'config': 'config'}
+ _toPy = {'application': 'application', 'config': 'config'}
+ def __init__(self, application=None, config=None, **unknown_fields):
+ '''
+ application : str
+ config : typing.Mapping[str, str]
+ '''
+ self.application = application
+ self.config = config
+
+
+
+class ApplicationConfigSetArgs(Type):
+ _toSchema = {'args': 'Args'}
+ _toPy = {'Args': 'args'}
+ def __init__(self, args=None, **unknown_fields):
+ '''
+ args : typing.Sequence[~ApplicationConfigSet]
+ '''
+ self.args = [ApplicationConfigSet.from_json(o) for o in args or []]
+
+
+
+class ApplicationConfigUnsetArgs(Type):
+ _toSchema = {'args': 'Args'}
+ _toPy = {'Args': 'args'}
+ def __init__(self, args=None, **unknown_fields):
+ '''
+ args : typing.Sequence[~ApplicationUnset]
+ '''
+ self.args = [ApplicationUnset.from_json(o) for o in args or []]
+
+
+
+class ApplicationConstraint(Type):
+ _toSchema = {'constraints': 'constraints', 'error': 'error'}
+ _toPy = {'constraints': 'constraints', 'error': 'error'}
+ def __init__(self, constraints=None, error=None, **unknown_fields):
+ '''
+ constraints : Value
+ error : Error
+ '''
+ self.constraints = Value.from_json(constraints) if constraints else None
+ self.error = Error.from_json(error) if error else None
+
+
+
class ApplicationDeploy(Type):
- _toSchema = {'application': 'application', 'channel': 'channel', 'charm_url': 'charm-url', 'config': 'config', 'config_yaml': 'config-yaml', 'constraints': 'constraints', 'endpoint_bindings': 'endpoint-bindings', 'num_units': 'num-units', 'placement': 'placement', 'resources': 'resources', 'series': 'series', 'storage': 'storage'}
- _toPy = {'application': 'application', 'channel': 'channel', 'charm-url': 'charm_url', 'config': 'config', 'config-yaml': 'config_yaml', 'constraints': 'constraints', 'endpoint-bindings': 'endpoint_bindings', 'num-units': 'num_units', 'placement': 'placement', 'resources': 'resources', 'series': 'series', 'storage': 'storage'}
- def __init__(self, application=None, channel=None, charm_url=None, config=None, config_yaml=None, constraints=None, endpoint_bindings=None, num_units=None, placement=None, resources=None, series=None, storage=None, **unknown_fields):
+ _toSchema = {'application': 'application', 'attach_storage': 'attach-storage', 'channel': 'channel', 'charm_url': 'charm-url', 'config': 'config', 'config_yaml': 'config-yaml', 'constraints': 'constraints', 'devices': 'devices', 'endpoint_bindings': 'endpoint-bindings', 'num_units': 'num-units', 'placement': 'placement', 'policy': 'policy', 'resources': 'resources', 'series': 'series', 'storage': 'storage'}
+ _toPy = {'application': 'application', 'attach-storage': 'attach_storage', 'channel': 'channel', 'charm-url': 'charm_url', 'config': 'config', 'config-yaml': 'config_yaml', 'constraints': 'constraints', 'devices': 'devices', 'endpoint-bindings': 'endpoint_bindings', 'num-units': 'num_units', 'placement': 'placement', 'policy': 'policy', 'resources': 'resources', 'series': 'series', 'storage': 'storage'}
+ def __init__(self, application=None, attach_storage=None, channel=None, charm_url=None, config=None, config_yaml=None, constraints=None, devices=None, endpoint_bindings=None, num_units=None, placement=None, policy=None, resources=None, series=None, storage=None, **unknown_fields):
'''
application : str
+ attach_storage : typing.Sequence[str]
channel : str
charm_url : str
- config : typing.Mapping<~KT, +VT_co>[str, str]
+ config : typing.Mapping[str, str]
config_yaml : str
constraints : Value
- endpoint_bindings : typing.Mapping<~KT, +VT_co>[str, str]
+ devices : typing.Mapping[str, ~Constraints]
+ endpoint_bindings : typing.Mapping[str, str]
num_units : int
- placement : typing.Sequence<+T_co>[~Placement]<~Placement>
- resources : typing.Mapping<~KT, +VT_co>[str, str]
+ placement : typing.Sequence[~Placement]
+ policy : str
+ resources : typing.Mapping[str, str]
series : str
- storage : typing.Mapping<~KT, +VT_co>[str, ~Constraints]<~Constraints>
+ storage : typing.Mapping[str, ~Constraints]
'''
self.application = application
+ self.attach_storage = attach_storage
self.channel = channel
self.charm_url = charm_url
self.config = config
self.config_yaml = config_yaml
self.constraints = Value.from_json(constraints) if constraints else None
+ self.devices = devices
self.endpoint_bindings = endpoint_bindings
self.num_units = num_units
self.placement = [Placement.from_json(o) for o in placement or []]
+ self.policy = policy
self.resources = resources
self.series = series
self.storage = storage
+class ApplicationGetConfigResults(Type):
+ _toSchema = {'results': 'Results'}
+ _toPy = {'Results': 'results'}
+ def __init__(self, results=None, **unknown_fields):
+ '''
+ results : typing.Sequence[~ConfigResult]
+ '''
+ self.results = [ConfigResult.from_json(o) for o in results or []]
+
+
+
+class ApplicationGetConstraintsResults(Type):
+ _toSchema = {'results': 'results'}
+ _toPy = {'results': 'results'}
+ def __init__(self, results=None, **unknown_fields):
+ '''
+ results : typing.Sequence[~ApplicationConstraint]
+ '''
+ self.results = [ApplicationConstraint.from_json(o) for o in results or []]
+
+
+
class ApplicationGetResults(Type):
_toSchema = {'application': 'application', 'charm': 'charm', 'config': 'config', 'constraints': 'constraints', 'series': 'series'}
_toPy = {'application': 'application', 'charm': 'charm', 'config': 'config', 'constraints': 'constraints', 'series': 'series'}
'''
application : str
charm : str
- config : typing.Mapping<~KT, +VT_co>[str, typing.Any]
+ config : typing.Mapping[str, typing.Any]
constraints : Value
series : str
'''
def __init__(self, application=None, metrics_credentials=None, **unknown_fields):
'''
application : str
- metrics_credentials : typing.Sequence<+T_co>[int]
+ metrics_credentials : typing.Sequence[int]
'''
self.application = application
self.metrics_credentials = metrics_credentials
_toPy = {'creds': 'creds'}
def __init__(self, creds=None, **unknown_fields):
'''
- creds : typing.Sequence<+T_co>[~ApplicationMetricCredential]<~ApplicationMetricCredential>
+ creds : typing.Sequence[~ApplicationMetricCredential]
'''
self.creds = [ApplicationMetricCredential.from_json(o) for o in creds or []]
'''
access : str
application_description : str
- bindings : typing.Mapping<~KT, +VT_co>[str, str]
- endpoints : typing.Sequence<+T_co>[~RemoteEndpoint]<~RemoteEndpoint>
+ bindings : typing.Mapping[str, str]
+ endpoints : typing.Sequence[~RemoteEndpoint]
offer_name : str
offer_url : str
source_model_tag : str
- spaces : typing.Sequence<+T_co>[~RemoteSpace]<~RemoteSpace>
+ spaces : typing.Sequence[~RemoteSpace]
'''
self.access = access
self.application_description = application_description
+class ApplicationOfferAdminDetails(Type):
+ _toSchema = {'application_name': 'application-name', 'applicationofferdetails': 'ApplicationOfferDetails', 'charm_url': 'charm-url', 'connections': 'connections'}
+ _toPy = {'ApplicationOfferDetails': 'applicationofferdetails', 'application-name': 'application_name', 'charm-url': 'charm_url', 'connections': 'connections'}
+ def __init__(self, applicationofferdetails=None, application_name=None, charm_url=None, connections=None, **unknown_fields):
+ '''
+ applicationofferdetails : ApplicationOfferDetails
+ application_name : str
+ charm_url : str
+ connections : typing.Sequence[~OfferConnection]
+ '''
+ self.applicationofferdetails = ApplicationOfferDetails.from_json(applicationofferdetails) if applicationofferdetails else None
+ self.application_name = application_name
+ self.charm_url = charm_url
+ self.connections = [OfferConnection.from_json(o) for o in connections or []]
+
+
+
+class ApplicationOfferDetails(Type):
+ _toSchema = {'application_description': 'application-description', 'bindings': 'bindings', 'endpoints': 'endpoints', 'offer_name': 'offer-name', 'offer_url': 'offer-url', 'offer_uuid': 'offer-uuid', 'source_model_tag': 'source-model-tag', 'spaces': 'spaces', 'users': 'users'}
+ _toPy = {'application-description': 'application_description', 'bindings': 'bindings', 'endpoints': 'endpoints', 'offer-name': 'offer_name', 'offer-url': 'offer_url', 'offer-uuid': 'offer_uuid', 'source-model-tag': 'source_model_tag', 'spaces': 'spaces', 'users': 'users'}
+ def __init__(self, application_description=None, bindings=None, endpoints=None, offer_name=None, offer_url=None, offer_uuid=None, source_model_tag=None, spaces=None, users=None, **unknown_fields):
+ '''
+ application_description : str
+ bindings : typing.Mapping[str, str]
+ endpoints : typing.Sequence[~RemoteEndpoint]
+ offer_name : str
+ offer_url : str
+ offer_uuid : str
+ source_model_tag : str
+ spaces : typing.Sequence[~RemoteSpace]
+ users : typing.Sequence[~OfferUserDetails]
+ '''
+ self.application_description = application_description
+ self.bindings = bindings
+ self.endpoints = [RemoteEndpoint.from_json(o) for o in endpoints or []]
+ self.offer_name = offer_name
+ self.offer_url = offer_url
+ self.offer_uuid = offer_uuid
+ self.source_model_tag = source_model_tag
+ self.spaces = [RemoteSpace.from_json(o) for o in spaces or []]
+ self.users = [OfferUserDetails.from_json(o) for o in users or []]
+
+
+
+class ApplicationOfferResult(Type):
+ _toSchema = {'error': 'error', 'result': 'result'}
+ _toPy = {'error': 'error', 'result': 'result'}
+ def __init__(self, error=None, result=None, **unknown_fields):
+ '''
+ error : Error
+ result : ApplicationOfferAdminDetails
+ '''
+ self.error = Error.from_json(error) if error else None
+ self.result = ApplicationOfferAdminDetails.from_json(result) if result else None
+
+
+
+class ApplicationOfferStatus(Type):
+ _toSchema = {'active_connected_count': 'active-connected-count', 'application_name': 'application-name', 'charm': 'charm', 'endpoints': 'endpoints', 'err': 'err', 'offer_name': 'offer-name', 'total_connected_count': 'total-connected-count'}
+ _toPy = {'active-connected-count': 'active_connected_count', 'application-name': 'application_name', 'charm': 'charm', 'endpoints': 'endpoints', 'err': 'err', 'offer-name': 'offer_name', 'total-connected-count': 'total_connected_count'}
+ def __init__(self, active_connected_count=None, application_name=None, charm=None, endpoints=None, err=None, offer_name=None, total_connected_count=None, **unknown_fields):
+ '''
+ active_connected_count : int
+ application_name : str
+ charm : str
+ endpoints : typing.Mapping[str, ~RemoteEndpoint]
+ err : typing.Mapping[str, typing.Any]
+ offer_name : str
+ total_connected_count : int
+ '''
+ self.active_connected_count = active_connected_count
+ self.application_name = application_name
+ self.charm = charm
+ self.endpoints = endpoints
+ self.err = err
+ self.offer_name = offer_name
+ self.total_connected_count = total_connected_count
+
+
+
+class ApplicationOffersResults(Type):
+ _toSchema = {'results': 'results'}
+ _toPy = {'results': 'results'}
+ def __init__(self, results=None, **unknown_fields):
+ '''
+ results : typing.Sequence[~ApplicationOfferResult]
+ '''
+ self.results = [ApplicationOfferResult.from_json(o) for o in results or []]
+
+
+
class ApplicationRelationsChange(Type):
_toSchema = {'changed': 'changed', 'removed': 'removed'}
_toPy = {'changed': 'changed', 'removed': 'removed'}
def __init__(self, changed=None, removed=None, **unknown_fields):
'''
- changed : typing.Sequence<+T_co>[~RelationChange]<~RelationChange>
- removed : typing.Sequence<+T_co>[int]
+ changed : typing.Sequence[~RelationChange]
+ removed : typing.Sequence[int]
'''
self.changed = [RelationChange.from_json(o) for o in changed or []]
self.removed = removed
def __init__(self, application=None, options=None, **unknown_fields):
'''
application : str
- options : typing.Mapping<~KT, +VT_co>[str, str]
+ options : typing.Mapping[str, str]
'''
self.application = application
self.options = options
application : str
channel : str
charm_url : str
- config_settings : typing.Mapping<~KT, +VT_co>[str, str]
+ config_settings : typing.Mapping[str, str]
config_settings_yaml : str
force_series : bool
force_units : bool
- resource_ids : typing.Mapping<~KT, +VT_co>[str, str]
- storage_constraints : typing.Mapping<~KT, +VT_co>[str, ~StorageConstraints]<~StorageConstraints>
+ resource_ids : typing.Mapping[str, str]
+ storage_constraints : typing.Mapping[str, ~StorageConstraints]
'''
self.application = application
self.channel = channel
+class ApplicationSetCharmProfile(Type):
+ _toSchema = {'application': 'application', 'charm_url': 'charm-url'}
+ _toPy = {'application': 'application', 'charm-url': 'charm_url'}
+ def __init__(self, application=None, charm_url=None, **unknown_fields):
+ '''
+ application : str
+ charm_url : str
+ '''
+ self.application = application
+ self.charm_url = charm_url
+
+
+
class ApplicationStatus(Type):
_toSchema = {'can_upgrade_to': 'can-upgrade-to', 'charm': 'charm', 'err': 'err', 'exposed': 'exposed', 'life': 'life', 'meter_statuses': 'meter-statuses', 'relations': 'relations', 'series': 'series', 'status': 'status', 'subordinate_to': 'subordinate-to', 'units': 'units', 'workload_version': 'workload-version'}
_toPy = {'can-upgrade-to': 'can_upgrade_to', 'charm': 'charm', 'err': 'err', 'exposed': 'exposed', 'life': 'life', 'meter-statuses': 'meter_statuses', 'relations': 'relations', 'series': 'series', 'status': 'status', 'subordinate-to': 'subordinate_to', 'units': 'units', 'workload-version': 'workload_version'}
'''
can_upgrade_to : str
charm : str
- err : typing.Mapping<~KT, +VT_co>[str, typing.Any]
+ err : typing.Mapping[str, typing.Any]
exposed : bool
life : str
- meter_statuses : typing.Mapping<~KT, +VT_co>[str, ~MeterStatus]<~MeterStatus>
- relations : typing.Sequence<+T_co>[str]
+ meter_statuses : typing.Mapping[str, ~MeterStatus]
+ relations : typing.Sequence[str]
series : str
status : DetailedStatus
- subordinate_to : typing.Sequence<+T_co>[str]
- units : typing.Mapping<~KT, +VT_co>[str, ~UnitStatus]<~UnitStatus>
+ subordinate_to : typing.Sequence[str]
+ units : typing.Mapping[str, ~UnitStatus]
workload_version : str
'''
self.can_upgrade_to = can_upgrade_to
'''
application : StatusResult
error : Error
- units : typing.Mapping<~KT, +VT_co>[str, ~StatusResult]<~StatusResult>
+ units : typing.Mapping[str, ~StatusResult]
'''
self.application = StatusResult.from_json(application) if application else None
self.error = Error.from_json(error) if error else None
_toPy = {'results': 'results'}
def __init__(self, results=None, **unknown_fields):
'''
- results : typing.Sequence<+T_co>[~ApplicationStatusResult]<~ApplicationStatusResult>
+ results : typing.Sequence[~ApplicationStatusResult]
'''
self.results = [ApplicationStatusResult.from_json(o) for o in results or []]
_toPy = {'application-urls': 'application_urls'}
def __init__(self, application_urls=None, **unknown_fields):
'''
- application_urls : typing.Sequence<+T_co>[str]
+ application_urls : typing.Sequence[str]
'''
self.application_urls = application_urls
+class ApplicationUnitParams(Type):
+ _toSchema = {'address': 'address', 'data': 'data', 'filesystem_info': 'filesystem-info', 'info': 'info', 'ports': 'ports', 'provider_id': 'provider-id', 'status': 'status', 'unit_tag': 'unit-tag'}
+ _toPy = {'address': 'address', 'data': 'data', 'filesystem-info': 'filesystem_info', 'info': 'info', 'ports': 'ports', 'provider-id': 'provider_id', 'status': 'status', 'unit-tag': 'unit_tag'}
+ def __init__(self, address=None, data=None, filesystem_info=None, info=None, ports=None, provider_id=None, status=None, unit_tag=None, **unknown_fields):
+ '''
+ address : str
+ data : typing.Mapping[str, typing.Any]
+ filesystem_info : typing.Sequence[~KubernetesFilesystemInfo]
+ info : str
+ ports : typing.Sequence[str]
+ provider_id : str
+ status : str
+ unit_tag : str
+ '''
+ self.address = address
+ self.data = data
+ self.filesystem_info = [KubernetesFilesystemInfo.from_json(o) for o in filesystem_info or []]
+ self.info = info
+ self.ports = ports
+ self.provider_id = provider_id
+ self.status = status
+ self.unit_tag = unit_tag
+
+
+
class ApplicationUnset(Type):
_toSchema = {'application': 'application', 'options': 'options'}
_toPy = {'application': 'application', 'options': 'options'}
def __init__(self, application=None, options=None, **unknown_fields):
'''
application : str
- options : typing.Sequence<+T_co>[str]
+ options : typing.Sequence[str]
'''
self.application = application
self.options = options
force_charm_url : bool
force_series : bool
min_units : int
- settings : typing.Mapping<~KT, +VT_co>[str, str]
+ settings : typing.Mapping[str, str]
settings_yaml : str
'''
self.application = application
_toPy = {'results': 'results'}
def __init__(self, results=None, **unknown_fields):
'''
- results : typing.Sequence<+T_co>[~ApplicationCharmActionsResult]<~ApplicationCharmActionsResult>
+ results : typing.Sequence[~ApplicationCharmActionsResult]
'''
self.results = [ApplicationCharmActionsResult.from_json(o) for o in results or []]
_toPy = {'applications': 'applications'}
def __init__(self, applications=None, **unknown_fields):
'''
- applications : typing.Sequence<+T_co>[~ApplicationDeploy]<~ApplicationDeploy>
+ applications : typing.Sequence[~ApplicationDeploy]
'''
self.applications = [ApplicationDeploy.from_json(o) for o in applications or []]
_toPy = {'list': 'list_'}
def __init__(self, list_=None, **unknown_fields):
'''
- list_ : typing.Sequence<+T_co>[~BackupsMetadataResult]<~BackupsMetadataResult>
+ list_ : typing.Sequence[~BackupsMetadataResult]
'''
self.list_ = [BackupsMetadataResult.from_json(o) for o in list_ or []]
def __init__(self, busaddress=None, devicelinks=None, devicename=None, filesystemtype=None, hardwareid=None, inuse=None, label=None, mountpoint=None, size=None, uuid=None, **unknown_fields):
'''
busaddress : str
- devicelinks : typing.Sequence<+T_co>[str]
+ devicelinks : typing.Sequence[str]
devicename : str
filesystemtype : str
hardwareid : str
_toPy = {'results': 'results'}
def __init__(self, results=None, **unknown_fields):
'''
- results : typing.Sequence<+T_co>[~BlockDeviceResult]<~BlockDeviceResult>
+ results : typing.Sequence[~BlockDeviceResult]
'''
self.results = [BlockDeviceResult.from_json(o) for o in results or []]
_toPy = {'results': 'results'}
def __init__(self, results=None, **unknown_fields):
'''
- results : typing.Sequence<+T_co>[~BlockResult]<~BlockResult>
+ results : typing.Sequence[~BlockResult]
'''
self.results = [BlockResult.from_json(o) for o in results or []]
_toPy = {'results': 'results'}
def __init__(self, results=None, **unknown_fields):
'''
- results : typing.Sequence<+T_co>[~BoolResult]<~BoolResult>
+ results : typing.Sequence[~BoolResult]
'''
self.results = [BoolResult.from_json(o) for o in results or []]
+class BulkImportStorageParams(Type):
+ _toSchema = {'storage': 'storage'}
+ _toPy = {'storage': 'storage'}
+ def __init__(self, storage=None, **unknown_fields):
+ '''
+ storage : typing.Sequence[~ImportStorageParams]
+ '''
+ self.storage = [ImportStorageParams.from_json(o) for o in storage or []]
+
+
+
class BundleChange(Type):
_toSchema = {'args': 'args', 'id_': 'id', 'method': 'method', 'requires': 'requires'}
_toPy = {'args': 'args', 'id': 'id_', 'method': 'method', 'requires': 'requires'}
def __init__(self, args=None, id_=None, method=None, requires=None, **unknown_fields):
'''
- args : typing.Sequence<+T_co>[typing.Any]
+ args : typing.Sequence[typing.Any]
id_ : str
method : str
- requires : typing.Sequence<+T_co>[str]
+ requires : typing.Sequence[str]
'''
self.args = args
self.id_ = id_
_toPy = {'changes': 'changes', 'errors': 'errors'}
def __init__(self, changes=None, errors=None, **unknown_fields):
'''
- changes : typing.Sequence<+T_co>[~BundleChange]<~BundleChange>
- errors : typing.Sequence<+T_co>[str]
+ changes : typing.Sequence[~BundleChange]
+ errors : typing.Sequence[str]
'''
self.changes = [BundleChange.from_json(o) for o in changes or []]
self.errors = errors
_toPy = {'result': 'result'}
def __init__(self, result=None, **unknown_fields):
'''
- result : typing.Sequence<+T_co>[int]
+ result : typing.Sequence[int]
'''
self.result = result
+class ChangeModelCredentialParams(Type):
+ _toSchema = {'credential_tag': 'credential-tag', 'model_tag': 'model-tag'}
+ _toPy = {'credential-tag': 'credential_tag', 'model-tag': 'model_tag'}
+ def __init__(self, credential_tag=None, model_tag=None, **unknown_fields):
+ '''
+ credential_tag : str
+ model_tag : str
+ '''
+ self.credential_tag = credential_tag
+ self.model_tag = model_tag
+
+
+
+class ChangeModelCredentialsParams(Type):
+ _toSchema = {'model_credentials': 'model-credentials'}
+ _toPy = {'model-credentials': 'model_credentials'}
+ def __init__(self, model_credentials=None, **unknown_fields):
+ '''
+ model_credentials : typing.Sequence[~ChangeModelCredentialParams]
+ '''
+ self.model_credentials = [ChangeModelCredentialParams.from_json(o) for o in model_credentials or []]
+
+
+
class CharmActionSpec(Type):
_toSchema = {'description': 'description', 'params': 'params'}
_toPy = {'description': 'description', 'params': 'params'}
def __init__(self, description=None, params=None, **unknown_fields):
'''
description : str
- params : typing.Mapping<~KT, +VT_co>[str, typing.Any]
+ params : typing.Mapping[str, typing.Any]
'''
self.description = description
self.params = params
_toPy = {'specs': 'specs'}
def __init__(self, specs=None, **unknown_fields):
'''
- specs : typing.Mapping<~KT, +VT_co>[str, ~CharmActionSpec]<~CharmActionSpec>
+ specs : typing.Mapping[str, ~CharmActionSpec]
'''
self.specs = specs
+class CharmDevice(Type):
+ _toSchema = {'countmax': 'CountMax', 'countmin': 'CountMin', 'description': 'Description', 'name': 'Name', 'type_': 'Type'}
+ _toPy = {'CountMax': 'countmax', 'CountMin': 'countmin', 'Description': 'description', 'Name': 'name', 'Type': 'type_'}
+ def __init__(self, countmax=None, countmin=None, description=None, name=None, type_=None, **unknown_fields):
+ '''
+ countmax : int
+ countmin : int
+ description : str
+ name : str
+ type_ : str
+ '''
+ self.countmax = countmax
+ self.countmin = countmin
+ self.description = description
+ self.name = name
+ self.type_ = type_
+
+
+
class CharmInfo(Type):
_toSchema = {'actions': 'actions', 'config': 'config', 'meta': 'meta', 'metrics': 'metrics', 'revision': 'revision', 'url': 'url'}
_toPy = {'actions': 'actions', 'config': 'config', 'meta': 'meta', 'metrics': 'metrics', 'revision': 'revision', 'url': 'url'}
def __init__(self, actions=None, config=None, meta=None, metrics=None, revision=None, url=None, **unknown_fields):
'''
actions : CharmActions
- config : typing.Mapping<~KT, +VT_co>[str, ~CharmOption]<~CharmOption>
+ config : typing.Mapping[str, ~CharmOption]
meta : CharmMeta
metrics : CharmMetrics
revision : int
+class CharmLXDProfile(Type):
+ _toSchema = {'config': 'config', 'description': 'description', 'devices': 'devices'}
+ _toPy = {'config': 'config', 'description': 'description', 'devices': 'devices'}
+ def __init__(self, config=None, description=None, devices=None, **unknown_fields):
+ '''
+ config : typing.Mapping[str, str]
+ description : str
+ devices : typing.Mapping[str, typing.Any]
+ '''
+ self.config = config
+ self.description = description
+ self.devices = devices
+
+
+
class CharmMeta(Type):
_toSchema = {'categories': 'categories', 'description': 'description', 'extra_bindings': 'extra-bindings', 'min_juju_version': 'min-juju-version', 'name': 'name', 'payload_classes': 'payload-classes', 'peers': 'peers', 'provides': 'provides', 'requires': 'requires', 'resources': 'resources', 'series': 'series', 'storage': 'storage', 'subordinate': 'subordinate', 'summary': 'summary', 'tags': 'tags', 'terms': 'terms'}
_toPy = {'categories': 'categories', 'description': 'description', 'extra-bindings': 'extra_bindings', 'min-juju-version': 'min_juju_version', 'name': 'name', 'payload-classes': 'payload_classes', 'peers': 'peers', 'provides': 'provides', 'requires': 'requires', 'resources': 'resources', 'series': 'series', 'storage': 'storage', 'subordinate': 'subordinate', 'summary': 'summary', 'tags': 'tags', 'terms': 'terms'}
def __init__(self, categories=None, description=None, extra_bindings=None, min_juju_version=None, name=None, payload_classes=None, peers=None, provides=None, requires=None, resources=None, series=None, storage=None, subordinate=None, summary=None, tags=None, terms=None, **unknown_fields):
'''
- categories : typing.Sequence<+T_co>[str]
+ categories : typing.Sequence[str]
description : str
- extra_bindings : typing.Mapping<~KT, +VT_co>[str, str]
+ extra_bindings : typing.Mapping[str, str]
min_juju_version : str
name : str
- payload_classes : typing.Mapping<~KT, +VT_co>[str, ~CharmPayloadClass]<~CharmPayloadClass>
- peers : typing.Mapping<~KT, +VT_co>[str, ~CharmRelation]<~CharmRelation>
- provides : typing.Mapping<~KT, +VT_co>[str, ~CharmRelation]<~CharmRelation>
- requires : typing.Mapping<~KT, +VT_co>[str, ~CharmRelation]<~CharmRelation>
- resources : typing.Mapping<~KT, +VT_co>[str, ~CharmResourceMeta]<~CharmResourceMeta>
- series : typing.Sequence<+T_co>[str]
- storage : typing.Mapping<~KT, +VT_co>[str, ~CharmStorage]<~CharmStorage>
+ payload_classes : typing.Mapping[str, ~CharmPayloadClass]
+ peers : typing.Mapping[str, ~CharmRelation]
+ provides : typing.Mapping[str, ~CharmRelation]
+ requires : typing.Mapping[str, ~CharmRelation]
+ resources : typing.Mapping[str, ~CharmResourceMeta]
+ series : typing.Sequence[str]
+ storage : typing.Mapping[str, ~CharmStorage]
subordinate : bool
summary : str
- tags : typing.Sequence<+T_co>[str]
- terms : typing.Sequence<+T_co>[str]
+ tags : typing.Sequence[str]
+ terms : typing.Sequence[str]
'''
self.categories = categories
self.description = description
_toPy = {'metrics': 'metrics', 'plan': 'plan'}
def __init__(self, metrics=None, plan=None, **unknown_fields):
'''
- metrics : typing.Mapping<~KT, +VT_co>[str, ~CharmMetric]<~CharmMetric>
+ metrics : typing.Mapping[str, ~CharmMetric]
plan : CharmPlan
'''
self.metrics = metrics
_toPy = {'default': 'default', 'description': 'description', 'type': 'type_'}
def __init__(self, default=None, description=None, type_=None, **unknown_fields):
'''
- default : typing.Mapping<~KT, +VT_co>[str, typing.Any]
+ default : typing.Mapping[str, typing.Any]
description : str
type_ : str
'''
def __init__(self, description=None, fingerprint=None, name=None, origin=None, path=None, revision=None, size=None, type_=None, **unknown_fields):
'''
description : str
- fingerprint : typing.Sequence<+T_co>[int]
+ fingerprint : typing.Sequence[int]
name : str
origin : str
path : str
location : str
minimum_size : int
name : str
- properties : typing.Sequence<+T_co>[str]
+ properties : typing.Sequence[str]
read_only : bool
shared : bool
type_ : str
_toPy = {'urls': 'urls'}
def __init__(self, urls=None, **unknown_fields):
'''
- urls : typing.Sequence<+T_co>[~CharmURL]<~CharmURL>
+ urls : typing.Sequence[~CharmURL]
'''
self.urls = [CharmURL.from_json(o) for o in urls or []]
_toPy = {'names': 'names'}
def __init__(self, names=None, **unknown_fields):
'''
- names : typing.Sequence<+T_co>[str]
+ names : typing.Sequence[str]
'''
self.names = names
_toPy = {'charm-urls': 'charm_urls'}
def __init__(self, charm_urls=None, **unknown_fields):
'''
- charm_urls : typing.Sequence<+T_co>[str]
+ charm_urls : typing.Sequence[str]
'''
self.charm_urls = charm_urls
_toPy = {'params': 'params'}
def __init__(self, params=None, **unknown_fields):
'''
- params : typing.Sequence<+T_co>[~ClaimLeadershipParams]<~ClaimLeadershipParams>
+ params : typing.Sequence[~ClaimLeadershipParams]
'''
self.params = [ClaimLeadershipParams.from_json(o) for o in params or []]
_toPy = {'results': 'results'}
def __init__(self, results=None, **unknown_fields):
'''
- results : typing.Sequence<+T_co>[~ErrorResult]<~ErrorResult>
+ results : typing.Sequence[~ErrorResult]
'''
self.results = [ErrorResult.from_json(o) for o in results or []]
_toPy = {'auth-types': 'auth_types', 'endpoint': 'endpoint', 'identity-endpoint': 'identity_endpoint', 'regions': 'regions', 'storage-endpoint': 'storage_endpoint', 'type': 'type_'}
def __init__(self, auth_types=None, endpoint=None, identity_endpoint=None, regions=None, storage_endpoint=None, type_=None, **unknown_fields):
'''
- auth_types : typing.Sequence<+T_co>[str]
+ auth_types : typing.Sequence[str]
endpoint : str
identity_endpoint : str
- regions : typing.Sequence<+T_co>[~CloudRegion]<~CloudRegion>
+ regions : typing.Sequence[~CloudRegion]
storage_endpoint : str
type_ : str
'''
_toPy = {'attrs': 'attrs', 'auth-type': 'auth_type', 'redacted': 'redacted'}
def __init__(self, attrs=None, auth_type=None, redacted=None, **unknown_fields):
'''
- attrs : typing.Mapping<~KT, +VT_co>[str, str]
+ attrs : typing.Mapping[str, str]
auth_type : str
- redacted : typing.Sequence<+T_co>[str]
+ redacted : typing.Sequence[str]
'''
self.attrs = attrs
self.auth_type = auth_type
-class CloudCredentialResult(Type):
- _toSchema = {'error': 'error', 'result': 'result'}
- _toPy = {'error': 'error', 'result': 'result'}
+class CloudCredentialArg(Type):
+ _toSchema = {'cloud_name': 'cloud-name', 'credential_name': 'credential-name'}
+ _toPy = {'cloud-name': 'cloud_name', 'credential-name': 'credential_name'}
+ def __init__(self, cloud_name=None, credential_name=None, **unknown_fields):
+ '''
+ cloud_name : str
+ credential_name : str
+ '''
+ self.cloud_name = cloud_name
+ self.credential_name = credential_name
+
+
+
+class CloudCredentialArgs(Type):
+ _toSchema = {'credentials': 'credentials', 'include_secrets': 'include-secrets'}
+ _toPy = {'credentials': 'credentials', 'include-secrets': 'include_secrets'}
+ def __init__(self, credentials=None, include_secrets=None, **unknown_fields):
+ '''
+ credentials : typing.Sequence[~CloudCredentialArg]
+ include_secrets : bool
+ '''
+ self.credentials = [CloudCredentialArg.from_json(o) for o in credentials or []]
+ self.include_secrets = include_secrets
+
+
+
+class CloudCredentialResult(Type):
+ _toSchema = {'error': 'error', 'result': 'result'}
+ _toPy = {'error': 'error', 'result': 'result'}
def __init__(self, error=None, result=None, **unknown_fields):
'''
error : Error
_toPy = {'results': 'results'}
def __init__(self, results=None, **unknown_fields):
'''
- results : typing.Sequence<+T_co>[~CloudCredentialResult]<~CloudCredentialResult>
+ results : typing.Sequence[~CloudCredentialResult]
'''
self.results = [CloudCredentialResult.from_json(o) for o in results or []]
+class CloudDetails(Type):
+ _toSchema = {'auth_types': 'auth-types', 'endpoint': 'endpoint', 'identity_endpoint': 'identity-endpoint', 'regions': 'regions', 'storage_endpoint': 'storage-endpoint', 'type_': 'type'}
+ _toPy = {'auth-types': 'auth_types', 'endpoint': 'endpoint', 'identity-endpoint': 'identity_endpoint', 'regions': 'regions', 'storage-endpoint': 'storage_endpoint', 'type': 'type_'}
+ def __init__(self, auth_types=None, endpoint=None, identity_endpoint=None, regions=None, storage_endpoint=None, type_=None, **unknown_fields):
+ '''
+ auth_types : typing.Sequence[str]
+ endpoint : str
+ identity_endpoint : str
+ regions : typing.Sequence[~CloudRegion]
+ storage_endpoint : str
+ type_ : str
+ '''
+ self.auth_types = auth_types
+ self.endpoint = endpoint
+ self.identity_endpoint = identity_endpoint
+ self.regions = [CloudRegion.from_json(o) for o in regions or []]
+ self.storage_endpoint = storage_endpoint
+ self.type_ = type_
+
+
+
class CloudImageMetadata(Type):
_toSchema = {'arch': 'arch', 'image_id': 'image-id', 'priority': 'priority', 'region': 'region', 'root_storage_size': 'root-storage-size', 'root_storage_type': 'root-storage-type', 'series': 'series', 'source': 'source', 'stream': 'stream', 'version': 'version', 'virt_type': 'virt-type'}
_toPy = {'arch': 'arch', 'image-id': 'image_id', 'priority': 'priority', 'region': 'region', 'root-storage-size': 'root_storage_size', 'root-storage-type': 'root_storage_type', 'series': 'series', 'source': 'source', 'stream': 'stream', 'version': 'version', 'virt-type': 'virt_type'}
_toPy = {'metadata': 'metadata'}
def __init__(self, metadata=None, **unknown_fields):
'''
- metadata : typing.Sequence<+T_co>[~CloudImageMetadata]<~CloudImageMetadata>
+ metadata : typing.Sequence[~CloudImageMetadata]
'''
self.metadata = [CloudImageMetadata.from_json(o) for o in metadata or []]
+class CloudInfo(Type):
+ _toSchema = {'clouddetails': 'CloudDetails', 'users': 'users'}
+ _toPy = {'CloudDetails': 'clouddetails', 'users': 'users'}
+ def __init__(self, clouddetails=None, users=None, **unknown_fields):
+ '''
+ clouddetails : CloudDetails
+ users : typing.Sequence[~CloudUserInfo]
+ '''
+ self.clouddetails = CloudDetails.from_json(clouddetails) if clouddetails else None
+ self.users = [CloudUserInfo.from_json(o) for o in users or []]
+
+
+
+class CloudInfoResult(Type):
+ _toSchema = {'error': 'error', 'result': 'result'}
+ _toPy = {'error': 'error', 'result': 'result'}
+ def __init__(self, error=None, result=None, **unknown_fields):
+ '''
+ error : Error
+ result : CloudInfo
+ '''
+ self.error = Error.from_json(error) if error else None
+ self.result = CloudInfo.from_json(result) if result else None
+
+
+
+class CloudInfoResults(Type):
+ _toSchema = {'results': 'results'}
+ _toPy = {'results': 'results'}
+ def __init__(self, results=None, **unknown_fields):
+ '''
+ results : typing.Sequence[~CloudInfoResult]
+ '''
+ self.results = [CloudInfoResult.from_json(o) for o in results or []]
+
+
+
class CloudInstanceTypesConstraint(Type):
_toSchema = {'cloud_tag': 'cloud-tag', 'constraints': 'constraints', 'region': 'region'}
_toPy = {'cloud-tag': 'cloud_tag', 'constraints': 'constraints', 'region': 'region'}
_toPy = {'constraints': 'constraints'}
def __init__(self, constraints=None, **unknown_fields):
'''
- constraints : typing.Sequence<+T_co>[~CloudInstanceTypesConstraint]<~CloudInstanceTypesConstraint>
+ constraints : typing.Sequence[~CloudInstanceTypesConstraint]
'''
self.constraints = [CloudInstanceTypesConstraint.from_json(o) for o in constraints or []]
_toPy = {'results': 'results'}
def __init__(self, results=None, **unknown_fields):
'''
- results : typing.Sequence<+T_co>[~CloudResult]<~CloudResult>
+ results : typing.Sequence[~CloudResult]
'''
self.results = [CloudResult.from_json(o) for o in results or []]
_toPy = {'results': 'results'}
def __init__(self, results=None, **unknown_fields):
'''
- results : typing.Sequence<+T_co>[~CloudSpecResult]<~CloudSpecResult>
+ results : typing.Sequence[~CloudSpecResult]
'''
self.results = [CloudSpecResult.from_json(o) for o in results or []]
+class CloudUserInfo(Type):
+ _toSchema = {'access': 'access', 'display_name': 'display-name', 'user': 'user'}
+ _toPy = {'access': 'access', 'display-name': 'display_name', 'user': 'user'}
+ def __init__(self, access=None, display_name=None, user=None, **unknown_fields):
+ '''
+ access : str
+ display_name : str
+ user : str
+ '''
+ self.access = access
+ self.display_name = display_name
+ self.user = user
+
+
+
class CloudsResult(Type):
_toSchema = {'clouds': 'clouds'}
_toPy = {'clouds': 'clouds'}
def __init__(self, clouds=None, **unknown_fields):
'''
- clouds : typing.Mapping<~KT, +VT_co>[str, ~Cloud]<~Cloud>
+ clouds : typing.Mapping[str, ~Cloud]
'''
self.clouds = clouds
+class ConfigResult(Type):
+ _toSchema = {'config': 'config', 'error': 'error'}
+ _toPy = {'config': 'config', 'error': 'error'}
+ def __init__(self, config=None, error=None, **unknown_fields):
+ '''
+ config : typing.Mapping[str, typing.Any]
+ error : Error
+ '''
+ self.config = config
+ self.error = Error.from_json(error) if error else None
+
+
+
class ConfigSettingsResult(Type):
_toSchema = {'error': 'error', 'settings': 'settings'}
_toPy = {'error': 'error', 'settings': 'settings'}
def __init__(self, error=None, settings=None, **unknown_fields):
'''
error : Error
- settings : typing.Mapping<~KT, +VT_co>[str, typing.Any]
+ settings : typing.Mapping[str, typing.Any]
'''
self.error = Error.from_json(error) if error else None
self.settings = settings
_toPy = {'results': 'results'}
def __init__(self, results=None, **unknown_fields):
'''
- results : typing.Sequence<+T_co>[~ConfigSettingsResult]<~ConfigSettingsResult>
+ results : typing.Sequence[~ConfigSettingsResult]
'''
self.results = [ConfigSettingsResult.from_json(o) for o in results or []]
def __init__(self, source=None, value=None, **unknown_fields):
'''
source : str
- value : typing.Mapping<~KT, +VT_co>[str, typing.Any]
+ value : typing.Mapping[str, typing.Any]
'''
self.source = source
self.value = value
_toPy = {'results': 'results'}
def __init__(self, results=None, **unknown_fields):
'''
- results : typing.Sequence<+T_co>[~ConstraintsResult]<~ConstraintsResult>
+ results : typing.Sequence[~ConstraintsResult]
'''
self.results = [ConstraintsResult.from_json(o) for o in results or []]
_toPy = {'args': 'args'}
def __init__(self, args=None, **unknown_fields):
'''
- args : typing.Sequence<+T_co>[~ConsumeApplicationArg]<~ConsumeApplicationArg>
+ args : typing.Sequence[~ConsumeApplicationArg]
'''
self.args = [ConsumeApplicationArg.from_json(o) for o in args or []]
_toPy = {'results': 'results'}
def __init__(self, results=None, **unknown_fields):
'''
- results : typing.Sequence<+T_co>[~ConsumeApplicationResult]<~ConsumeApplicationResult>
+ results : typing.Sequence[~ConsumeApplicationResult]
'''
self.results = [ConsumeApplicationResult.from_json(o) for o in results or []]
+class ConsumeOfferDetails(Type):
+ _toSchema = {'external_controller': 'external-controller', 'macaroon': 'macaroon', 'offer': 'offer'}
+ _toPy = {'external-controller': 'external_controller', 'macaroon': 'macaroon', 'offer': 'offer'}
+ def __init__(self, external_controller=None, macaroon=None, offer=None, **unknown_fields):
+ '''
+ external_controller : ExternalControllerInfo
+ macaroon : Macaroon
+ offer : ApplicationOfferDetails
+ '''
+ self.external_controller = ExternalControllerInfo.from_json(external_controller) if external_controller else None
+ self.macaroon = Macaroon.from_json(macaroon) if macaroon else None
+ self.offer = ApplicationOfferDetails.from_json(offer) if offer else None
+
+
+
+class ConsumeOfferDetailsResult(Type):
+ _toSchema = {'consumeofferdetails': 'ConsumeOfferDetails', 'error': 'error'}
+ _toPy = {'ConsumeOfferDetails': 'consumeofferdetails', 'error': 'error'}
+ def __init__(self, consumeofferdetails=None, error=None, **unknown_fields):
+ '''
+ consumeofferdetails : ConsumeOfferDetails
+ error : Error
+ '''
+ self.consumeofferdetails = ConsumeOfferDetails.from_json(consumeofferdetails) if consumeofferdetails else None
+ self.error = Error.from_json(error) if error else None
+
+
+
+class ConsumeOfferDetailsResults(Type):
+ _toSchema = {'results': 'results'}
+ _toPy = {'results': 'results'}
+ def __init__(self, results=None, **unknown_fields):
+ '''
+ results : typing.Sequence[~ConsumeOfferDetailsResult]
+ '''
+ self.results = [ConsumeOfferDetailsResult.from_json(o) for o in results or []]
+
+
+
class ContainerConfig(Type):
_toSchema = {'apt_mirror': 'apt-mirror', 'apt_proxy': 'apt-proxy', 'authorized_keys': 'authorized-keys', 'provider_type': 'provider-type', 'proxy': 'proxy', 'ssl_hostname_verification': 'ssl-hostname-verification', 'updatebehavior': 'UpdateBehavior'}
_toPy = {'UpdateBehavior': 'updatebehavior', 'apt-mirror': 'apt_mirror', 'apt-proxy': 'apt_proxy', 'authorized-keys': 'authorized_keys', 'provider-type': 'provider_type', 'proxy': 'proxy', 'ssl-hostname-verification': 'ssl_hostname_verification'}
+class ContainerLXDProfile(Type):
+ _toSchema = {'name': 'name', 'profile': 'profile'}
+ _toPy = {'name': 'name', 'profile': 'profile'}
+ def __init__(self, name=None, profile=None, **unknown_fields):
+ '''
+ name : str
+ profile : CharmLXDProfile
+ '''
+ self.name = name
+ self.profile = CharmLXDProfile.from_json(profile) if profile else None
+
+
+
class ContainerManagerConfig(Type):
_toSchema = {'config': 'config'}
_toPy = {'config': 'config'}
def __init__(self, config=None, **unknown_fields):
'''
- config : typing.Mapping<~KT, +VT_co>[str, str]
+ config : typing.Mapping[str, str]
'''
self.config = config
+class ContainerProfileResult(Type):
+ _toSchema = {'error': 'error', 'lxd_profiles': 'lxd-profiles'}
+ _toPy = {'error': 'error', 'lxd-profiles': 'lxd_profiles'}
+ def __init__(self, error=None, lxd_profiles=None, **unknown_fields):
+ '''
+ error : Error
+ lxd_profiles : typing.Sequence[~ContainerLXDProfile]
+ '''
+ self.error = Error.from_json(error) if error else None
+ self.lxd_profiles = [ContainerLXDProfile.from_json(o) for o in lxd_profiles or []]
+
+
+
+class ContainerProfileResults(Type):
+ _toSchema = {'results': 'results'}
+ _toPy = {'results': 'results'}
+ def __init__(self, results=None, **unknown_fields):
+ '''
+ results : typing.Sequence[~ContainerProfileResult]
+ '''
+ self.results = [ContainerProfileResult.from_json(o) for o in results or []]
+
+
+
+class ControllerAPIInfoResult(Type):
+ _toSchema = {'addresses': 'addresses', 'cacert': 'cacert', 'error': 'error'}
+ _toPy = {'addresses': 'addresses', 'cacert': 'cacert', 'error': 'error'}
+ def __init__(self, addresses=None, cacert=None, error=None, **unknown_fields):
+ '''
+ addresses : typing.Sequence[str]
+ cacert : str
+ error : Error
+ '''
+ self.addresses = addresses
+ self.cacert = cacert
+ self.error = Error.from_json(error) if error else None
+
+
+
+class ControllerAPIInfoResults(Type):
+ _toSchema = {'results': 'results'}
+ _toPy = {'results': 'results'}
+ def __init__(self, results=None, **unknown_fields):
+ '''
+ results : typing.Sequence[~ControllerAPIInfoResult]
+ '''
+ self.results = [ControllerAPIInfoResult.from_json(o) for o in results or []]
+
+
+
class ControllerConfigResult(Type):
_toSchema = {'config': 'config'}
_toPy = {'config': 'config'}
def __init__(self, config=None, **unknown_fields):
'''
- config : typing.Mapping<~KT, +VT_co>[str, typing.Any]
+ config : typing.Mapping[str, typing.Any]
+ '''
+ self.config = config
+
+
+
+class ControllerConfigSet(Type):
+ _toSchema = {'config': 'config'}
+ _toPy = {'config': 'config'}
+ def __init__(self, config=None, **unknown_fields):
+ '''
+ config : typing.Mapping[str, typing.Any]
'''
self.config = config
+class ControllerCredentialInfo(Type):
+ _toSchema = {'content': 'content', 'models': 'models'}
+ _toPy = {'content': 'content', 'models': 'models'}
+ def __init__(self, content=None, models=None, **unknown_fields):
+ '''
+ content : CredentialContent
+ models : typing.Sequence[~ModelAccess]
+ '''
+ self.content = CredentialContent.from_json(content) if content else None
+ self.models = [ModelAccess.from_json(o) for o in models or []]
+
+
+
class ControllersChangeResult(Type):
_toSchema = {'error': 'error', 'result': 'result'}
_toPy = {'error': 'error', 'result': 'result'}
_toPy = {'results': 'results'}
def __init__(self, results=None, **unknown_fields):
'''
- results : typing.Sequence<+T_co>[~ControllersChangeResult]<~ControllersChangeResult>
+ results : typing.Sequence[~ControllersChangeResult]
'''
self.results = [ControllersChangeResult.from_json(o) for o in results or []]
_toPy = {'added': 'added', 'converted': 'converted', 'demoted': 'demoted', 'maintained': 'maintained', 'promoted': 'promoted', 'removed': 'removed'}
def __init__(self, added=None, converted=None, demoted=None, maintained=None, promoted=None, removed=None, **unknown_fields):
'''
- added : typing.Sequence<+T_co>[str]
- converted : typing.Sequence<+T_co>[str]
- demoted : typing.Sequence<+T_co>[str]
- maintained : typing.Sequence<+T_co>[str]
- promoted : typing.Sequence<+T_co>[str]
- removed : typing.Sequence<+T_co>[str]
+ added : typing.Sequence[str]
+ converted : typing.Sequence[str]
+ demoted : typing.Sequence[str]
+ maintained : typing.Sequence[str]
+ promoted : typing.Sequence[str]
+ removed : typing.Sequence[str]
'''
self.added = added
self.converted = converted
'''
constraints : Value
num_controllers : int
- placement : typing.Sequence<+T_co>[str]
+ placement : typing.Sequence[str]
series : str
'''
self.constraints = Value.from_json(constraints) if constraints else None
_toPy = {'specs': 'specs'}
def __init__(self, specs=None, **unknown_fields):
'''
- specs : typing.Sequence<+T_co>[~ControllersSpec]<~ControllersSpec>
+ specs : typing.Sequence[~ControllersSpec]
'''
self.specs = [ControllersSpec.from_json(o) for o in specs or []]
provider_id : str
public : bool
space_tag : str
- subnet_tags : typing.Sequence<+T_co>[str]
+ subnet_tags : typing.Sequence[str]
'''
self.provider_id = provider_id
self.public = public
_toPy = {'spaces': 'spaces'}
def __init__(self, spaces=None, **unknown_fields):
'''
- spaces : typing.Sequence<+T_co>[~CreateSpaceParams]<~CreateSpaceParams>
+ spaces : typing.Sequence[~CreateSpaceParams]
'''
self.spaces = [CreateSpaceParams.from_json(o) for o in spaces or []]
+class CredentialContent(Type):
+ _toSchema = {'attrs': 'attrs', 'auth_type': 'auth-type', 'cloud': 'cloud', 'name': 'name'}
+ _toPy = {'attrs': 'attrs', 'auth-type': 'auth_type', 'cloud': 'cloud', 'name': 'name'}
+ def __init__(self, attrs=None, auth_type=None, cloud=None, name=None, **unknown_fields):
+ '''
+ attrs : typing.Mapping[str, str]
+ auth_type : str
+ cloud : str
+ name : str
+ '''
+ self.attrs = attrs
+ self.auth_type = auth_type
+ self.cloud = cloud
+ self.name = name
+
+
+
+class CredentialContentResult(Type):
+ _toSchema = {'error': 'error', 'result': 'result'}
+ _toPy = {'error': 'error', 'result': 'result'}
+ def __init__(self, error=None, result=None, **unknown_fields):
+ '''
+ error : Error
+ result : ControllerCredentialInfo
+ '''
+ self.error = Error.from_json(error) if error else None
+ self.result = ControllerCredentialInfo.from_json(result) if result else None
+
+
+
+class CredentialContentResults(Type):
+ _toSchema = {'results': 'results'}
+ _toPy = {'results': 'results'}
+ def __init__(self, results=None, **unknown_fields):
+ '''
+ results : typing.Sequence[~CredentialContentResult]
+ '''
+ self.results = [CredentialContentResult.from_json(o) for o in results or []]
+
+
+
class Delta(Type):
_toSchema = {'entity': 'entity', 'removed': 'removed'}
_toPy = {'entity': 'entity', 'removed': 'removed'}
def __init__(self, entity=None, removed=None, **unknown_fields):
'''
- entity : typing.Mapping<~KT, +VT_co>[str, typing.Any]
+ entity : typing.Mapping[str, typing.Any]
removed : bool
'''
self.entity = entity
_toPy = {'api-addresses': 'api_addresses', 'state-addresses': 'state_addresses'}
def __init__(self, api_addresses=None, state_addresses=None, **unknown_fields):
'''
- api_addresses : typing.Sequence<+T_co>[str]
- state_addresses : typing.Sequence<+T_co>[str]
+ api_addresses : typing.Sequence[str]
+ state_addresses : typing.Sequence[str]
'''
self.api_addresses = api_addresses
self.state_addresses = state_addresses
_toPy = {'destroyed-storage': 'destroyed_storage', 'destroyed-units': 'destroyed_units', 'detached-storage': 'detached_storage'}
def __init__(self, destroyed_storage=None, destroyed_units=None, detached_storage=None, **unknown_fields):
'''
- destroyed_storage : typing.Sequence<+T_co>[~Entity]<~Entity>
- destroyed_units : typing.Sequence<+T_co>[~Entity]<~Entity>
- detached_storage : typing.Sequence<+T_co>[~Entity]<~Entity>
+ destroyed_storage : typing.Sequence[~Entity]
+ destroyed_units : typing.Sequence[~Entity]
+ detached_storage : typing.Sequence[~Entity]
'''
self.destroyed_storage = [Entity.from_json(o) for o in destroyed_storage or []]
self.destroyed_units = [Entity.from_json(o) for o in destroyed_units or []]
+class DestroyApplicationOffers(Type):
+ _toSchema = {'force': 'force', 'offer_urls': 'offer-urls'}
+ _toPy = {'force': 'force', 'offer-urls': 'offer_urls'}
+ def __init__(self, force=None, offer_urls=None, **unknown_fields):
+ '''
+ force : bool
+ offer_urls : typing.Sequence[str]
+ '''
+ self.force = force
+ self.offer_urls = offer_urls
+
+
+
+class DestroyApplicationParams(Type):
+ _toSchema = {'application_tag': 'application-tag', 'destroy_storage': 'destroy-storage'}
+ _toPy = {'application-tag': 'application_tag', 'destroy-storage': 'destroy_storage'}
+ def __init__(self, application_tag=None, destroy_storage=None, **unknown_fields):
+ '''
+ application_tag : str
+ destroy_storage : bool
+ '''
+ self.application_tag = application_tag
+ self.destroy_storage = destroy_storage
+
+
+
class DestroyApplicationResult(Type):
_toSchema = {'error': 'error', 'info': 'info'}
_toPy = {'error': 'error', 'info': 'info'}
_toPy = {'results': 'results'}
def __init__(self, results=None, **unknown_fields):
'''
- results : typing.Sequence<+T_co>[~DestroyApplicationResult]<~DestroyApplicationResult>
+ results : typing.Sequence[~DestroyApplicationResult]
'''
self.results = [DestroyApplicationResult.from_json(o) for o in results or []]
_toPy = {'unit-names': 'unit_names'}
def __init__(self, unit_names=None, **unknown_fields):
'''
- unit_names : typing.Sequence<+T_co>[str]
+ unit_names : typing.Sequence[str]
'''
self.unit_names = unit_names
+class DestroyApplicationsParams(Type):
+ _toSchema = {'applications': 'applications'}
+ _toPy = {'applications': 'applications'}
+ def __init__(self, applications=None, **unknown_fields):
+ '''
+ applications : typing.Sequence[~DestroyApplicationParams]
+ '''
+ self.applications = [DestroyApplicationParams.from_json(o) for o in applications or []]
+
+
+
+class DestroyConsumedApplicationParams(Type):
+ _toSchema = {'application_tag': 'application-tag'}
+ _toPy = {'application-tag': 'application_tag'}
+ def __init__(self, application_tag=None, **unknown_fields):
+ '''
+ application_tag : str
+ '''
+ self.application_tag = application_tag
+
+
+
+class DestroyConsumedApplicationsParams(Type):
+ _toSchema = {'applications': 'applications'}
+ _toPy = {'applications': 'applications'}
+ def __init__(self, applications=None, **unknown_fields):
+ '''
+ applications : typing.Sequence[~DestroyConsumedApplicationParams]
+ '''
+ self.applications = [DestroyConsumedApplicationParams.from_json(o) for o in applications or []]
+
+
+
class DestroyControllerArgs(Type):
_toSchema = {'destroy_models': 'destroy-models'}
_toPy = {'destroy-models': 'destroy_models'}
_toPy = {'destroyed-storage': 'destroyed_storage', 'destroyed-units': 'destroyed_units', 'detached-storage': 'detached_storage'}
def __init__(self, destroyed_storage=None, destroyed_units=None, detached_storage=None, **unknown_fields):
'''
- destroyed_storage : typing.Sequence<+T_co>[~Entity]<~Entity>
- destroyed_units : typing.Sequence<+T_co>[~Entity]<~Entity>
- detached_storage : typing.Sequence<+T_co>[~Entity]<~Entity>
+ destroyed_storage : typing.Sequence[~Entity]
+ destroyed_units : typing.Sequence[~Entity]
+ detached_storage : typing.Sequence[~Entity]
'''
self.destroyed_storage = [Entity.from_json(o) for o in destroyed_storage or []]
self.destroyed_units = [Entity.from_json(o) for o in destroyed_units or []]
_toPy = {'results': 'results'}
def __init__(self, results=None, **unknown_fields):
'''
- results : typing.Sequence<+T_co>[~DestroyMachineResult]<~DestroyMachineResult>
+ results : typing.Sequence[~DestroyMachineResult]
'''
self.results = [DestroyMachineResult.from_json(o) for o in results or []]
def __init__(self, force=None, machine_names=None, **unknown_fields):
'''
force : bool
- machine_names : typing.Sequence<+T_co>[str]
+ machine_names : typing.Sequence[str]
'''
self.force = force
self.machine_names = machine_names
+class DestroyMachinesParams(Type):
+ _toSchema = {'force': 'force', 'keep': 'keep', 'machine_tags': 'machine-tags'}
+ _toPy = {'force': 'force', 'keep': 'keep', 'machine-tags': 'machine_tags'}
+ def __init__(self, force=None, keep=None, machine_tags=None, **unknown_fields):
+ '''
+ force : bool
+ keep : bool
+ machine_tags : typing.Sequence[str]
+ '''
+ self.force = force
+ self.keep = keep
+ self.machine_tags = machine_tags
+
+
+
+class DestroyModelParams(Type):
+ _toSchema = {'destroy_storage': 'destroy-storage', 'model_tag': 'model-tag'}
+ _toPy = {'destroy-storage': 'destroy_storage', 'model-tag': 'model_tag'}
+ def __init__(self, destroy_storage=None, model_tag=None, **unknown_fields):
+ '''
+ destroy_storage : bool
+ model_tag : str
+ '''
+ self.destroy_storage = destroy_storage
+ self.model_tag = model_tag
+
+
+
+class DestroyModelsParams(Type):
+ _toSchema = {'models': 'models'}
+ _toPy = {'models': 'models'}
+ def __init__(self, models=None, **unknown_fields):
+ '''
+ models : typing.Sequence[~DestroyModelParams]
+ '''
+ self.models = [DestroyModelParams.from_json(o) for o in models or []]
+
+
+
class DestroyRelation(Type):
_toSchema = {'endpoints': 'endpoints'}
_toPy = {'endpoints': 'endpoints'}
def __init__(self, endpoints=None, **unknown_fields):
'''
- endpoints : typing.Sequence<+T_co>[str]
+ endpoints : typing.Sequence[str]
'''
self.endpoints = endpoints
_toPy = {'destroyed-storage': 'destroyed_storage', 'detached-storage': 'detached_storage'}
def __init__(self, destroyed_storage=None, detached_storage=None, **unknown_fields):
'''
- destroyed_storage : typing.Sequence<+T_co>[~Entity]<~Entity>
- detached_storage : typing.Sequence<+T_co>[~Entity]<~Entity>
+ destroyed_storage : typing.Sequence[~Entity]
+ detached_storage : typing.Sequence[~Entity]
'''
self.destroyed_storage = [Entity.from_json(o) for o in destroyed_storage or []]
self.detached_storage = [Entity.from_json(o) for o in detached_storage or []]
+class DestroyUnitParams(Type):
+ _toSchema = {'destroy_storage': 'destroy-storage', 'unit_tag': 'unit-tag'}
+ _toPy = {'destroy-storage': 'destroy_storage', 'unit-tag': 'unit_tag'}
+ def __init__(self, destroy_storage=None, unit_tag=None, **unknown_fields):
+ '''
+ destroy_storage : bool
+ unit_tag : str
+ '''
+ self.destroy_storage = destroy_storage
+ self.unit_tag = unit_tag
+
+
+
class DestroyUnitResult(Type):
_toSchema = {'error': 'error', 'info': 'info'}
_toPy = {'error': 'error', 'info': 'info'}
_toPy = {'results': 'results'}
def __init__(self, results=None, **unknown_fields):
'''
- results : typing.Sequence<+T_co>[~DestroyUnitResult]<~DestroyUnitResult>
+ results : typing.Sequence[~DestroyUnitResult]
'''
self.results = [DestroyUnitResult.from_json(o) for o in results or []]
+class DestroyUnitsParams(Type):
+ _toSchema = {'units': 'units'}
+ _toPy = {'units': 'units'}
+ def __init__(self, units=None, **unknown_fields):
+ '''
+ units : typing.Sequence[~DestroyUnitParams]
+ '''
+ self.units = [DestroyUnitParams.from_json(o) for o in units or []]
+
+
+
class DetailedStatus(Type):
_toSchema = {'data': 'data', 'err': 'err', 'info': 'info', 'kind': 'kind', 'life': 'life', 'since': 'since', 'status': 'status', 'version': 'version'}
_toPy = {'data': 'data', 'err': 'err', 'info': 'info', 'kind': 'kind', 'life': 'life', 'since': 'since', 'status': 'status', 'version': 'version'}
def __init__(self, data=None, err=None, info=None, kind=None, life=None, since=None, status=None, version=None, **unknown_fields):
'''
- data : typing.Mapping<~KT, +VT_co>[str, typing.Any]
- err : typing.Mapping<~KT, +VT_co>[str, typing.Any]
+ data : typing.Mapping[str, typing.Any]
+ err : typing.Mapping[str, typing.Any]
info : str
kind : str
life : str
_toPy = {'results': 'results'}
def __init__(self, results=None, **unknown_fields):
'''
- results : typing.Sequence<+T_co>[~ProviderSpace]<~ProviderSpace>
+ results : typing.Sequence[~ProviderSpace]
'''
self.results = [ProviderSpace.from_json(o) for o in results or []]
def __init__(self, error=None, result=None, **unknown_fields):
'''
error : Error
- result : typing.Sequence<+T_co>[str]
+ result : typing.Sequence[str]
'''
self.error = Error.from_json(error) if error else None
self.result = result
_toPy = {'results': 'results'}
def __init__(self, results=None, **unknown_fields):
'''
- results : typing.Sequence<+T_co>[~DistributionGroupResult]<~DistributionGroupResult>
+ results : typing.Sequence[~DistributionGroupResult]
'''
self.results = [DistributionGroupResult.from_json(o) for o in results or []]
_toPy = {'entities': 'entities', 'simplified': 'simplified'}
def __init__(self, entities=None, simplified=None, **unknown_fields):
'''
- entities : typing.Sequence<+T_co>[~Entity]<~Entity>
+ entities : typing.Sequence[~Entity]
simplified : bool
'''
self.entities = [Entity.from_json(o) for o in entities or []]
-class EndpointStatus(Type):
- _toSchema = {'application': 'application', 'name': 'name', 'role': 'role', 'subordinate': 'subordinate'}
- _toPy = {'application': 'application', 'name': 'name', 'role': 'role', 'subordinate': 'subordinate'}
- def __init__(self, application=None, name=None, role=None, subordinate=None, **unknown_fields):
+class EndpointFilterAttributes(Type):
+ _toSchema = {'interface': 'interface', 'name': 'name', 'role': 'role'}
+ _toPy = {'interface': 'interface', 'name': 'name', 'role': 'role'}
+ def __init__(self, interface=None, name=None, role=None, **unknown_fields):
'''
- application : str
+ interface : str
name : str
role : str
- subordinate : bool
+ '''
+ self.interface = interface
+ self.name = name
+ self.role = role
+
+
+
+class EndpointStatus(Type):
+ _toSchema = {'application': 'application', 'name': 'name', 'role': 'role', 'subordinate': 'subordinate'}
+ _toPy = {'application': 'application', 'name': 'name', 'role': 'role', 'subordinate': 'subordinate'}
+ def __init__(self, application=None, name=None, role=None, subordinate=None, **unknown_fields):
+ '''
+ application : str
+ name : str
+ role : str
+ subordinate : bool
'''
self.application = application
self.name = name
_toPy = {'entities': 'entities'}
def __init__(self, entities=None, **unknown_fields):
'''
- entities : typing.Sequence<+T_co>[~Entity]<~Entity>
+ entities : typing.Sequence[~Entity]
'''
self.entities = [Entity.from_json(o) for o in entities or []]
_toPy = {'entities': 'entities'}
def __init__(self, entities=None, **unknown_fields):
'''
- entities : typing.Sequence<+T_co>[~EntityCharmURL]<~EntityCharmURL>
+ entities : typing.Sequence[~EntityCharmURL]
'''
self.entities = [EntityCharmURL.from_json(o) for o in entities or []]
_toPy = {'entities': 'entities'}
def __init__(self, entities=None, **unknown_fields):
'''
- entities : typing.Sequence<+T_co>[~EntityPortRange]<~EntityPortRange>
+ entities : typing.Sequence[~EntityPortRange]
'''
self.entities = [EntityPortRange.from_json(o) for o in entities or []]
_toPy = {'entities': 'entities', 'error': 'error'}
def __init__(self, entities=None, error=None, **unknown_fields):
'''
- entities : typing.Sequence<+T_co>[~Entity]<~Entity>
+ entities : typing.Sequence[~Entity]
error : Error
'''
self.entities = [Entity.from_json(o) for o in entities or []]
_toPy = {'results': 'results'}
def __init__(self, results=None, **unknown_fields):
'''
- results : typing.Sequence<+T_co>[~EntitiesResult]<~EntitiesResult>
+ results : typing.Sequence[~EntitiesResult]
'''
self.results = [EntitiesResult.from_json(o) for o in results or []]
_toPy = {'agent-tools': 'agent_tools'}
def __init__(self, agent_tools=None, **unknown_fields):
'''
- agent_tools : typing.Sequence<+T_co>[~EntityVersion]<~EntityVersion>
+ agent_tools : typing.Sequence[~EntityVersion]
'''
self.agent_tools = [EntityVersion.from_json(o) for o in agent_tools or []]
_toPy = {'changes': 'changes', 'error': 'error', 'watcher-id': 'watcher_id'}
def __init__(self, changes=None, error=None, watcher_id=None, **unknown_fields):
'''
- changes : typing.Sequence<+T_co>[str]
+ changes : typing.Sequence[str]
error : Error
watcher_id : str
'''
_toPy = {'annotations': 'annotations', 'entity': 'entity'}
def __init__(self, annotations=None, entity=None, **unknown_fields):
'''
- annotations : typing.Mapping<~KT, +VT_co>[str, str]
+ annotations : typing.Mapping[str, str]
entity : str
'''
self.annotations = annotations
+class EntityMacaroonArg(Type):
+ _toSchema = {'macaroon': 'macaroon', 'tag': 'tag'}
+ _toPy = {'macaroon': 'macaroon', 'tag': 'tag'}
+ def __init__(self, macaroon=None, tag=None, **unknown_fields):
+ '''
+ macaroon : Macaroon
+ tag : str
+ '''
+ self.macaroon = Macaroon.from_json(macaroon) if macaroon else None
+ self.tag = tag
+
+
+
+class EntityMacaroonArgs(Type):
+ _toSchema = {'args': 'Args'}
+ _toPy = {'Args': 'args'}
+ def __init__(self, args=None, **unknown_fields):
+ '''
+ args : typing.Sequence[~EntityMacaroonArg]
+ '''
+ self.args = [EntityMacaroonArg.from_json(o) for o in args or []]
+
+
+
class EntityMetrics(Type):
_toSchema = {'error': 'error', 'metrics': 'metrics'}
_toPy = {'error': 'error', 'metrics': 'metrics'}
def __init__(self, error=None, metrics=None, **unknown_fields):
'''
error : Error
- metrics : typing.Sequence<+T_co>[~MetricResult]<~MetricResult>
+ metrics : typing.Sequence[~MetricResult]
'''
self.error = Error.from_json(error) if error else None
self.metrics = [MetricResult.from_json(o) for o in metrics or []]
_toPy = {'changes': 'changes'}
def __init__(self, changes=None, **unknown_fields):
'''
- changes : typing.Sequence<+T_co>[~EntityPassword]<~EntityPassword>
+ changes : typing.Sequence[~EntityPassword]
'''
self.changes = [EntityPassword.from_json(o) for o in changes or []]
_toPy = {'data': 'data', 'info': 'info', 'since': 'since', 'status': 'status'}
def __init__(self, data=None, info=None, since=None, status=None, **unknown_fields):
'''
- data : typing.Mapping<~KT, +VT_co>[str, typing.Any]
+ data : typing.Mapping[str, typing.Any]
info : str
since : str
status : str
_toPy = {'data': 'data', 'info': 'info', 'status': 'status', 'tag': 'tag'}
def __init__(self, data=None, info=None, status=None, tag=None, **unknown_fields):
'''
- data : typing.Mapping<~KT, +VT_co>[str, typing.Any]
+ data : typing.Mapping[str, typing.Any]
info : str
status : str
tag : str
+class EntityString(Type):
+ _toSchema = {'tag': 'tag', 'value': 'value'}
+ _toPy = {'tag': 'tag', 'value': 'value'}
+ def __init__(self, tag=None, value=None, **unknown_fields):
+ '''
+ tag : str
+ value : str
+ '''
+ self.tag = tag
+ self.value = value
+
+
+
class EntityVersion(Type):
_toSchema = {'tag': 'tag', 'tools': 'tools'}
_toPy = {'tag': 'tag', 'tools': 'tools'}
_toPy = {'entities': 'entities'}
def __init__(self, entities=None, **unknown_fields):
'''
- entities : typing.Sequence<+T_co>[~EntityWorkloadVersion]<~EntityWorkloadVersion>
+ entities : typing.Sequence[~EntityWorkloadVersion]
'''
self.entities = [EntityWorkloadVersion.from_json(o) for o in entities or []]
_toPy = {'patterns': 'patterns'}
def __init__(self, patterns=None, **unknown_fields):
'''
- patterns : typing.Sequence<+T_co>[str]
+ patterns : typing.Sequence[str]
'''
self.patterns = patterns
_toPy = {'results': 'results'}
def __init__(self, results=None, **unknown_fields):
'''
- results : typing.Sequence<+T_co>[~Payload]<~Payload>
+ results : typing.Sequence[~Payload]
'''
self.results = [Payload.from_json(o) for o in results or []]
_toPy = {'results': 'results'}
def __init__(self, results=None, **unknown_fields):
'''
- results : typing.Sequence<+T_co>[~ErrorResult]<~ErrorResult>
+ results : typing.Sequence[~ErrorResult]
'''
self.results = [ErrorResult.from_json(o) for o in results or []]
+class ExternalControllerInfo(Type):
+ _toSchema = {'addrs': 'addrs', 'ca_cert': 'ca-cert', 'controller_alias': 'controller-alias', 'controller_tag': 'controller-tag'}
+ _toPy = {'addrs': 'addrs', 'ca-cert': 'ca_cert', 'controller-alias': 'controller_alias', 'controller-tag': 'controller_tag'}
+ def __init__(self, addrs=None, ca_cert=None, controller_alias=None, controller_tag=None, **unknown_fields):
+ '''
+ addrs : typing.Sequence[str]
+ ca_cert : str
+ controller_alias : str
+ controller_tag : str
+ '''
+ self.addrs = addrs
+ self.ca_cert = ca_cert
+ self.controller_alias = controller_alias
+ self.controller_tag = controller_tag
+
+
+
+class ExternalControllerInfoResult(Type):
+ _toSchema = {'error': 'error', 'result': 'result'}
+ _toPy = {'error': 'error', 'result': 'result'}
+ def __init__(self, error=None, result=None, **unknown_fields):
+ '''
+ error : Error
+ result : ExternalControllerInfo
+ '''
+ self.error = Error.from_json(error) if error else None
+ self.result = ExternalControllerInfo.from_json(result) if result else None
+
+
+
+class ExternalControllerInfoResults(Type):
+ _toSchema = {'results': 'results'}
+ _toPy = {'results': 'results'}
+ def __init__(self, results=None, **unknown_fields):
+ '''
+ results : typing.Sequence[~ExternalControllerInfoResult]
+ '''
+ self.results = [ExternalControllerInfoResult.from_json(o) for o in results or []]
+
+
+
+class FanConfigEntry(Type):
+ _toSchema = {'overlay': 'overlay', 'underlay': 'underlay'}
+ _toPy = {'overlay': 'overlay', 'underlay': 'underlay'}
+ def __init__(self, overlay=None, underlay=None, **unknown_fields):
+ '''
+ overlay : str
+ underlay : str
+ '''
+ self.overlay = overlay
+ self.underlay = underlay
+
+
+
+class FanConfigResult(Type):
+ _toSchema = {'fans': 'fans'}
+ _toPy = {'fans': 'fans'}
+ def __init__(self, fans=None, **unknown_fields):
+ '''
+ fans : typing.Sequence[~FanConfigEntry]
+ '''
+ self.fans = [FanConfigEntry.from_json(o) for o in fans or []]
+
+
+
class Filesystem(Type):
_toSchema = {'filesystem_tag': 'filesystem-tag', 'info': 'info', 'volume_tag': 'volume-tag'}
_toPy = {'filesystem-tag': 'filesystem_tag', 'info': 'info', 'volume-tag': 'volume_tag'}
_toPy = {'results': 'results'}
def __init__(self, results=None, **unknown_fields):
'''
- results : typing.Sequence<+T_co>[~FilesystemAttachmentParamsResult]<~FilesystemAttachmentParamsResult>
+ results : typing.Sequence[~FilesystemAttachmentParamsResult]
'''
self.results = [FilesystemAttachmentParamsResult.from_json(o) for o in results or []]
_toPy = {'results': 'results'}
def __init__(self, results=None, **unknown_fields):
'''
- results : typing.Sequence<+T_co>[~FilesystemAttachmentResult]<~FilesystemAttachmentResult>
+ results : typing.Sequence[~FilesystemAttachmentResult]
'''
self.results = [FilesystemAttachmentResult.from_json(o) for o in results or []]
_toPy = {'filesystem-attachments': 'filesystem_attachments'}
def __init__(self, filesystem_attachments=None, **unknown_fields):
'''
- filesystem_attachments : typing.Sequence<+T_co>[~FilesystemAttachment]<~FilesystemAttachment>
+ filesystem_attachments : typing.Sequence[~FilesystemAttachment]
'''
self.filesystem_attachments = [FilesystemAttachment.from_json(o) for o in filesystem_attachments or []]
'''
filesystem_tag : str
info : FilesystemInfo
- machine_attachments : typing.Mapping<~KT, +VT_co>[str, ~FilesystemAttachmentInfo]<~FilesystemAttachmentInfo>
+ machine_attachments : typing.Mapping[str, ~FilesystemAttachmentInfo]
status : EntityStatus
storage : StorageDetails
volume_tag : str
def __init__(self, error=None, result=None, **unknown_fields):
'''
error : Error
- result : typing.Sequence<+T_co>[~FilesystemDetails]<~FilesystemDetails>
+ result : typing.Sequence[~FilesystemDetails]
'''
self.error = Error.from_json(error) if error else None
self.result = [FilesystemDetails.from_json(o) for o in result or []]
_toPy = {'results': 'results'}
def __init__(self, results=None, **unknown_fields):
'''
- results : typing.Sequence<+T_co>[~FilesystemDetailsListResult]<~FilesystemDetailsListResult>
+ results : typing.Sequence[~FilesystemDetailsListResult]
'''
self.results = [FilesystemDetailsListResult.from_json(o) for o in results or []]
_toPy = {'machines': 'machines'}
def __init__(self, machines=None, **unknown_fields):
'''
- machines : typing.Sequence<+T_co>[str]
+ machines : typing.Sequence[str]
'''
self.machines = machines
_toPy = {'filters': 'filters'}
def __init__(self, filters=None, **unknown_fields):
'''
- filters : typing.Sequence<+T_co>[~FilesystemFilter]<~FilesystemFilter>
+ filters : typing.Sequence[~FilesystemFilter]
'''
self.filters = [FilesystemFilter.from_json(o) for o in filters or []]
def __init__(self, attachment=None, attributes=None, filesystem_tag=None, provider=None, size=None, tags=None, volume_tag=None, **unknown_fields):
'''
attachment : FilesystemAttachmentParams
- attributes : typing.Mapping<~KT, +VT_co>[str, typing.Any]
+ attributes : typing.Mapping[str, typing.Any]
filesystem_tag : str
provider : str
size : int
- tags : typing.Mapping<~KT, +VT_co>[str, str]
+ tags : typing.Mapping[str, str]
volume_tag : str
'''
self.attachment = FilesystemAttachmentParams.from_json(attachment) if attachment else None
_toPy = {'results': 'results'}
def __init__(self, results=None, **unknown_fields):
'''
- results : typing.Sequence<+T_co>[~FilesystemParamsResult]<~FilesystemParamsResult>
+ results : typing.Sequence[~FilesystemParamsResult]
'''
self.results = [FilesystemParamsResult.from_json(o) for o in results or []]
_toPy = {'results': 'results'}
def __init__(self, results=None, **unknown_fields):
'''
- results : typing.Sequence<+T_co>[~FilesystemResult]<~FilesystemResult>
+ results : typing.Sequence[~FilesystemResult]
'''
self.results = [FilesystemResult.from_json(o) for o in results or []]
_toPy = {'filesystems': 'filesystems'}
def __init__(self, filesystems=None, **unknown_fields):
'''
- filesystems : typing.Sequence<+T_co>[~Filesystem]<~Filesystem>
+ filesystems : typing.Sequence[~Filesystem]
'''
self.filesystems = [Filesystem.from_json(o) for o in filesystems or []]
_toPy = {'names': 'names'}
def __init__(self, names=None, **unknown_fields):
'''
- names : typing.Sequence<+T_co>[str]
+ names : typing.Sequence[str]
'''
self.names = names
_toPy = {'prefixes': 'prefixes'}
def __init__(self, prefixes=None, **unknown_fields):
'''
- prefixes : typing.Sequence<+T_co>[str]
+ prefixes : typing.Sequence[str]
'''
self.prefixes = prefixes
_toPy = {'matches': 'matches'}
def __init__(self, matches=None, **unknown_fields):
'''
- matches : typing.Sequence<+T_co>[~Entity]<~Entity>
+ matches : typing.Sequence[~Entity]
'''
self.matches = [Entity.from_json(o) for o in matches or []]
def __init__(self, error=None, list_=None, **unknown_fields):
'''
error : Error
- list_ : typing.Sequence<+T_co>[~Tools]<~Tools>
+ list_ : typing.Sequence[~Tools]
'''
self.error = Error.from_json(error) if error else None
self.list_ = [Tools.from_json(o) for o in list_ or []]
+class FirewallRule(Type):
+ _toSchema = {'known_service': 'known-service', 'whitelist_cidrs': 'whitelist-cidrs'}
+ _toPy = {'known-service': 'known_service', 'whitelist-cidrs': 'whitelist_cidrs'}
+ def __init__(self, known_service=None, whitelist_cidrs=None, **unknown_fields):
+ '''
+ known_service : str
+ whitelist_cidrs : typing.Sequence[str]
+ '''
+ self.known_service = known_service
+ self.whitelist_cidrs = whitelist_cidrs
+
+
+
+class FirewallRuleArgs(Type):
+ _toSchema = {'args': 'args'}
+ _toPy = {'args': 'args'}
+ def __init__(self, args=None, **unknown_fields):
+ '''
+ args : typing.Sequence[~FirewallRule]
+ '''
+ self.args = [FirewallRule.from_json(o) for o in args or []]
+
+
+
class FullStatus(Type):
- _toSchema = {'applications': 'applications', 'machines': 'machines', 'model': 'model', 'relations': 'relations', 'remote_applications': 'remote-applications'}
- _toPy = {'applications': 'applications', 'machines': 'machines', 'model': 'model', 'relations': 'relations', 'remote-applications': 'remote_applications'}
- def __init__(self, applications=None, machines=None, model=None, relations=None, remote_applications=None, **unknown_fields):
+ _toSchema = {'applications': 'applications', 'controller_timestamp': 'controller-timestamp', 'machines': 'machines', 'model': 'model', 'offers': 'offers', 'relations': 'relations', 'remote_applications': 'remote-applications'}
+ _toPy = {'applications': 'applications', 'controller-timestamp': 'controller_timestamp', 'machines': 'machines', 'model': 'model', 'offers': 'offers', 'relations': 'relations', 'remote-applications': 'remote_applications'}
+ def __init__(self, applications=None, controller_timestamp=None, machines=None, model=None, offers=None, relations=None, remote_applications=None, **unknown_fields):
'''
- applications : typing.Mapping<~KT, +VT_co>[str, ~ApplicationStatus]<~ApplicationStatus>
- machines : typing.Mapping<~KT, +VT_co>[str, ~MachineStatus]<~MachineStatus>
+ applications : typing.Mapping[str, ~ApplicationStatus]
+ controller_timestamp : str
+ machines : typing.Mapping[str, ~MachineStatus]
model : ModelStatusInfo
- relations : typing.Sequence<+T_co>[~RelationStatus]<~RelationStatus>
- remote_applications : typing.Mapping<~KT, +VT_co>[str, ~RemoteApplicationStatus]<~RemoteApplicationStatus>
+ offers : typing.Mapping[str, ~ApplicationOfferStatus]
+ relations : typing.Sequence[~RelationStatus]
+ remote_applications : typing.Mapping[str, ~RemoteApplicationStatus]
'''
self.applications = applications
+ self.controller_timestamp = controller_timestamp
self.machines = machines
self.model = ModelStatusInfo.from_json(model) if model else None
+ self.offers = offers
self.relations = [RelationStatus.from_json(o) for o in relations or []]
self.remote_applications = remote_applications
_toPy = {'results': 'results'}
def __init__(self, results=None, **unknown_fields):
'''
- results : typing.Sequence<+T_co>[~GetLeadershipSettingsResult]<~GetLeadershipSettingsResult>
+ results : typing.Sequence[~GetLeadershipSettingsResult]
'''
self.results = [GetLeadershipSettingsResult.from_json(o) for o in results or []]
def __init__(self, error=None, settings=None, **unknown_fields):
'''
error : Error
- settings : typing.Mapping<~KT, +VT_co>[str, str]
+ settings : typing.Mapping[str, str]
'''
self.error = Error.from_json(error) if error else None
self.settings = settings
+class GetTokenArg(Type):
+ _toSchema = {'tag': 'tag'}
+ _toPy = {'tag': 'tag'}
+ def __init__(self, tag=None, **unknown_fields):
+ '''
+ tag : str
+ '''
+ self.tag = tag
+
+
+
+class GetTokenArgs(Type):
+ _toSchema = {'args': 'Args'}
+ _toPy = {'Args': 'args'}
+ def __init__(self, args=None, **unknown_fields):
+ '''
+ args : typing.Sequence[~GetTokenArg]
+ '''
+ self.args = [GetTokenArg.from_json(o) for o in args or []]
+
+
+
+class GoalState(Type):
+ _toSchema = {'relations': 'relations', 'units': 'units'}
+ _toPy = {'relations': 'relations', 'units': 'units'}
+ def __init__(self, relations=None, units=None, **unknown_fields):
+ '''
+ relations : typing.Mapping[str, typing.Any]
+ units : typing.Mapping[str, ~GoalStateStatus]
+ '''
+ self.relations = relations
+ self.units = units
+
+
+
+class GoalStateResult(Type):
+ _toSchema = {'error': 'error', 'result': 'result'}
+ _toPy = {'error': 'error', 'result': 'result'}
+ def __init__(self, error=None, result=None, **unknown_fields):
+ '''
+ error : Error
+ result : GoalState
+ '''
+ self.error = Error.from_json(error) if error else None
+ self.result = GoalState.from_json(result) if result else None
+
+
+
+class GoalStateResults(Type):
+ _toSchema = {'results': 'results'}
+ _toPy = {'results': 'results'}
+ def __init__(self, results=None, **unknown_fields):
+ '''
+ results : typing.Sequence[~GoalStateResult]
+ '''
+ self.results = [GoalStateResult.from_json(o) for o in results or []]
+
+
+
+class GoalStateStatus(Type):
+ _toSchema = {'since': 'since', 'status': 'status'}
+ _toPy = {'since': 'since', 'status': 'status'}
+ def __init__(self, since=None, status=None, **unknown_fields):
+ '''
+ since : str
+ status : str
+ '''
+ self.since = since
+ self.status = status
+
+
+
class HAMember(Type):
_toSchema = {'public_address': 'public-address', 'series': 'series', 'tag': 'tag'}
_toPy = {'public-address': 'public_address', 'series': 'series', 'tag': 'tag'}
cpu_power : int
mem : int
root_disk : int
- tags : typing.Sequence<+T_co>[str]
+ tags : typing.Sequence[str]
'''
self.arch = arch
self.availability_zone = availability_zone
def __init__(self, error=None, statuses=None, **unknown_fields):
'''
error : Error
- statuses : typing.Sequence<+T_co>[~DetailedStatus]<~DetailedStatus>
+ statuses : typing.Sequence[~DetailedStatus]
'''
self.error = Error.from_json(error) if error else None
self.statuses = [DetailedStatus.from_json(o) for o in statuses or []]
def __init__(self, error=None, new_bridges=None, reconfigure_delay=None, **unknown_fields):
'''
error : Error
- new_bridges : typing.Sequence<+T_co>[~DeviceBridgeInfo]<~DeviceBridgeInfo>
+ new_bridges : typing.Sequence[~DeviceBridgeInfo]
reconfigure_delay : int
'''
self.error = Error.from_json(error) if error else None
_toPy = {'results': 'results'}
def __init__(self, results=None, **unknown_fields):
'''
- results : typing.Sequence<+T_co>[~HostNetworkChange]<~HostNetworkChange>
+ results : typing.Sequence[~HostNetworkChange]
'''
self.results = [HostNetworkChange.from_json(o) for o in results or []]
def __init__(self, cloud_spec=None, config=None, error=None, name=None, owner=None, **unknown_fields):
'''
cloud_spec : CloudSpec
- config : typing.Mapping<~KT, +VT_co>[str, typing.Any]
+ config : typing.Mapping[str, typing.Any]
error : Error
name : str
owner : str
_toPy = {'models': 'models'}
def __init__(self, models=None, **unknown_fields):
'''
- models : typing.Sequence<+T_co>[~HostedModelConfig]<~HostedModelConfig>
+ models : typing.Sequence[~HostedModelConfig]
'''
self.models = [HostedModelConfig.from_json(o) for o in models or []]
_toPy = {'images': 'images'}
def __init__(self, images=None, **unknown_fields):
'''
- images : typing.Sequence<+T_co>[~ImageSpec]<~ImageSpec>
+ images : typing.Sequence[~ImageSpec]
'''
self.images = [ImageSpec.from_json(o) for o in images or []]
_toPy = {'arches': 'arches', 'region': 'region', 'root-storage-type': 'root_storage_type', 'series': 'series', 'stream': 'stream', 'virt-type': 'virt_type'}
def __init__(self, arches=None, region=None, root_storage_type=None, series=None, stream=None, virt_type=None, **unknown_fields):
'''
- arches : typing.Sequence<+T_co>[str]
+ arches : typing.Sequence[str]
region : str
root_storage_type : str
- series : typing.Sequence<+T_co>[str]
+ series : typing.Sequence[str]
stream : str
virt_type : str
'''
+class ImportStorageDetails(Type):
+ _toSchema = {'storage_tag': 'storage-tag'}
+ _toPy = {'storage-tag': 'storage_tag'}
+ def __init__(self, storage_tag=None, **unknown_fields):
+ '''
+ storage_tag : str
+ '''
+ self.storage_tag = storage_tag
+
+
+
+class ImportStorageParams(Type):
+ _toSchema = {'kind': 'kind', 'pool': 'pool', 'provider_id': 'provider-id', 'storage_name': 'storage-name'}
+ _toPy = {'kind': 'kind', 'pool': 'pool', 'provider-id': 'provider_id', 'storage-name': 'storage_name'}
+ def __init__(self, kind=None, pool=None, provider_id=None, storage_name=None, **unknown_fields):
+ '''
+ kind : int
+ pool : str
+ provider_id : str
+ storage_name : str
+ '''
+ self.kind = kind
+ self.pool = pool
+ self.provider_id = provider_id
+ self.storage_name = storage_name
+
+
+
+class ImportStorageResult(Type):
+ _toSchema = {'error': 'error', 'result': 'result'}
+ _toPy = {'error': 'error', 'result': 'result'}
+ def __init__(self, error=None, result=None, **unknown_fields):
+ '''
+ error : Error
+ result : ImportStorageDetails
+ '''
+ self.error = Error.from_json(error) if error else None
+ self.result = ImportStorageDetails.from_json(result) if result else None
+
+
+
+class ImportStorageResults(Type):
+ _toSchema = {'results': 'results'}
+ _toPy = {'results': 'results'}
+ def __init__(self, results=None, **unknown_fields):
+ '''
+ results : typing.Sequence[~ImportStorageResult]
+ '''
+ self.results = [ImportStorageResult.from_json(o) for o in results or []]
+
+
+
+class IngressNetworksChangeEvent(Type):
+ _toSchema = {'application_token': 'application-token', 'ingress_required': 'ingress-required', 'macaroons': 'macaroons', 'networks': 'networks', 'relation_token': 'relation-token'}
+ _toPy = {'application-token': 'application_token', 'ingress-required': 'ingress_required', 'macaroons': 'macaroons', 'networks': 'networks', 'relation-token': 'relation_token'}
+ def __init__(self, application_token=None, ingress_required=None, macaroons=None, networks=None, relation_token=None, **unknown_fields):
+ '''
+ application_token : str
+ ingress_required : bool
+ macaroons : typing.Sequence[~Macaroon]
+ networks : typing.Sequence[str]
+ relation_token : str
+ '''
+ self.application_token = application_token
+ self.ingress_required = ingress_required
+ self.macaroons = [Macaroon.from_json(o) for o in macaroons or []]
+ self.networks = networks
+ self.relation_token = relation_token
+
+
+
+class IngressNetworksChanges(Type):
+ _toSchema = {'changes': 'changes'}
+ _toPy = {'changes': 'changes'}
+ def __init__(self, changes=None, **unknown_fields):
+ '''
+ changes : typing.Sequence[~IngressNetworksChangeEvent]
+ '''
+ self.changes = [IngressNetworksChangeEvent.from_json(o) for o in changes or []]
+
+
+
class InitiateMigrationArgs(Type):
_toSchema = {'specs': 'specs'}
_toPy = {'specs': 'specs'}
def __init__(self, specs=None, **unknown_fields):
'''
- specs : typing.Sequence<+T_co>[~MigrationSpec]<~MigrationSpec>
+ specs : typing.Sequence[~MigrationSpec]
'''
self.specs = [MigrationSpec.from_json(o) for o in specs or []]
_toPy = {'results': 'results'}
def __init__(self, results=None, **unknown_fields):
'''
- results : typing.Sequence<+T_co>[~InitiateMigrationResult]<~InitiateMigrationResult>
+ results : typing.Sequence[~InitiateMigrationResult]
'''
self.results = [InitiateMigrationResult.from_json(o) for o in results or []]
'''
characteristics : HardwareCharacteristics
instance_id : str
- network_config : typing.Sequence<+T_co>[~NetworkConfig]<~NetworkConfig>
+ network_config : typing.Sequence[~NetworkConfig]
nonce : str
tag : str
- volume_attachments : typing.Mapping<~KT, +VT_co>[str, ~VolumeAttachmentInfo]<~VolumeAttachmentInfo>
- volumes : typing.Sequence<+T_co>[~Volume]<~Volume>
+ volume_attachments : typing.Mapping[str, ~VolumeAttachmentInfo]
+ volumes : typing.Sequence[~Volume]
'''
self.characteristics = HardwareCharacteristics.from_json(characteristics) if characteristics else None
self.instance_id = instance_id
_toPy = {'arches': 'arches', 'cost': 'cost', 'cpu-cores': 'cpu_cores', 'deprecated': 'deprecated', 'memory': 'memory', 'name': 'name', 'root-disk': 'root_disk', 'virt-type': 'virt_type'}
def __init__(self, arches=None, cost=None, cpu_cores=None, deprecated=None, memory=None, name=None, root_disk=None, virt_type=None, **unknown_fields):
'''
- arches : typing.Sequence<+T_co>[str]
+ arches : typing.Sequence[str]
cost : int
cpu_cores : int
deprecated : bool
cost_divisor : int
cost_unit : str
error : Error
- instance_types : typing.Sequence<+T_co>[~InstanceType]<~InstanceType>
+ instance_types : typing.Sequence[~InstanceType]
'''
self.cost_currency = cost_currency
self.cost_divisor = cost_divisor
_toPy = {'results': 'results'}
def __init__(self, results=None, **unknown_fields):
'''
- results : typing.Sequence<+T_co>[~InstanceTypesResult]<~InstanceTypesResult>
+ results : typing.Sequence[~InstanceTypesResult]
'''
self.results = [InstanceTypesResult.from_json(o) for o in results or []]
_toPy = {'machines': 'machines'}
def __init__(self, machines=None, **unknown_fields):
'''
- machines : typing.Sequence<+T_co>[~InstanceInfo]<~InstanceInfo>
+ machines : typing.Sequence[~InstanceInfo]
'''
self.machines = [InstanceInfo.from_json(o) for o in machines or []]
_toPy = {'results': 'results'}
def __init__(self, results=None, **unknown_fields):
'''
- results : typing.Sequence<+T_co>[~IntResult]<~IntResult>
+ results : typing.Sequence[~IntResult]
'''
self.results = [IntResult.from_json(o) for o in results or []]
+class InvalidateCredentialArg(Type):
+ _toSchema = {'reason': 'reason'}
+ _toPy = {'reason': 'reason'}
+ def __init__(self, reason=None, **unknown_fields):
+ '''
+ reason : str
+ '''
+ self.reason = reason
+
+
+
class IsMasterResult(Type):
_toSchema = {'master': 'master'}
_toPy = {'master': 'master'}
def __init__(self, error=None, jobs=None, **unknown_fields):
'''
error : Error
- jobs : typing.Sequence<+T_co>[str]
+ jobs : typing.Sequence[str]
'''
self.error = Error.from_json(error) if error else None
self.jobs = jobs
_toPy = {'results': 'results'}
def __init__(self, results=None, **unknown_fields):
'''
- results : typing.Sequence<+T_co>[~JobsResult]<~JobsResult>
+ results : typing.Sequence[~JobsResult]
'''
self.results = [JobsResult.from_json(o) for o in results or []]
-class LifeResult(Type):
- _toSchema = {'error': 'error', 'life': 'life'}
- _toPy = {'error': 'error', 'life': 'life'}
- def __init__(self, error=None, life=None, **unknown_fields):
+class KnownServiceArgs(Type):
+ _toSchema = {'known_services': 'known-services'}
+ _toPy = {'known-services': 'known_services'}
+ def __init__(self, known_services=None, **unknown_fields):
'''
- error : Error
- life : str
+ known_services : typing.Sequence[str]
'''
- self.error = Error.from_json(error) if error else None
- self.life = life
+ self.known_services = known_services
-class LifeResults(Type):
- _toSchema = {'results': 'results'}
- _toPy = {'results': 'results'}
- def __init__(self, results=None, **unknown_fields):
+class KubernetesDeviceParams(Type):
+ _toSchema = {'attributes': 'Attributes', 'count': 'Count', 'type_': 'Type'}
+ _toPy = {'Attributes': 'attributes', 'Count': 'count', 'Type': 'type_'}
+ def __init__(self, attributes=None, count=None, type_=None, **unknown_fields):
'''
- results : typing.Sequence<+T_co>[~LifeResult]<~LifeResult>
+ attributes : typing.Mapping[str, str]
+ count : int
+ type_ : str
'''
- self.results = [LifeResult.from_json(o) for o in results or []]
+ self.attributes = attributes
+ self.count = count
+ self.type_ = type_
-class ListCloudImageMetadataResult(Type):
- _toSchema = {'result': 'result'}
- _toPy = {'result': 'result'}
- def __init__(self, result=None, **unknown_fields):
+class KubernetesFilesystemAttachmentParams(Type):
+ _toSchema = {'mount_point': 'mount-point', 'provider': 'provider', 'read_only': 'read-only'}
+ _toPy = {'mount-point': 'mount_point', 'provider': 'provider', 'read-only': 'read_only'}
+ def __init__(self, mount_point=None, provider=None, read_only=None, **unknown_fields):
'''
- result : typing.Sequence<+T_co>[~CloudImageMetadata]<~CloudImageMetadata>
+ mount_point : str
+ provider : str
+ read_only : bool
'''
- self.result = [CloudImageMetadata.from_json(o) for o in result or []]
+ self.mount_point = mount_point
+ self.provider = provider
+ self.read_only = read_only
-class ListImageResult(Type):
- _toSchema = {'result': 'result'}
- _toPy = {'result': 'result'}
- def __init__(self, result=None, **unknown_fields):
+class KubernetesFilesystemInfo(Type):
+ _toSchema = {'data': 'data', 'filesystem_id': 'filesystem-id', 'info': 'info', 'mount_point': 'mount-point', 'pool': 'pool', 'read_only': 'read-only', 'size': 'size', 'status': 'status', 'storagename': 'storagename', 'volume': 'volume'}
+ _toPy = {'data': 'data', 'filesystem-id': 'filesystem_id', 'info': 'info', 'mount-point': 'mount_point', 'pool': 'pool', 'read-only': 'read_only', 'size': 'size', 'status': 'status', 'storagename': 'storagename', 'volume': 'volume'}
+ def __init__(self, data=None, filesystem_id=None, info=None, mount_point=None, pool=None, read_only=None, size=None, status=None, storagename=None, volume=None, **unknown_fields):
'''
- result : typing.Sequence<+T_co>[~ImageMetadata]<~ImageMetadata>
+ data : typing.Mapping[str, typing.Any]
+ filesystem_id : str
+ info : str
+ mount_point : str
+ pool : str
+ read_only : bool
+ size : int
+ status : str
+ storagename : str
+ volume : KubernetesVolumeInfo
'''
- self.result = [ImageMetadata.from_json(o) for o in result or []]
+ self.data = data
+ self.filesystem_id = filesystem_id
+ self.info = info
+ self.mount_point = mount_point
+ self.pool = pool
+ self.read_only = read_only
+ self.size = size
+ self.status = status
+ self.storagename = storagename
+ self.volume = KubernetesVolumeInfo.from_json(volume) if volume else None
-class ListResourcesArgs(Type):
- _toSchema = {'entities': 'entities'}
- _toPy = {'entities': 'entities'}
- def __init__(self, entities=None, **unknown_fields):
+class KubernetesFilesystemParams(Type):
+ _toSchema = {'attachment': 'attachment', 'attributes': 'attributes', 'provider': 'provider', 'size': 'size', 'storagename': 'storagename', 'tags': 'tags'}
+ _toPy = {'attachment': 'attachment', 'attributes': 'attributes', 'provider': 'provider', 'size': 'size', 'storagename': 'storagename', 'tags': 'tags'}
+ def __init__(self, attachment=None, attributes=None, provider=None, size=None, storagename=None, tags=None, **unknown_fields):
'''
- entities : typing.Sequence<+T_co>[~Entity]<~Entity>
+ attachment : KubernetesFilesystemAttachmentParams
+ attributes : typing.Mapping[str, typing.Any]
+ provider : str
+ size : int
+ storagename : str
+ tags : typing.Mapping[str, str]
'''
- self.entities = [Entity.from_json(o) for o in entities or []]
+ self.attachment = KubernetesFilesystemAttachmentParams.from_json(attachment) if attachment else None
+ self.attributes = attributes
+ self.provider = provider
+ self.size = size
+ self.storagename = storagename
+ self.tags = tags
-class ListSSHKeys(Type):
+class KubernetesProvisioningInfo(Type):
+ _toSchema = {'constraints': 'constraints', 'devices': 'devices', 'filesystems': 'filesystems', 'placement': 'placement', 'pod_spec': 'pod-spec', 'tags': 'tags', 'volumes': 'volumes'}
+ _toPy = {'constraints': 'constraints', 'devices': 'devices', 'filesystems': 'filesystems', 'placement': 'placement', 'pod-spec': 'pod_spec', 'tags': 'tags', 'volumes': 'volumes'}
+ def __init__(self, constraints=None, devices=None, filesystems=None, placement=None, pod_spec=None, tags=None, volumes=None, **unknown_fields):
+ '''
+ constraints : Value
+ devices : typing.Sequence[~KubernetesDeviceParams]
+ filesystems : typing.Sequence[~KubernetesFilesystemParams]
+ placement : str
+ pod_spec : str
+ tags : typing.Mapping[str, str]
+ volumes : typing.Sequence[~KubernetesVolumeParams]
+ '''
+ self.constraints = Value.from_json(constraints) if constraints else None
+ self.devices = [KubernetesDeviceParams.from_json(o) for o in devices or []]
+ self.filesystems = [KubernetesFilesystemParams.from_json(o) for o in filesystems or []]
+ self.placement = placement
+ self.pod_spec = pod_spec
+ self.tags = tags
+ self.volumes = [KubernetesVolumeParams.from_json(o) for o in volumes or []]
+
+
+
+class KubernetesProvisioningInfoResult(Type):
+ _toSchema = {'error': 'error', 'result': 'result'}
+ _toPy = {'error': 'error', 'result': 'result'}
+ def __init__(self, error=None, result=None, **unknown_fields):
+ '''
+ error : Error
+ result : KubernetesProvisioningInfo
+ '''
+ self.error = Error.from_json(error) if error else None
+ self.result = KubernetesProvisioningInfo.from_json(result) if result else None
+
+
+
+class KubernetesProvisioningInfoResults(Type):
+ _toSchema = {'results': 'results'}
+ _toPy = {'results': 'results'}
+ def __init__(self, results=None, **unknown_fields):
+ '''
+ results : typing.Sequence[~KubernetesProvisioningInfoResult]
+ '''
+ self.results = [KubernetesProvisioningInfoResult.from_json(o) for o in results or []]
+
+
+
+class KubernetesVolumeAttachmentParams(Type):
+ _toSchema = {'provider': 'provider', 'read_only': 'read-only'}
+ _toPy = {'provider': 'provider', 'read-only': 'read_only'}
+ def __init__(self, provider=None, read_only=None, **unknown_fields):
+ '''
+ provider : str
+ read_only : bool
+ '''
+ self.provider = provider
+ self.read_only = read_only
+
+
+
+class KubernetesVolumeInfo(Type):
+ _toSchema = {'data': 'data', 'info': 'info', 'persistent': 'persistent', 'pool': 'pool', 'size': 'size', 'status': 'status', 'volume_id': 'volume-id'}
+ _toPy = {'data': 'data', 'info': 'info', 'persistent': 'persistent', 'pool': 'pool', 'size': 'size', 'status': 'status', 'volume-id': 'volume_id'}
+ def __init__(self, data=None, info=None, persistent=None, pool=None, size=None, status=None, volume_id=None, **unknown_fields):
+ '''
+ data : typing.Mapping[str, typing.Any]
+ info : str
+ persistent : bool
+ pool : str
+ size : int
+ status : str
+ volume_id : str
+ '''
+ self.data = data
+ self.info = info
+ self.persistent = persistent
+ self.pool = pool
+ self.size = size
+ self.status = status
+ self.volume_id = volume_id
+
+
+
+class KubernetesVolumeParams(Type):
+ _toSchema = {'attachment': 'attachment', 'attributes': 'attributes', 'provider': 'provider', 'size': 'size', 'storagename': 'storagename', 'tags': 'tags'}
+ _toPy = {'attachment': 'attachment', 'attributes': 'attributes', 'provider': 'provider', 'size': 'size', 'storagename': 'storagename', 'tags': 'tags'}
+ def __init__(self, attachment=None, attributes=None, provider=None, size=None, storagename=None, tags=None, **unknown_fields):
+ '''
+ attachment : KubernetesVolumeAttachmentParams
+ attributes : typing.Mapping[str, typing.Any]
+ provider : str
+ size : int
+ storagename : str
+ tags : typing.Mapping[str, str]
+ '''
+ self.attachment = KubernetesVolumeAttachmentParams.from_json(attachment) if attachment else None
+ self.attributes = attributes
+ self.provider = provider
+ self.size = size
+ self.storagename = storagename
+ self.tags = tags
+
+
+
+class LXDProfile(Type):
+ _toSchema = {'config': 'config', 'description': 'description', 'devices': 'devices'}
+ _toPy = {'config': 'config', 'description': 'description', 'devices': 'devices'}
+ def __init__(self, config=None, description=None, devices=None, **unknown_fields):
+ '''
+ config : typing.Mapping[str, str]
+ description : str
+ devices : typing.Mapping[str, typing.Any]
+ '''
+ self.config = config
+ self.description = description
+ self.devices = devices
+
+
+
+class LXDProfileUpgradeMessages(Type):
+ _toSchema = {'application': 'application', 'watcher_id': 'watcher-id'}
+ _toPy = {'application': 'application', 'watcher-id': 'watcher_id'}
+ def __init__(self, application=None, watcher_id=None, **unknown_fields):
+ '''
+ application : Entity
+ watcher_id : str
+ '''
+ self.application = Entity.from_json(application) if application else None
+ self.watcher_id = watcher_id
+
+
+
+class LXDProfileUpgradeMessagesResult(Type):
+ _toSchema = {'error': 'error', 'message': 'message', 'unit_name': 'unit-name'}
+ _toPy = {'error': 'error', 'message': 'message', 'unit-name': 'unit_name'}
+ def __init__(self, error=None, message=None, unit_name=None, **unknown_fields):
+ '''
+ error : Error
+ message : str
+ unit_name : str
+ '''
+ self.error = Error.from_json(error) if error else None
+ self.message = message
+ self.unit_name = unit_name
+
+
+
+class LXDProfileUpgradeMessagesResults(Type):
+ _toSchema = {'args': 'args'}
+ _toPy = {'args': 'args'}
+ def __init__(self, args=None, **unknown_fields):
+ '''
+ args : typing.Sequence[~LXDProfileUpgradeMessagesResult]
+ '''
+ self.args = [LXDProfileUpgradeMessagesResult.from_json(o) for o in args or []]
+
+
+
+class LifeResult(Type):
+ _toSchema = {'error': 'error', 'life': 'life'}
+ _toPy = {'error': 'error', 'life': 'life'}
+ def __init__(self, error=None, life=None, **unknown_fields):
+ '''
+ error : Error
+ life : str
+ '''
+ self.error = Error.from_json(error) if error else None
+ self.life = life
+
+
+
+class LifeResults(Type):
+ _toSchema = {'results': 'results'}
+ _toPy = {'results': 'results'}
+ def __init__(self, results=None, **unknown_fields):
+ '''
+ results : typing.Sequence[~LifeResult]
+ '''
+ self.results = [LifeResult.from_json(o) for o in results or []]
+
+
+
+class ListCloudImageMetadataResult(Type):
+ _toSchema = {'result': 'result'}
+ _toPy = {'result': 'result'}
+ def __init__(self, result=None, **unknown_fields):
+ '''
+ result : typing.Sequence[~CloudImageMetadata]
+ '''
+ self.result = [CloudImageMetadata.from_json(o) for o in result or []]
+
+
+
+class ListCloudInfo(Type):
+ _toSchema = {'clouddetails': 'CloudDetails', 'user_access': 'user-access'}
+ _toPy = {'CloudDetails': 'clouddetails', 'user-access': 'user_access'}
+ def __init__(self, clouddetails=None, user_access=None, **unknown_fields):
+ '''
+ clouddetails : CloudDetails
+ user_access : str
+ '''
+ self.clouddetails = CloudDetails.from_json(clouddetails) if clouddetails else None
+ self.user_access = user_access
+
+
+
+class ListCloudInfoResult(Type):
+ _toSchema = {'error': 'error', 'result': 'result'}
+ _toPy = {'error': 'error', 'result': 'result'}
+ def __init__(self, error=None, result=None, **unknown_fields):
+ '''
+ error : Error
+ result : ListCloudInfo
+ '''
+ self.error = Error.from_json(error) if error else None
+ self.result = ListCloudInfo.from_json(result) if result else None
+
+
+
+class ListCloudInfoResults(Type):
+ _toSchema = {'results': 'results'}
+ _toPy = {'results': 'results'}
+ def __init__(self, results=None, **unknown_fields):
+ '''
+ results : typing.Sequence[~ListCloudInfoResult]
+ '''
+ self.results = [ListCloudInfoResult.from_json(o) for o in results or []]
+
+
+
+class ListCloudsRequest(Type):
+ _toSchema = {'all_': 'all', 'user_tag': 'user-tag'}
+ _toPy = {'all': 'all_', 'user-tag': 'user_tag'}
+ def __init__(self, all_=None, user_tag=None, **unknown_fields):
+ '''
+ all_ : bool
+ user_tag : str
+ '''
+ self.all_ = all_
+ self.user_tag = user_tag
+
+
+
+class ListFirewallRulesResults(Type):
+ _toSchema = {'rules': 'Rules'}
+ _toPy = {'Rules': 'rules'}
+ def __init__(self, rules=None, **unknown_fields):
+ '''
+ rules : typing.Sequence[~FirewallRule]
+ '''
+ self.rules = [FirewallRule.from_json(o) for o in rules or []]
+
+
+
+class ListImageResult(Type):
+ _toSchema = {'result': 'result'}
+ _toPy = {'result': 'result'}
+ def __init__(self, result=None, **unknown_fields):
+ '''
+ result : typing.Sequence[~ImageMetadata]
+ '''
+ self.result = [ImageMetadata.from_json(o) for o in result or []]
+
+
+
+class ListResourcesArgs(Type):
+ _toSchema = {'entities': 'entities'}
+ _toPy = {'entities': 'entities'}
+ def __init__(self, entities=None, **unknown_fields):
+ '''
+ entities : typing.Sequence[~Entity]
+ '''
+ self.entities = [Entity.from_json(o) for o in entities or []]
+
+
+
+class ListSSHKeys(Type):
_toSchema = {'entities': 'entities', 'mode': 'mode'}
_toPy = {'entities': 'entities', 'mode': 'mode'}
def __init__(self, entities=None, mode=None, **unknown_fields):
_toPy = {'results': 'results'}
def __init__(self, results=None, **unknown_fields):
'''
- results : typing.Sequence<+T_co>[~Space]<~Space>
+ results : typing.Sequence[~Space]
'''
self.results = [Space.from_json(o) for o in results or []]
_toPy = {'results': 'results'}
def __init__(self, results=None, **unknown_fields):
'''
- results : typing.Sequence<+T_co>[~Subnet]<~Subnet>
+ results : typing.Sequence[~Subnet]
'''
self.results = [Subnet.from_json(o) for o in results or []]
_toPy = {'resource-names': 'resource_names'}
def __init__(self, resource_names=None, **unknown_fields):
'''
- resource_names : typing.Sequence<+T_co>[str]
+ resource_names : typing.Sequence[str]
'''
self.resource_names = resource_names
_toPy = {'ids': 'ids'}
def __init__(self, ids=None, **unknown_fields):
'''
- ids : typing.Sequence<+T_co>[~LogForwardingID]<~LogForwardingID>
+ ids : typing.Sequence[~LogForwardingID]
'''
self.ids = [LogForwardingID.from_json(o) for o in ids or []]
_toPy = {'results': 'results'}
def __init__(self, results=None, **unknown_fields):
'''
- results : typing.Sequence<+T_co>[~LogForwardingGetLastSentResult]<~LogForwardingGetLastSentResult>
+ results : typing.Sequence[~LogForwardingGetLastSentResult]
'''
self.results = [LogForwardingGetLastSentResult.from_json(o) for o in results or []]
_toPy = {'params': 'params'}
def __init__(self, params=None, **unknown_fields):
'''
- params : typing.Sequence<+T_co>[~LogForwardingSetLastSentParam]<~LogForwardingSetLastSentParam>
+ params : typing.Sequence[~LogForwardingSetLastSentParam]
'''
self.params = [LogForwardingSetLastSentParam.from_json(o) for o in params or []]
_toPy = {'args': 'args'}
def __init__(self, args=None, **unknown_fields):
'''
- args : typing.Sequence<+T_co>[~LookUpArg]<~LookUpArg>
+ args : typing.Sequence[~LookUpArg]
'''
self.args = [LookUpArg.from_json(o) for o in args or []]
_toPy = {'args': 'args'}
def __init__(self, args=None, **unknown_fields):
'''
- args : typing.Sequence<+T_co>[~LookUpPayloadArg]<~LookUpPayloadArg>
+ args : typing.Sequence[~LookUpPayloadArg]
'''
self.args = [LookUpPayloadArg.from_json(o) for o in args or []]
+class MacaroonResult(Type):
+ _toSchema = {'error': 'error', 'result': 'result'}
+ _toPy = {'error': 'error', 'result': 'result'}
+ def __init__(self, error=None, result=None, **unknown_fields):
+ '''
+ error : Error
+ result : Macaroon
+ '''
+ self.error = Error.from_json(error) if error else None
+ self.result = Macaroon.from_json(result) if result else None
+
+
+
+class MacaroonResults(Type):
+ _toSchema = {'results': 'results'}
+ _toPy = {'results': 'results'}
+ def __init__(self, results=None, **unknown_fields):
+ '''
+ results : typing.Sequence[~MacaroonResult]
+ '''
+ self.results = [MacaroonResult.from_json(o) for o in results or []]
+
+
+
class MachineAddresses(Type):
_toSchema = {'addresses': 'addresses', 'tag': 'tag'}
_toPy = {'addresses': 'addresses', 'tag': 'tag'}
def __init__(self, addresses=None, tag=None, **unknown_fields):
'''
- addresses : typing.Sequence<+T_co>[~Address]<~Address>
+ addresses : typing.Sequence[~Address]
tag : str
'''
self.addresses = [Address.from_json(o) for o in addresses or []]
_toPy = {'addresses': 'addresses', 'error': 'error'}
def __init__(self, addresses=None, error=None, **unknown_fields):
'''
- addresses : typing.Sequence<+T_co>[~Address]<~Address>
+ addresses : typing.Sequence[~Address]
error : Error
'''
self.addresses = [Address.from_json(o) for o in addresses or []]
_toPy = {'results': 'results'}
def __init__(self, results=None, **unknown_fields):
'''
- results : typing.Sequence<+T_co>[~MachineAddressesResult]<~MachineAddressesResult>
+ results : typing.Sequence[~MachineAddressesResult]
'''
self.results = [MachineAddressesResult.from_json(o) for o in results or []]
_toPy = {'block-devices': 'block_devices', 'machine': 'machine'}
def __init__(self, block_devices=None, machine=None, **unknown_fields):
'''
- block_devices : typing.Sequence<+T_co>[~BlockDevice]<~BlockDevice>
+ block_devices : typing.Sequence[~BlockDevice]
machine : str
'''
self.block_devices = [BlockDevice.from_json(o) for o in block_devices or []]
_toPy = {'container-types': 'container_types', 'machine-tag': 'machine_tag'}
def __init__(self, container_types=None, machine_tag=None, **unknown_fields):
'''
- container_types : typing.Sequence<+T_co>[str]
+ container_types : typing.Sequence[str]
machine_tag : str
'''
self.container_types = container_types
_toPy = {'params': 'params'}
def __init__(self, params=None, **unknown_fields):
'''
- params : typing.Sequence<+T_co>[~MachineContainers]<~MachineContainers>
+ params : typing.Sequence[~MachineContainers]
'''
self.params = [MachineContainers.from_json(o) for o in params or []]
cpu_power : int
mem : int
root_disk : int
- tags : typing.Sequence<+T_co>[str]
+ tags : typing.Sequence[str]
'''
self.arch = arch
self.availability_zone = availability_zone
def __init__(self, error=None, info=None, **unknown_fields):
'''
error : Error
- info : typing.Sequence<+T_co>[~NetworkConfig]<~NetworkConfig>
+ info : typing.Sequence[~NetworkConfig]
'''
self.error = Error.from_json(error) if error else None
self.info = [NetworkConfig.from_json(o) for o in info or []]
_toPy = {'results': 'results'}
def __init__(self, results=None, **unknown_fields):
'''
- results : typing.Sequence<+T_co>[~MachineNetworkConfigResult]<~MachineNetworkConfigResult>
+ results : typing.Sequence[~MachineNetworkConfigResult]
'''
self.results = [MachineNetworkConfigResult.from_json(o) for o in results or []]
_toPy = {'params': 'params'}
def __init__(self, params=None, **unknown_fields):
'''
- params : typing.Sequence<+T_co>[~MachinePorts]<~MachinePorts>
+ params : typing.Sequence[~MachinePorts]
'''
self.params = [MachinePorts.from_json(o) for o in params or []]
def __init__(self, error=None, ports=None, **unknown_fields):
'''
error : Error
- ports : typing.Sequence<+T_co>[~MachinePortRange]<~MachinePortRange>
+ ports : typing.Sequence[~MachinePortRange]
'''
self.error = Error.from_json(error) if error else None
self.ports = [MachinePortRange.from_json(o) for o in ports or []]
_toPy = {'results': 'results'}
def __init__(self, results=None, **unknown_fields):
'''
- results : typing.Sequence<+T_co>[~MachinePortsResult]<~MachinePortsResult>
+ results : typing.Sequence[~MachinePortsResult]
'''
self.results = [MachinePortsResult.from_json(o) for o in results or []]
def __init__(self, agent_status=None, containers=None, dns_name=None, hardware=None, has_vote=None, id_=None, instance_id=None, instance_status=None, ip_addresses=None, jobs=None, series=None, wants_vote=None, **unknown_fields):
'''
agent_status : DetailedStatus
- containers : typing.Mapping<~KT, +VT_co>[str, ~MachineStatus]<~MachineStatus>
+ containers : typing.Mapping[str, ~MachineStatus]
dns_name : str
hardware : str
has_vote : bool
id_ : str
instance_id : str
instance_status : DetailedStatus
- ip_addresses : typing.Sequence<+T_co>[str]
- jobs : typing.Sequence<+T_co>[str]
+ ip_addresses : typing.Sequence[str]
+ jobs : typing.Sequence[str]
series : str
wants_vote : bool
'''
_toPy = {'ids': 'ids'}
def __init__(self, ids=None, **unknown_fields):
'''
- ids : typing.Sequence<+T_co>[~MachineStorageId]<~MachineStorageId>
+ ids : typing.Sequence[~MachineStorageId]
'''
self.ids = [MachineStorageId.from_json(o) for o in ids or []]
_toPy = {'changes': 'changes', 'error': 'error', 'watcher-id': 'watcher_id'}
def __init__(self, changes=None, error=None, watcher_id=None, **unknown_fields):
'''
- changes : typing.Sequence<+T_co>[~MachineStorageId]<~MachineStorageId>
+ changes : typing.Sequence[~MachineStorageId]
error : Error
watcher_id : str
'''
_toPy = {'results': 'results'}
def __init__(self, results=None, **unknown_fields):
'''
- results : typing.Sequence<+T_co>[~MachineStorageIdsWatchResult]<~MachineStorageIdsWatchResult>
+ results : typing.Sequence[~MachineStorageIdsWatchResult]
'''
self.results = [MachineStorageIdsWatchResult.from_json(o) for o in results or []]
def __init__(self, error=None, result=None, **unknown_fields):
'''
error : Error
- result : typing.Mapping<~KT, +VT_co>[str, typing.Any]
+ result : typing.Mapping[str, typing.Any]
'''
self.error = Error.from_json(error) if error else None
self.result = result
_toPy = {'results': 'results'}
def __init__(self, results=None, **unknown_fields):
'''
- results : typing.Sequence<+T_co>[~MapResult]<~MapResult>
+ results : typing.Sequence[~MapResult]
'''
self.results = [MapResult.from_json(o) for o in results or []]
id_ : int
priority : float
slavedelay : int
- tags : typing.Mapping<~KT, +VT_co>[str, str]
+ tags : typing.Mapping[str, str]
votes : int
'''
self.address = address
_toPy = {'params': 'params'}
def __init__(self, params=None, **unknown_fields):
'''
- params : typing.Sequence<+T_co>[~MergeLeadershipSettingsParam]<~MergeLeadershipSettingsParam>
+ params : typing.Sequence[~MergeLeadershipSettingsParam]
'''
self.params = [MergeLeadershipSettingsParam.from_json(o) for o in params or []]
def __init__(self, application_tag=None, settings=None, **unknown_fields):
'''
application_tag : str
- settings : typing.Mapping<~KT, +VT_co>[str, str]
+ settings : typing.Mapping[str, str]
'''
self.application_tag = application_tag
self.settings = settings
_toPy = {'image-ids': 'image_ids'}
def __init__(self, image_ids=None, **unknown_fields):
'''
- image_ids : typing.Sequence<+T_co>[str]
+ image_ids : typing.Sequence[str]
'''
self.image_ids = image_ids
_toPy = {'metadata': 'metadata'}
def __init__(self, metadata=None, **unknown_fields):
'''
- metadata : typing.Sequence<+T_co>[~CloudImageMetadataList]<~CloudImageMetadataList>
+ metadata : typing.Sequence[~CloudImageMetadataList]
'''
self.metadata = [CloudImageMetadataList.from_json(o) for o in metadata or []]
_toPy = {'statues': 'statues'}
def __init__(self, statues=None, **unknown_fields):
'''
- statues : typing.Sequence<+T_co>[~MeterStatusParam]<~MeterStatusParam>
+ statues : typing.Sequence[~MeterStatusParam]
'''
self.statues = [MeterStatusParam.from_json(o) for o in statues or []]
_toPy = {'results': 'results'}
def __init__(self, results=None, **unknown_fields):
'''
- results : typing.Sequence<+T_co>[~MeterStatusResult]<~MeterStatusResult>
+ results : typing.Sequence[~MeterStatusResult]
'''
self.results = [MeterStatusResult.from_json(o) for o in results or []]
'''
charm_url : str
created : str
- metrics : typing.Sequence<+T_co>[~Metric]<~Metric>
+ metrics : typing.Sequence[~Metric]
uuid : str
'''
self.charm_url = charm_url
_toPy = {'batches': 'batches'}
def __init__(self, batches=None, **unknown_fields):
'''
- batches : typing.Sequence<+T_co>[~MetricBatchParam]<~MetricBatchParam>
+ batches : typing.Sequence[~MetricBatchParam]
'''
self.batches = [MetricBatchParam.from_json(o) for o in batches or []]
_toPy = {'results': 'results'}
def __init__(self, results=None, **unknown_fields):
'''
- results : typing.Sequence<+T_co>[~EntityMetrics]<~EntityMetrics>
+ results : typing.Sequence[~EntityMetrics]
'''
self.results = [EntityMetrics.from_json(o) for o in results or []]
external_control : bool
migration_id : str
phase : str
- source_api_addrs : typing.Sequence<+T_co>[str]
+ source_api_addrs : typing.Sequence[str]
source_ca_cert : str
- target_api_addrs : typing.Sequence<+T_co>[str]
+ target_api_addrs : typing.Sequence[str]
target_ca_cert : str
'''
self.attempt = attempt
_toPy = {'addrs': 'addrs', 'auth-tag': 'auth_tag', 'ca-cert': 'ca_cert', 'controller-tag': 'controller_tag', 'macaroons': 'macaroons', 'password': 'password'}
def __init__(self, addrs=None, auth_tag=None, ca_cert=None, controller_tag=None, macaroons=None, password=None, **unknown_fields):
'''
- addrs : typing.Sequence<+T_co>[str]
+ addrs : typing.Sequence[str]
auth_tag : str
ca_cert : str
controller_tag : str
_toPy = {'failed': 'failed', 'migration-id': 'migration_id', 'phase': 'phase', 'success-count': 'success_count', 'unknown-count': 'unknown_count', 'unknown-sample': 'unknown_sample'}
def __init__(self, failed=None, migration_id=None, phase=None, success_count=None, unknown_count=None, unknown_sample=None, **unknown_fields):
'''
- failed : typing.Sequence<+T_co>[str]
+ failed : typing.Sequence[str]
migration_id : str
phase : str
success_count : int
unknown_count : int
- unknown_sample : typing.Sequence<+T_co>[str]
+ unknown_sample : typing.Sequence[str]
'''
self.failed = failed
self.migration_id = migration_id
+class ModelAccess(Type):
+ _toSchema = {'access': 'access', 'model': 'model'}
+ _toPy = {'access': 'access', 'model': 'model'}
+ def __init__(self, access=None, model=None, **unknown_fields):
+ '''
+ access : str
+ model : str
+ '''
+ self.access = access
+ self.model = model
+
+
+
class ModelArgs(Type):
_toSchema = {'model_tag': 'model-tag'}
_toPy = {'model-tag': 'model_tag'}
_toPy = {'blocks': 'blocks', 'model-uuid': 'model_uuid', 'name': 'name', 'owner-tag': 'owner_tag'}
def __init__(self, blocks=None, model_uuid=None, name=None, owner_tag=None, **unknown_fields):
'''
- blocks : typing.Sequence<+T_co>[str]
+ blocks : typing.Sequence[str]
model_uuid : str
name : str
owner_tag : str
_toPy = {'models': 'models'}
def __init__(self, models=None, **unknown_fields):
'''
- models : typing.Sequence<+T_co>[~ModelBlockInfo]<~ModelBlockInfo>
+ models : typing.Sequence[~ModelBlockInfo]
'''
self.models = [ModelBlockInfo.from_json(o) for o in models or []]
_toPy = {'config': 'config'}
def __init__(self, config=None, **unknown_fields):
'''
- config : typing.Mapping<~KT, +VT_co>[str, typing.Any]
+ config : typing.Mapping[str, typing.Any]
'''
self.config = config
_toPy = {'config': 'config'}
def __init__(self, config=None, **unknown_fields):
'''
- config : typing.Mapping<~KT, +VT_co>[str, ~ConfigValue]<~ConfigValue>
+ config : typing.Mapping[str, ~ConfigValue]
'''
self.config = config
def __init__(self, cloud_tag=None, config=None, credential=None, name=None, owner_tag=None, region=None, **unknown_fields):
'''
cloud_tag : str
- config : typing.Mapping<~KT, +VT_co>[str, typing.Any]
+ config : typing.Mapping[str, typing.Any]
credential : str
name : str
owner_tag : str
+class ModelCredential(Type):
+ _toSchema = {'credential_tag': 'credential-tag', 'exists': 'exists', 'model_tag': 'model-tag', 'valid': 'valid'}
+ _toPy = {'credential-tag': 'credential_tag', 'exists': 'exists', 'model-tag': 'model_tag', 'valid': 'valid'}
+ def __init__(self, credential_tag=None, exists=None, model_tag=None, valid=None, **unknown_fields):
+ '''
+ credential_tag : str
+ exists : bool
+ model_tag : str
+ valid : bool
+ '''
+ self.credential_tag = credential_tag
+ self.exists = exists
+ self.model_tag = model_tag
+ self.valid = valid
+
+
+
class ModelDefaultValues(Type):
_toSchema = {'cloud_region': 'cloud-region', 'cloud_tag': 'cloud-tag', 'config': 'config'}
_toPy = {'cloud-region': 'cloud_region', 'cloud-tag': 'cloud_tag', 'config': 'config'}
'''
cloud_region : str
cloud_tag : str
- config : typing.Mapping<~KT, +VT_co>[str, typing.Any]
+ config : typing.Mapping[str, typing.Any]
'''
self.cloud_region = cloud_region
self.cloud_tag = cloud_tag
_toPy = {'controller': 'controller', 'default': 'default', 'regions': 'regions'}
def __init__(self, controller=None, default=None, regions=None, **unknown_fields):
'''
- controller : typing.Mapping<~KT, +VT_co>[str, typing.Any]
- default : typing.Mapping<~KT, +VT_co>[str, typing.Any]
- regions : typing.Sequence<+T_co>[~RegionDefaults]<~RegionDefaults>
+ controller : typing.Mapping[str, typing.Any]
+ default : typing.Mapping[str, typing.Any]
+ regions : typing.Sequence[~RegionDefaults]
'''
self.controller = controller
self.default = default
_toPy = {'config': 'config'}
def __init__(self, config=None, **unknown_fields):
'''
- config : typing.Mapping<~KT, +VT_co>[str, ~ModelDefaults]<~ModelDefaults>
+ config : typing.Mapping[str, ~ModelDefaults]
'''
self.config = config
+class ModelEntityCount(Type):
+ _toSchema = {'count': 'count', 'entity': 'entity'}
+ _toPy = {'count': 'count', 'entity': 'entity'}
+ def __init__(self, count=None, entity=None, **unknown_fields):
+ '''
+ count : int
+ entity : str
+ '''
+ self.count = count
+ self.entity = entity
+
+
+
+class ModelFilesystemInfo(Type):
+ _toSchema = {'detachable': 'detachable', 'id_': 'id', 'message': 'message', 'provider_id': 'provider-id', 'status': 'status'}
+ _toPy = {'detachable': 'detachable', 'id': 'id_', 'message': 'message', 'provider-id': 'provider_id', 'status': 'status'}
+ def __init__(self, detachable=None, id_=None, message=None, provider_id=None, status=None, **unknown_fields):
+ '''
+ detachable : bool
+ id_ : str
+ message : str
+ provider_id : str
+ status : str
+ '''
+ self.detachable = detachable
+ self.id_ = id_
+ self.message = message
+ self.provider_id = provider_id
+ self.status = status
+
+
+
class ModelInfo(Type):
- _toSchema = {'agent_version': 'agent-version', 'cloud_credential_tag': 'cloud-credential-tag', 'cloud_region': 'cloud-region', 'cloud_tag': 'cloud-tag', 'controller_uuid': 'controller-uuid', 'default_series': 'default-series', 'life': 'life', 'machines': 'machines', 'migration': 'migration', 'name': 'name', 'owner_tag': 'owner-tag', 'provider_type': 'provider-type', 'sla': 'sla', 'status': 'status', 'users': 'users', 'uuid': 'uuid'}
- _toPy = {'agent-version': 'agent_version', 'cloud-credential-tag': 'cloud_credential_tag', 'cloud-region': 'cloud_region', 'cloud-tag': 'cloud_tag', 'controller-uuid': 'controller_uuid', 'default-series': 'default_series', 'life': 'life', 'machines': 'machines', 'migration': 'migration', 'name': 'name', 'owner-tag': 'owner_tag', 'provider-type': 'provider_type', 'sla': 'sla', 'status': 'status', 'users': 'users', 'uuid': 'uuid'}
- def __init__(self, agent_version=None, cloud_credential_tag=None, cloud_region=None, cloud_tag=None, controller_uuid=None, default_series=None, life=None, machines=None, migration=None, name=None, owner_tag=None, provider_type=None, sla=None, status=None, users=None, uuid=None, **unknown_fields):
+ _toSchema = {'agent_version': 'agent-version', 'cloud_credential_tag': 'cloud-credential-tag', 'cloud_region': 'cloud-region', 'cloud_tag': 'cloud-tag', 'controller_uuid': 'controller-uuid', 'default_series': 'default-series', 'life': 'life', 'machines': 'machines', 'migration': 'migration', 'name': 'name', 'owner_tag': 'owner-tag', 'provider_type': 'provider-type', 'sla': 'sla', 'status': 'status', 'type_': 'type', 'users': 'users', 'uuid': 'uuid'}
+ _toPy = {'agent-version': 'agent_version', 'cloud-credential-tag': 'cloud_credential_tag', 'cloud-region': 'cloud_region', 'cloud-tag': 'cloud_tag', 'controller-uuid': 'controller_uuid', 'default-series': 'default_series', 'life': 'life', 'machines': 'machines', 'migration': 'migration', 'name': 'name', 'owner-tag': 'owner_tag', 'provider-type': 'provider_type', 'sla': 'sla', 'status': 'status', 'type': 'type_', 'users': 'users', 'uuid': 'uuid'}
+ def __init__(self, agent_version=None, cloud_credential_tag=None, cloud_region=None, cloud_tag=None, controller_uuid=None, default_series=None, life=None, machines=None, migration=None, name=None, owner_tag=None, provider_type=None, sla=None, status=None, type_=None, users=None, uuid=None, **unknown_fields):
'''
agent_version : Number
cloud_credential_tag : str
controller_uuid : str
default_series : str
life : str
- machines : typing.Sequence<+T_co>[~ModelMachineInfo]<~ModelMachineInfo>
+ machines : typing.Sequence[~ModelMachineInfo]
migration : ModelMigrationStatus
name : str
owner_tag : str
provider_type : str
sla : ModelSLAInfo
status : EntityStatus
- users : typing.Sequence<+T_co>[~ModelUserInfo]<~ModelUserInfo>
+ type_ : str
+ users : typing.Sequence[~ModelUserInfo]
uuid : str
'''
self.agent_version = Number.from_json(agent_version) if agent_version else None
self.provider_type = provider_type
self.sla = ModelSLAInfo.from_json(sla) if sla else None
self.status = EntityStatus.from_json(status) if status else None
+ self.type_ = type_
self.users = [ModelUserInfo.from_json(o) for o in users or []]
self.uuid = uuid
_toPy = {'results': 'results'}
def __init__(self, results=None, **unknown_fields):
'''
- results : typing.Sequence<+T_co>[~ModelInfoResult]<~ModelInfoResult>
+ results : typing.Sequence[~ModelInfoResult]
'''
self.results = [ModelInfoResult.from_json(o) for o in results or []]
_toPy = {'constraints': 'constraints'}
def __init__(self, constraints=None, **unknown_fields):
'''
- constraints : typing.Sequence<+T_co>[~ModelInstanceTypesConstraint]<~ModelInstanceTypesConstraint>
+ constraints : typing.Sequence[~ModelInstanceTypesConstraint]
'''
self.constraints = [ModelInstanceTypesConstraint.from_json(o) for o in constraints or []]
_toPy = {'creds': 'creds', 'level': 'level'}
def __init__(self, creds=None, level=None, **unknown_fields):
'''
- creds : typing.Sequence<+T_co>[int]
+ creds : typing.Sequence[int]
level : str
'''
self.creds = creds
+class ModelSequencesResult(Type):
+ _toSchema = {'sequences': 'sequences'}
+ _toPy = {'sequences': 'sequences'}
+ def __init__(self, sequences=None, **unknown_fields):
+ '''
+ sequences : typing.Mapping[str, int]
+ '''
+ self.sequences = sequences
+
+
+
class ModelSet(Type):
_toSchema = {'config': 'config'}
_toPy = {'config': 'config'}
def __init__(self, config=None, **unknown_fields):
'''
- config : typing.Mapping<~KT, +VT_co>[str, typing.Any]
+ config : typing.Mapping[str, typing.Any]
'''
self.config = config
application_count : int
hosted_machine_count : int
life : str
- machines : typing.Sequence<+T_co>[~ModelMachineInfo]<~ModelMachineInfo>
+ machines : typing.Sequence[~ModelMachineInfo]
model_tag : str
owner_tag : str
'''
class ModelStatusInfo(Type):
- _toSchema = {'available_version': 'available-version', 'cloud_tag': 'cloud-tag', 'meter_status': 'meter-status', 'model_status': 'model-status', 'name': 'name', 'region': 'region', 'sla': 'sla', 'version': 'version'}
- _toPy = {'available-version': 'available_version', 'cloud-tag': 'cloud_tag', 'meter-status': 'meter_status', 'model-status': 'model_status', 'name': 'name', 'region': 'region', 'sla': 'sla', 'version': 'version'}
- def __init__(self, available_version=None, cloud_tag=None, meter_status=None, model_status=None, name=None, region=None, sla=None, version=None, **unknown_fields):
+ _toSchema = {'available_version': 'available-version', 'cloud_tag': 'cloud-tag', 'meter_status': 'meter-status', 'model_status': 'model-status', 'name': 'name', 'region': 'region', 'sla': 'sla', 'type_': 'type', 'version': 'version'}
+ _toPy = {'available-version': 'available_version', 'cloud-tag': 'cloud_tag', 'meter-status': 'meter_status', 'model-status': 'model_status', 'name': 'name', 'region': 'region', 'sla': 'sla', 'type': 'type_', 'version': 'version'}
+ def __init__(self, available_version=None, cloud_tag=None, meter_status=None, model_status=None, name=None, region=None, sla=None, type_=None, version=None, **unknown_fields):
'''
available_version : str
cloud_tag : str
name : str
region : str
sla : str
+ type_ : str
version : str
'''
self.available_version = available_version
self.name = name
self.region = region
self.sla = sla
+ self.type_ = type_
self.version = version
_toPy = {'models': 'models'}
def __init__(self, models=None, **unknown_fields):
'''
- models : typing.Sequence<+T_co>[~ModelStatus]<~ModelStatus>
+ models : typing.Sequence[~ModelStatus]
'''
self.models = [ModelStatus.from_json(o) for o in models or []]
+class ModelSummariesRequest(Type):
+ _toSchema = {'all_': 'all', 'user_tag': 'user-tag'}
+ _toPy = {'all': 'all_', 'user-tag': 'user_tag'}
+ def __init__(self, all_=None, user_tag=None, **unknown_fields):
+ '''
+ all_ : bool
+ user_tag : str
+ '''
+ self.all_ = all_
+ self.user_tag = user_tag
+
+
+
+class ModelSummary(Type):
+ _toSchema = {'agent_version': 'agent-version', 'cloud_credential_tag': 'cloud-credential-tag', 'cloud_region': 'cloud-region', 'cloud_tag': 'cloud-tag', 'controller_uuid': 'controller-uuid', 'counts': 'counts', 'default_series': 'default-series', 'last_connection': 'last-connection', 'life': 'life', 'migration': 'migration', 'name': 'name', 'owner_tag': 'owner-tag', 'provider_type': 'provider-type', 'sla': 'sla', 'status': 'status', 'type_': 'type', 'user_access': 'user-access', 'uuid': 'uuid'}
+ _toPy = {'agent-version': 'agent_version', 'cloud-credential-tag': 'cloud_credential_tag', 'cloud-region': 'cloud_region', 'cloud-tag': 'cloud_tag', 'controller-uuid': 'controller_uuid', 'counts': 'counts', 'default-series': 'default_series', 'last-connection': 'last_connection', 'life': 'life', 'migration': 'migration', 'name': 'name', 'owner-tag': 'owner_tag', 'provider-type': 'provider_type', 'sla': 'sla', 'status': 'status', 'type': 'type_', 'user-access': 'user_access', 'uuid': 'uuid'}
+ def __init__(self, agent_version=None, cloud_credential_tag=None, cloud_region=None, cloud_tag=None, controller_uuid=None, counts=None, default_series=None, last_connection=None, life=None, migration=None, name=None, owner_tag=None, provider_type=None, sla=None, status=None, type_=None, user_access=None, uuid=None, **unknown_fields):
+ '''
+ agent_version : Number
+ cloud_credential_tag : str
+ cloud_region : str
+ cloud_tag : str
+ controller_uuid : str
+ counts : typing.Sequence[~ModelEntityCount]
+ default_series : str
+ last_connection : str
+ life : str
+ migration : ModelMigrationStatus
+ name : str
+ owner_tag : str
+ provider_type : str
+ sla : ModelSLAInfo
+ status : EntityStatus
+ type_ : str
+ user_access : str
+ uuid : str
+ '''
+ self.agent_version = Number.from_json(agent_version) if agent_version else None
+ self.cloud_credential_tag = cloud_credential_tag
+ self.cloud_region = cloud_region
+ self.cloud_tag = cloud_tag
+ self.controller_uuid = controller_uuid
+ self.counts = [ModelEntityCount.from_json(o) for o in counts or []]
+ self.default_series = default_series
+ self.last_connection = last_connection
+ self.life = life
+ self.migration = ModelMigrationStatus.from_json(migration) if migration else None
+ self.name = name
+ self.owner_tag = owner_tag
+ self.provider_type = provider_type
+ self.sla = ModelSLAInfo.from_json(sla) if sla else None
+ self.status = EntityStatus.from_json(status) if status else None
+ self.type_ = type_
+ self.user_access = user_access
+ self.uuid = uuid
+
+
+
+class ModelSummaryResult(Type):
+ _toSchema = {'error': 'error', 'result': 'result'}
+ _toPy = {'error': 'error', 'result': 'result'}
+ def __init__(self, error=None, result=None, **unknown_fields):
+ '''
+ error : Error
+ result : ModelSummary
+ '''
+ self.error = Error.from_json(error) if error else None
+ self.result = ModelSummary.from_json(result) if result else None
+
+
+
+class ModelSummaryResults(Type):
+ _toSchema = {'results': 'results'}
+ _toPy = {'results': 'results'}
+ def __init__(self, results=None, **unknown_fields):
+ '''
+ results : typing.Sequence[~ModelSummaryResult]
+ '''
+ self.results = [ModelSummaryResult.from_json(o) for o in results or []]
+
+
+
class ModelTag(Type):
_toSchema = {}
_toPy = {}
_toPy = {'keys': 'keys'}
def __init__(self, keys=None, **unknown_fields):
'''
- keys : typing.Sequence<+T_co>[str]
+ keys : typing.Sequence[str]
'''
self.keys = keys
'''
cloud_region : str
cloud_tag : str
- keys : typing.Sequence<+T_co>[str]
+ keys : typing.Sequence[str]
'''
self.cloud_region = cloud_region
self.cloud_tag = cloud_tag
_toPy = {'results': 'results'}
def __init__(self, results=None, **unknown_fields):
'''
- results : typing.Sequence<+T_co>[~ModelUserInfoResult]<~ModelUserInfoResult>
+ results : typing.Sequence[~ModelUserInfoResult]
'''
self.results = [ModelUserInfoResult.from_json(o) for o in results or []]
+class ModelVolumeInfo(Type):
+ _toSchema = {'detachable': 'detachable', 'id_': 'id', 'message': 'message', 'provider_id': 'provider-id', 'status': 'status'}
+ _toPy = {'detachable': 'detachable', 'id': 'id_', 'message': 'message', 'provider-id': 'provider_id', 'status': 'status'}
+ def __init__(self, detachable=None, id_=None, message=None, provider_id=None, status=None, **unknown_fields):
+ '''
+ detachable : bool
+ id_ : str
+ message : str
+ provider_id : str
+ status : str
+ '''
+ self.detachable = detachable
+ self.id_ = id_
+ self.message = message
+ self.provider_id = provider_id
+ self.status = status
+
+
+
+class ModifyCloudAccess(Type):
+ _toSchema = {'access': 'access', 'action': 'action', 'cloud_tag': 'cloud-tag', 'user_tag': 'user-tag'}
+ _toPy = {'access': 'access', 'action': 'action', 'cloud-tag': 'cloud_tag', 'user-tag': 'user_tag'}
+ def __init__(self, access=None, action=None, cloud_tag=None, user_tag=None, **unknown_fields):
+ '''
+ access : str
+ action : str
+ cloud_tag : str
+ user_tag : str
+ '''
+ self.access = access
+ self.action = action
+ self.cloud_tag = cloud_tag
+ self.user_tag = user_tag
+
+
+
+class ModifyCloudAccessRequest(Type):
+ _toSchema = {'changes': 'changes'}
+ _toPy = {'changes': 'changes'}
+ def __init__(self, changes=None, **unknown_fields):
+ '''
+ changes : typing.Sequence[~ModifyCloudAccess]
+ '''
+ self.changes = [ModifyCloudAccess.from_json(o) for o in changes or []]
+
+
+
class ModifyControllerAccess(Type):
_toSchema = {'access': 'access', 'action': 'action', 'user_tag': 'user-tag'}
_toPy = {'access': 'access', 'action': 'action', 'user-tag': 'user_tag'}
_toPy = {'changes': 'changes'}
def __init__(self, changes=None, **unknown_fields):
'''
- changes : typing.Sequence<+T_co>[~ModifyControllerAccess]<~ModifyControllerAccess>
+ changes : typing.Sequence[~ModifyControllerAccess]
'''
self.changes = [ModifyControllerAccess.from_json(o) for o in changes or []]
_toPy = {'changes': 'changes'}
def __init__(self, changes=None, **unknown_fields):
'''
- changes : typing.Sequence<+T_co>[~ModifyModelAccess]<~ModifyModelAccess>
+ changes : typing.Sequence[~ModifyModelAccess]
'''
self.changes = [ModifyModelAccess.from_json(o) for o in changes or []]
+class ModifyOfferAccess(Type):
+ _toSchema = {'access': 'access', 'action': 'action', 'offer_url': 'offer-url', 'user_tag': 'user-tag'}
+ _toPy = {'access': 'access', 'action': 'action', 'offer-url': 'offer_url', 'user-tag': 'user_tag'}
+ def __init__(self, access=None, action=None, offer_url=None, user_tag=None, **unknown_fields):
+ '''
+ access : str
+ action : str
+ offer_url : str
+ user_tag : str
+ '''
+ self.access = access
+ self.action = action
+ self.offer_url = offer_url
+ self.user_tag = user_tag
+
+
+
+class ModifyOfferAccessRequest(Type):
+ _toSchema = {'changes': 'changes'}
+ _toPy = {'changes': 'changes'}
+ def __init__(self, changes=None, **unknown_fields):
+ '''
+ changes : typing.Sequence[~ModifyOfferAccess]
+ '''
+ self.changes = [ModifyOfferAccess.from_json(o) for o in changes or []]
+
+
+
class ModifyUserSSHKeys(Type):
_toSchema = {'ssh_keys': 'ssh-keys', 'user': 'user'}
_toPy = {'ssh-keys': 'ssh_keys', 'user': 'user'}
def __init__(self, ssh_keys=None, user=None, **unknown_fields):
'''
- ssh_keys : typing.Sequence<+T_co>[str]
+ ssh_keys : typing.Sequence[str]
user : str
'''
self.ssh_keys = ssh_keys
_toPy = {'ha-members': 'ha_members', 'master': 'master', 'rs-members': 'rs_members'}
def __init__(self, ha_members=None, master=None, rs_members=None, **unknown_fields):
'''
- ha_members : typing.Sequence<+T_co>[~HAMember]<~HAMember>
+ ha_members : typing.Sequence[~HAMember]
master : HAMember
- rs_members : typing.Sequence<+T_co>[~Member]<~Member>
+ rs_members : typing.Sequence[~Member]
'''
self.ha_members = [HAMember.from_json(o) for o in ha_members or []]
self.master = HAMember.from_json(master) if master else None
config_type : str
device_index : int
disabled : bool
- dns_search_domains : typing.Sequence<+T_co>[str]
- dns_servers : typing.Sequence<+T_co>[str]
+ dns_search_domains : typing.Sequence[str]
+ dns_servers : typing.Sequence[str]
gateway_address : str
interface_name : str
interface_type : str
_toPy = {'addresses': 'addresses', 'interface-name': 'interface_name', 'mac-address': 'mac_address'}
def __init__(self, addresses=None, interface_name=None, mac_address=None, **unknown_fields):
'''
- addresses : typing.Sequence<+T_co>[~InterfaceAddress]<~InterfaceAddress>
+ addresses : typing.Sequence[~InterfaceAddress]
interface_name : str
mac_address : str
'''
_toPy = {'bindings': 'bindings', 'unit': 'unit'}
def __init__(self, bindings=None, unit=None, **unknown_fields):
'''
- bindings : typing.Sequence<+T_co>[str]
+ bindings : typing.Sequence[str]
unit : str
'''
self.bindings = bindings
def __init__(self, error=None, network_info=None, **unknown_fields):
'''
error : Error
- network_info : typing.Sequence<+T_co>[~NetworkInfo]<~NetworkInfo>
+ network_info : typing.Sequence[~NetworkInfo]
'''
self.error = Error.from_json(error) if error else None
self.network_info = [NetworkInfo.from_json(o) for o in network_info or []]
_toPy = {'results': 'results'}
def __init__(self, results=None, **unknown_fields):
'''
- results : typing.Mapping<~KT, +VT_co>[str, ~NetworkInfoResult]<~NetworkInfoResult>
+ results : typing.Mapping[str, ~NetworkInfoResult]
'''
self.results = results
_toPy = {'dns-nameservers': 'dns_nameservers', 'gateway': 'gateway', 'ip-addresses': 'ip_addresses', 'is-up': 'is_up', 'mac-address': 'mac_address', 'space': 'space'}
def __init__(self, dns_nameservers=None, gateway=None, ip_addresses=None, is_up=None, mac_address=None, space=None, **unknown_fields):
'''
- dns_nameservers : typing.Sequence<+T_co>[str]
+ dns_nameservers : typing.Sequence[str]
gateway : str
- ip_addresses : typing.Sequence<+T_co>[str]
+ ip_addresses : typing.Sequence[str]
is_up : bool
mac_address : str
space : str
_toPy = {'results': 'results'}
def __init__(self, results=None, **unknown_fields):
'''
- results : typing.Sequence<+T_co>[~NotifyWatchResult]<~NotifyWatchResult>
+ results : typing.Sequence[~NotifyWatchResult]
'''
self.results = [NotifyWatchResult.from_json(o) for o in results or []]
+class OfferArg(Type):
+ _toSchema = {'macaroons': 'macaroons', 'offer_uuid': 'offer-uuid'}
+ _toPy = {'macaroons': 'macaroons', 'offer-uuid': 'offer_uuid'}
+ def __init__(self, macaroons=None, offer_uuid=None, **unknown_fields):
+ '''
+ macaroons : typing.Sequence[~Macaroon]
+ offer_uuid : str
+ '''
+ self.macaroons = [Macaroon.from_json(o) for o in macaroons or []]
+ self.offer_uuid = offer_uuid
+
+
+
+class OfferArgs(Type):
+ _toSchema = {'args': 'args'}
+ _toPy = {'args': 'args'}
+ def __init__(self, args=None, **unknown_fields):
+ '''
+ args : typing.Sequence[~OfferArg]
+ '''
+ self.args = [OfferArg.from_json(o) for o in args or []]
+
+
+
+class OfferConnection(Type):
+ _toSchema = {'endpoint': 'endpoint', 'ingress_subnets': 'ingress-subnets', 'relation_id': 'relation-id', 'source_model_tag': 'source-model-tag', 'status': 'status', 'username': 'username'}
+ _toPy = {'endpoint': 'endpoint', 'ingress-subnets': 'ingress_subnets', 'relation-id': 'relation_id', 'source-model-tag': 'source_model_tag', 'status': 'status', 'username': 'username'}
+ def __init__(self, endpoint=None, ingress_subnets=None, relation_id=None, source_model_tag=None, status=None, username=None, **unknown_fields):
+ '''
+ endpoint : str
+ ingress_subnets : typing.Sequence[str]
+ relation_id : int
+ source_model_tag : str
+ status : EntityStatus
+ username : str
+ '''
+ self.endpoint = endpoint
+ self.ingress_subnets = ingress_subnets
+ self.relation_id = relation_id
+ self.source_model_tag = source_model_tag
+ self.status = EntityStatus.from_json(status) if status else None
+ self.username = username
+
+
+
+class OfferFilter(Type):
+ _toSchema = {'allowed_users': 'allowed-users', 'application_description': 'application-description', 'application_name': 'application-name', 'application_user': 'application-user', 'connected_users': 'connected-users', 'endpoints': 'endpoints', 'model_name': 'model-name', 'offer_name': 'offer-name', 'owner_name': 'owner-name'}
+ _toPy = {'allowed-users': 'allowed_users', 'application-description': 'application_description', 'application-name': 'application_name', 'application-user': 'application_user', 'connected-users': 'connected_users', 'endpoints': 'endpoints', 'model-name': 'model_name', 'offer-name': 'offer_name', 'owner-name': 'owner_name'}
+ def __init__(self, allowed_users=None, application_description=None, application_name=None, application_user=None, connected_users=None, endpoints=None, model_name=None, offer_name=None, owner_name=None, **unknown_fields):
+ '''
+ allowed_users : typing.Sequence[str]
+ application_description : str
+ application_name : str
+ application_user : str
+ connected_users : typing.Sequence[str]
+ endpoints : typing.Sequence[~EndpointFilterAttributes]
+ model_name : str
+ offer_name : str
+ owner_name : str
+ '''
+ self.allowed_users = allowed_users
+ self.application_description = application_description
+ self.application_name = application_name
+ self.application_user = application_user
+ self.connected_users = connected_users
+ self.endpoints = [EndpointFilterAttributes.from_json(o) for o in endpoints or []]
+ self.model_name = model_name
+ self.offer_name = offer_name
+ self.owner_name = owner_name
+
+
+
+class OfferFilters(Type):
+ _toSchema = {'filters': 'Filters'}
+ _toPy = {'Filters': 'filters'}
+ def __init__(self, filters=None, **unknown_fields):
+ '''
+ filters : typing.Sequence[~OfferFilter]
+ '''
+ self.filters = [OfferFilter.from_json(o) for o in filters or []]
+
+
+
+class OfferStatusChange(Type):
+ _toSchema = {'offer_name': 'offer-name', 'status': 'status'}
+ _toPy = {'offer-name': 'offer_name', 'status': 'status'}
+ def __init__(self, offer_name=None, status=None, **unknown_fields):
+ '''
+ offer_name : str
+ status : EntityStatus
+ '''
+ self.offer_name = offer_name
+ self.status = EntityStatus.from_json(status) if status else None
+
+
+
+class OfferStatusWatchResult(Type):
+ _toSchema = {'changes': 'changes', 'error': 'error', 'watcher_id': 'watcher-id'}
+ _toPy = {'changes': 'changes', 'error': 'error', 'watcher-id': 'watcher_id'}
+ def __init__(self, changes=None, error=None, watcher_id=None, **unknown_fields):
+ '''
+ changes : typing.Sequence[~OfferStatusChange]
+ error : Error
+ watcher_id : str
+ '''
+ self.changes = [OfferStatusChange.from_json(o) for o in changes or []]
+ self.error = Error.from_json(error) if error else None
+ self.watcher_id = watcher_id
+
+
+
+class OfferStatusWatchResults(Type):
+ _toSchema = {'results': 'results'}
+ _toPy = {'results': 'results'}
+ def __init__(self, results=None, **unknown_fields):
+ '''
+ results : typing.Sequence[~OfferStatusWatchResult]
+ '''
+ self.results = [OfferStatusWatchResult.from_json(o) for o in results or []]
+
+
+
+class OfferURLs(Type):
+ _toSchema = {'offer_urls': 'offer-urls'}
+ _toPy = {'offer-urls': 'offer_urls'}
+ def __init__(self, offer_urls=None, **unknown_fields):
+ '''
+ offer_urls : typing.Sequence[str]
+ '''
+ self.offer_urls = offer_urls
+
+
+
+class OfferUserDetails(Type):
+ _toSchema = {'access': 'access', 'display_name': 'display-name', 'user': 'user'}
+ _toPy = {'access': 'access', 'display-name': 'display_name', 'user': 'user'}
+ def __init__(self, access=None, display_name=None, user=None, **unknown_fields):
+ '''
+ access : str
+ display_name : str
+ user : str
+ '''
+ self.access = access
+ self.display_name = display_name
+ self.user = user
+
+
+
+class OperatorProvisioningInfo(Type):
+ _toSchema = {'api_addresses': 'api-addresses', 'charm_storage': 'charm-storage', 'image_path': 'image-path', 'tags': 'tags', 'version': 'version'}
+ _toPy = {'api-addresses': 'api_addresses', 'charm-storage': 'charm_storage', 'image-path': 'image_path', 'tags': 'tags', 'version': 'version'}
+ def __init__(self, api_addresses=None, charm_storage=None, image_path=None, tags=None, version=None, **unknown_fields):
+ '''
+ api_addresses : typing.Sequence[str]
+ charm_storage : KubernetesFilesystemParams
+ image_path : str
+ tags : typing.Mapping[str, str]
+ version : Number
+ '''
+ self.api_addresses = api_addresses
+ self.charm_storage = KubernetesFilesystemParams.from_json(charm_storage) if charm_storage else None
+ self.image_path = image_path
+ self.tags = tags
+ self.version = Number.from_json(version) if version else None
+
+
+
class Payload(Type):
_toSchema = {'class_': 'class', 'id_': 'id', 'labels': 'labels', 'machine': 'machine', 'status': 'status', 'type_': 'type', 'unit': 'unit'}
_toPy = {'class': 'class_', 'id': 'id_', 'labels': 'labels', 'machine': 'machine', 'status': 'status', 'type': 'type_', 'unit': 'unit'}
'''
class_ : str
id_ : str
- labels : typing.Sequence<+T_co>[str]
+ labels : typing.Sequence[str]
machine : str
status : str
type_ : str
_toPy = {'patterns': 'patterns'}
def __init__(self, patterns=None, **unknown_fields):
'''
- patterns : typing.Sequence<+T_co>[str]
+ patterns : typing.Sequence[str]
'''
self.patterns = patterns
_toPy = {'results': 'results'}
def __init__(self, results=None, **unknown_fields):
'''
- results : typing.Sequence<+T_co>[~Payload]<~Payload>
+ results : typing.Sequence[~Payload]
'''
self.results = [Payload.from_json(o) for o in results or []]
_toPy = {'results': 'results'}
def __init__(self, results=None, **unknown_fields):
'''
- results : typing.Sequence<+T_co>[~PayloadResult]<~PayloadResult>
+ results : typing.Sequence[~PayloadResult]
'''
self.results = [PayloadResult.from_json(o) for o in results or []]
_toPy = {'results': 'results'}
def __init__(self, results=None, **unknown_fields):
'''
- results : typing.Sequence<+T_co>[~PhaseResult]<~PhaseResult>
+ results : typing.Sequence[~PhaseResult]
'''
self.results = [PhaseResult.from_json(o) for o in results or []]
+class PinApplicationResult(Type):
+ _toSchema = {'application_name': 'application-name', 'error': 'error'}
+ _toPy = {'application-name': 'application_name', 'error': 'error'}
+ def __init__(self, application_name=None, error=None, **unknown_fields):
+ '''
+ application_name : str
+ error : Error
+ '''
+ self.application_name = application_name
+ self.error = Error.from_json(error) if error else None
+
+
+
+class PinApplicationsResults(Type):
+ _toSchema = {'results': 'results'}
+ _toPy = {'results': 'results'}
+ def __init__(self, results=None, **unknown_fields):
+ '''
+ results : typing.Sequence[~PinApplicationResult]
+ '''
+ self.results = [PinApplicationResult.from_json(o) for o in results or []]
+
+
+
+class PinnedLeadershipResult(Type):
+ _toSchema = {'result': 'result'}
+ _toPy = {'result': 'result'}
+ def __init__(self, result=None, **unknown_fields):
+ '''
+ result : typing.Sequence[str]
+ '''
+ self.result = result
+
+
+
class Placement(Type):
_toSchema = {'directive': 'directive', 'scope': 'scope'}
_toPy = {'directive': 'directive', 'scope': 'scope'}
+class ProfileChangeResult(Type):
+ _toSchema = {'error': 'error', 'new_profile_name': 'new-profile-name', 'old_profile_name': 'old-profile-name', 'profile': 'profile', 'subordinate': 'subordinate'}
+ _toPy = {'error': 'error', 'new-profile-name': 'new_profile_name', 'old-profile-name': 'old_profile_name', 'profile': 'profile', 'subordinate': 'subordinate'}
+ def __init__(self, error=None, new_profile_name=None, old_profile_name=None, profile=None, subordinate=None, **unknown_fields):
+ '''
+ error : Error
+ new_profile_name : str
+ old_profile_name : str
+ profile : CharmLXDProfile
+ subordinate : bool
+ '''
+ self.error = Error.from_json(error) if error else None
+ self.new_profile_name = new_profile_name
+ self.old_profile_name = old_profile_name
+ self.profile = CharmLXDProfile.from_json(profile) if profile else None
+ self.subordinate = subordinate
+
+
+
+class ProfileChangeResults(Type):
+ _toSchema = {'results': 'results'}
+ _toPy = {'results': 'results'}
+ def __init__(self, results=None, **unknown_fields):
+ '''
+ results : typing.Sequence[~ProfileChangeResult]
+ '''
+ self.results = [ProfileChangeResult.from_json(o) for o in results or []]
+
+
+
class ProviderInterfaceInfo(Type):
_toSchema = {'interface_name': 'interface-name', 'mac_address': 'mac-address', 'provider_id': 'provider-id'}
_toPy = {'interface-name': 'interface_name', 'mac-address': 'mac_address', 'provider-id': 'provider_id'}
def __init__(self, error=None, interfaces=None, machine_tag=None, **unknown_fields):
'''
error : Error
- interfaces : typing.Sequence<+T_co>[~ProviderInterfaceInfo]<~ProviderInterfaceInfo>
+ interfaces : typing.Sequence[~ProviderInterfaceInfo]
machine_tag : str
'''
self.error = Error.from_json(error) if error else None
_toPy = {'results': 'results'}
def __init__(self, results=None, **unknown_fields):
'''
- results : typing.Sequence<+T_co>[~ProviderInterfaceInfoResult]<~ProviderInterfaceInfoResult>
+ results : typing.Sequence[~ProviderInterfaceInfoResult]
'''
self.results = [ProviderInterfaceInfoResult.from_json(o) for o in results or []]
error : Error
name : str
provider_id : str
- subnets : typing.Sequence<+T_co>[~Subnet]<~Subnet>
+ subnets : typing.Sequence[~Subnet]
'''
self.error = Error.from_json(error) if error else None
self.name = name
def __init__(self, constraints=None, controller_config=None, endpoint_bindings=None, image_metadata=None, jobs=None, placement=None, series=None, subnets_to_zones=None, tags=None, volumes=None, **unknown_fields):
'''
constraints : Value
- controller_config : typing.Mapping<~KT, +VT_co>[str, typing.Any]
- endpoint_bindings : typing.Mapping<~KT, +VT_co>[str, str]
- image_metadata : typing.Sequence<+T_co>[~CloudImageMetadata]<~CloudImageMetadata>
- jobs : typing.Sequence<+T_co>[str]
+ controller_config : typing.Mapping[str, typing.Any]
+ endpoint_bindings : typing.Mapping[str, str]
+ image_metadata : typing.Sequence[~CloudImageMetadata]
+ jobs : typing.Sequence[str]
placement : str
series : str
- subnets_to_zones : typing.Sequence<+T_co>[str]
- tags : typing.Mapping<~KT, +VT_co>[str, str]
- volumes : typing.Sequence<+T_co>[~VolumeParams]<~VolumeParams>
+ subnets_to_zones : typing.Sequence[str]
+ tags : typing.Mapping[str, str]
+ volumes : typing.Sequence[~VolumeParams]
'''
self.constraints = Value.from_json(constraints) if constraints else None
self.controller_config = controller_config
_toPy = {'results': 'results'}
def __init__(self, results=None, **unknown_fields):
'''
- results : typing.Sequence<+T_co>[~ProvisioningInfoResult]<~ProvisioningInfoResult>
+ results : typing.Sequence[~ProvisioningInfoResult]
'''
self.results = [ProvisioningInfoResult.from_json(o) for o in results or []]
_toPy = {'results': 'results'}
def __init__(self, results=None, **unknown_fields):
'''
- results : typing.Sequence<+T_co>[~ProxyConfigResult]<~ProxyConfigResult>
+ results : typing.Sequence[~ProxyConfigResult]
'''
self.results = [ProxyConfigResult.from_json(o) for o in results or []]
+class QueryApplicationOffersResults(Type):
+ _toSchema = {'results': 'results'}
+ _toPy = {'results': 'results'}
+ def __init__(self, results=None, **unknown_fields):
+ '''
+ results : typing.Sequence[~ApplicationOfferAdminDetails]
+ '''
+ self.results = [ApplicationOfferAdminDetails.from_json(o) for o in results or []]
+
+
+
class RebootActionResult(Type):
_toSchema = {'error': 'error', 'result': 'result'}
_toPy = {'error': 'error', 'result': 'result'}
_toPy = {'results': 'results'}
def __init__(self, results=None, **unknown_fields):
'''
- results : typing.Sequence<+T_co>[~RebootActionResult]<~RebootActionResult>
+ results : typing.Sequence[~RebootActionResult]
'''
self.results = [RebootActionResult.from_json(o) for o in results or []]
def __init__(self, region_name=None, value=None, **unknown_fields):
'''
region_name : str
- value : typing.Mapping<~KT, +VT_co>[str, typing.Any]
+ value : typing.Mapping[str, typing.Any]
'''
self.region_name = region_name
self.value = value
+class RegisterRemoteRelationArg(Type):
+ _toSchema = {'application_token': 'application-token', 'local_endpoint_name': 'local-endpoint-name', 'macaroons': 'macaroons', 'offer_uuid': 'offer-uuid', 'relation_token': 'relation-token', 'remote_endpoint': 'remote-endpoint', 'remote_space': 'remote-space', 'source_model_tag': 'source-model-tag'}
+ _toPy = {'application-token': 'application_token', 'local-endpoint-name': 'local_endpoint_name', 'macaroons': 'macaroons', 'offer-uuid': 'offer_uuid', 'relation-token': 'relation_token', 'remote-endpoint': 'remote_endpoint', 'remote-space': 'remote_space', 'source-model-tag': 'source_model_tag'}
+ def __init__(self, application_token=None, local_endpoint_name=None, macaroons=None, offer_uuid=None, relation_token=None, remote_endpoint=None, remote_space=None, source_model_tag=None, **unknown_fields):
+ '''
+ application_token : str
+ local_endpoint_name : str
+ macaroons : typing.Sequence[~Macaroon]
+ offer_uuid : str
+ relation_token : str
+ remote_endpoint : RemoteEndpoint
+ remote_space : RemoteSpace
+ source_model_tag : str
+ '''
+ self.application_token = application_token
+ self.local_endpoint_name = local_endpoint_name
+ self.macaroons = [Macaroon.from_json(o) for o in macaroons or []]
+ self.offer_uuid = offer_uuid
+ self.relation_token = relation_token
+ self.remote_endpoint = RemoteEndpoint.from_json(remote_endpoint) if remote_endpoint else None
+ self.remote_space = RemoteSpace.from_json(remote_space) if remote_space else None
+ self.source_model_tag = source_model_tag
+
+
+
+class RegisterRemoteRelationArgs(Type):
+ _toSchema = {'relations': 'relations'}
+ _toPy = {'relations': 'relations'}
+ def __init__(self, relations=None, **unknown_fields):
+ '''
+ relations : typing.Sequence[~RegisterRemoteRelationArg]
+ '''
+ self.relations = [RegisterRemoteRelationArg.from_json(o) for o in relations or []]
+
+
+
+class RegisterRemoteRelationResult(Type):
+ _toSchema = {'error': 'error', 'result': 'result'}
+ _toPy = {'error': 'error', 'result': 'result'}
+ def __init__(self, error=None, result=None, **unknown_fields):
+ '''
+ error : Error
+ result : RemoteRelationDetails
+ '''
+ self.error = Error.from_json(error) if error else None
+ self.result = RemoteRelationDetails.from_json(result) if result else None
+
+
+
+class RegisterRemoteRelationResults(Type):
+ _toSchema = {'results': 'results'}
+ _toPy = {'results': 'results'}
+ def __init__(self, results=None, **unknown_fields):
+ '''
+ results : typing.Sequence[~RegisterRemoteRelationResult]
+ '''
+ self.results = [RegisterRemoteRelationResult.from_json(o) for o in results or []]
+
+
+
class RelationChange(Type):
_toSchema = {'changedunits': 'changedunits', 'departedunits': 'departedunits', 'id_': 'id', 'life': 'life'}
_toPy = {'changedunits': 'changedunits', 'departedunits': 'departedunits', 'id': 'id_', 'life': 'life'}
def __init__(self, changedunits=None, departedunits=None, id_=None, life=None, **unknown_fields):
'''
- changedunits : typing.Mapping<~KT, +VT_co>[str, ~RelationUnitChange]<~RelationUnitChange>
- departedunits : typing.Sequence<+T_co>[str]
+ changedunits : typing.Mapping[str, ~RelationUnitChange]
+ departedunits : typing.Sequence[str]
id_ : int
life : str
'''
_toPy = {'relation-ids': 'relation_ids'}
def __init__(self, relation_ids=None, **unknown_fields):
'''
- relation_ids : typing.Sequence<+T_co>[int]
+ relation_ids : typing.Sequence[int]
'''
self.relation_ids = relation_ids
+class RelationLifeSuspendedStatusChange(Type):
+ _toSchema = {'key': 'key', 'life': 'life', 'suspended': 'suspended', 'suspended_reason': 'suspended-reason'}
+ _toPy = {'key': 'key', 'life': 'life', 'suspended': 'suspended', 'suspended-reason': 'suspended_reason'}
+ def __init__(self, key=None, life=None, suspended=None, suspended_reason=None, **unknown_fields):
+ '''
+ key : str
+ life : str
+ suspended : bool
+ suspended_reason : str
+ '''
+ self.key = key
+ self.life = life
+ self.suspended = suspended
+ self.suspended_reason = suspended_reason
+
+
+
+class RelationLifeSuspendedStatusWatchResult(Type):
+ _toSchema = {'changes': 'changes', 'error': 'error', 'watcher_id': 'watcher-id'}
+ _toPy = {'changes': 'changes', 'error': 'error', 'watcher-id': 'watcher_id'}
+ def __init__(self, changes=None, error=None, watcher_id=None, **unknown_fields):
+ '''
+ changes : typing.Sequence[~RelationLifeSuspendedStatusChange]
+ error : Error
+ watcher_id : str
+ '''
+ self.changes = [RelationLifeSuspendedStatusChange.from_json(o) for o in changes or []]
+ self.error = Error.from_json(error) if error else None
+ self.watcher_id = watcher_id
+
+
+
class RelationResult(Type):
_toSchema = {'endpoint': 'endpoint', 'error': 'error', 'id_': 'id', 'key': 'key', 'life': 'life'}
_toPy = {'endpoint': 'endpoint', 'error': 'error', 'id': 'id_', 'key': 'key', 'life': 'life'}
_toPy = {'results': 'results'}
def __init__(self, results=None, **unknown_fields):
'''
- results : typing.Sequence<+T_co>[~RelationResult]<~RelationResult>
+ results : typing.Sequence[~RelationResult]
'''
self.results = [RelationResult.from_json(o) for o in results or []]
_toPy = {'endpoints': 'endpoints', 'id': 'id_', 'interface': 'interface', 'key': 'key', 'scope': 'scope'}
def __init__(self, endpoints=None, id_=None, interface=None, key=None, scope=None, **unknown_fields):
'''
- endpoints : typing.Sequence<+T_co>[~EndpointStatus]<~EndpointStatus>
+ endpoints : typing.Sequence[~EndpointStatus]
id_ : int
interface : str
key : str
+class RelationStatusArg(Type):
+ _toSchema = {'message': 'message', 'relation_id': 'relation-id', 'status': 'status', 'unit_tag': 'unit-tag'}
+ _toPy = {'message': 'message', 'relation-id': 'relation_id', 'status': 'status', 'unit-tag': 'unit_tag'}
+ def __init__(self, message=None, relation_id=None, status=None, unit_tag=None, **unknown_fields):
+ '''
+ message : str
+ relation_id : int
+ status : str
+ unit_tag : str
+ '''
+ self.message = message
+ self.relation_id = relation_id
+ self.status = status
+ self.unit_tag = unit_tag
+
+
+
+class RelationStatusArgs(Type):
+ _toSchema = {'args': 'args'}
+ _toPy = {'args': 'args'}
+ def __init__(self, args=None, **unknown_fields):
+ '''
+ args : typing.Sequence[~RelationStatusArg]
+ '''
+ self.args = [RelationStatusArg.from_json(o) for o in args or []]
+
+
+
+class RelationStatusWatchResults(Type):
+ _toSchema = {'results': 'results'}
+ _toPy = {'results': 'results'}
+ def __init__(self, results=None, **unknown_fields):
+ '''
+ results : typing.Sequence[~RelationLifeSuspendedStatusWatchResult]
+ '''
+ self.results = [RelationLifeSuspendedStatusWatchResult.from_json(o) for o in results or []]
+
+
+
+class RelationSuspendedArg(Type):
+ _toSchema = {'message': 'message', 'relation_id': 'relation-id', 'suspended': 'suspended'}
+ _toPy = {'message': 'message', 'relation-id': 'relation_id', 'suspended': 'suspended'}
+ def __init__(self, message=None, relation_id=None, suspended=None, **unknown_fields):
+ '''
+ message : str
+ relation_id : int
+ suspended : bool
+ '''
+ self.message = message
+ self.relation_id = relation_id
+ self.suspended = suspended
+
+
+
+class RelationSuspendedArgs(Type):
+ _toSchema = {'args': 'args'}
+ _toPy = {'args': 'args'}
+ def __init__(self, args=None, **unknown_fields):
+ '''
+ args : typing.Sequence[~RelationSuspendedArg]
+ '''
+ self.args = [RelationSuspendedArg.from_json(o) for o in args or []]
+
+
+
class RelationUnit(Type):
_toSchema = {'relation': 'relation', 'unit': 'unit'}
_toPy = {'relation': 'relation', 'unit': 'unit'}
_toPy = {'settings': 'settings'}
def __init__(self, settings=None, **unknown_fields):
'''
- settings : typing.Mapping<~KT, +VT_co>[str, typing.Any]
+ settings : typing.Mapping[str, typing.Any]
'''
self.settings = settings
_toPy = {'relation-unit-pairs': 'relation_unit_pairs'}
def __init__(self, relation_unit_pairs=None, **unknown_fields):
'''
- relation_unit_pairs : typing.Sequence<+T_co>[~RelationUnitPair]<~RelationUnitPair>
+ relation_unit_pairs : typing.Sequence[~RelationUnitPair]
'''
self.relation_unit_pairs = [RelationUnitPair.from_json(o) for o in relation_unit_pairs or []]
def __init__(self, relation=None, settings=None, unit=None, **unknown_fields):
'''
relation : str
- settings : typing.Mapping<~KT, +VT_co>[str, str]
+ settings : typing.Mapping[str, str]
unit : str
'''
self.relation = relation
+class RelationUnitStatus(Type):
+ _toSchema = {'in_scope': 'in-scope', 'relation_tag': 'relation-tag', 'suspended': 'suspended'}
+ _toPy = {'in-scope': 'in_scope', 'relation-tag': 'relation_tag', 'suspended': 'suspended'}
+ def __init__(self, in_scope=None, relation_tag=None, suspended=None, **unknown_fields):
+ '''
+ in_scope : bool
+ relation_tag : str
+ suspended : bool
+ '''
+ self.in_scope = in_scope
+ self.relation_tag = relation_tag
+ self.suspended = suspended
+
+
+
+class RelationUnitStatusResult(Type):
+ _toSchema = {'error': 'error', 'results': 'results'}
+ _toPy = {'error': 'error', 'results': 'results'}
+ def __init__(self, error=None, results=None, **unknown_fields):
+ '''
+ error : Error
+ results : typing.Sequence[~RelationUnitStatus]
+ '''
+ self.error = Error.from_json(error) if error else None
+ self.results = [RelationUnitStatus.from_json(o) for o in results or []]
+
+
+
+class RelationUnitStatusResults(Type):
+ _toSchema = {'results': 'results'}
+ _toPy = {'results': 'results'}
+ def __init__(self, results=None, **unknown_fields):
+ '''
+ results : typing.Sequence[~RelationUnitStatusResult]
+ '''
+ self.results = [RelationUnitStatusResult.from_json(o) for o in results or []]
+
+
+
class RelationUnits(Type):
_toSchema = {'relation_units': 'relation-units'}
_toPy = {'relation-units': 'relation_units'}
def __init__(self, relation_units=None, **unknown_fields):
'''
- relation_units : typing.Sequence<+T_co>[~RelationUnit]<~RelationUnit>
+ relation_units : typing.Sequence[~RelationUnit]
'''
self.relation_units = [RelationUnit.from_json(o) for o in relation_units or []]
_toPy = {'changed': 'changed', 'departed': 'departed'}
def __init__(self, changed=None, departed=None, **unknown_fields):
'''
- changed : typing.Mapping<~KT, +VT_co>[str, ~UnitSettings]<~UnitSettings>
- departed : typing.Sequence<+T_co>[str]
+ changed : typing.Mapping[str, ~UnitSettings]
+ departed : typing.Sequence[str]
'''
self.changed = changed
self.departed = departed
_toPy = {'relation-units': 'relation_units'}
def __init__(self, relation_units=None, **unknown_fields):
'''
- relation_units : typing.Sequence<+T_co>[~RelationUnitSettings]<~RelationUnitSettings>
+ relation_units : typing.Sequence[~RelationUnitSettings]
'''
self.relation_units = [RelationUnitSettings.from_json(o) for o in relation_units or []]
_toPy = {'results': 'results'}
def __init__(self, results=None, **unknown_fields):
'''
- results : typing.Sequence<+T_co>[~RelationUnitsWatchResult]<~RelationUnitsWatchResult>
+ results : typing.Sequence[~RelationUnitsWatchResult]
'''
self.results = [RelationUnitsWatchResult.from_json(o) for o in results or []]
+class RemoteApplication(Type):
+ _toSchema = {'is_consumer_proxy': 'is-consumer-proxy', 'life': 'life', 'macaroon': 'macaroon', 'model_uuid': 'model-uuid', 'name': 'name', 'offer_uuid': 'offer-uuid', 'status': 'status'}
+ _toPy = {'is-consumer-proxy': 'is_consumer_proxy', 'life': 'life', 'macaroon': 'macaroon', 'model-uuid': 'model_uuid', 'name': 'name', 'offer-uuid': 'offer_uuid', 'status': 'status'}
+ def __init__(self, is_consumer_proxy=None, life=None, macaroon=None, model_uuid=None, name=None, offer_uuid=None, status=None, **unknown_fields):
+ '''
+ is_consumer_proxy : bool
+ life : str
+ macaroon : Macaroon
+ model_uuid : str
+ name : str
+ offer_uuid : str
+ status : str
+ '''
+ self.is_consumer_proxy = is_consumer_proxy
+ self.life = life
+ self.macaroon = Macaroon.from_json(macaroon) if macaroon else None
+ self.model_uuid = model_uuid
+ self.name = name
+ self.offer_uuid = offer_uuid
+ self.status = status
+
+
+
class RemoteApplicationChange(Type):
_toSchema = {'application_tag': 'application-tag', 'life': 'life', 'relations': 'relations'}
_toPy = {'application-tag': 'application_tag', 'life': 'life', 'relations': 'relations'}
'''
application_url : str
description : str
- endpoints : typing.Sequence<+T_co>[~RemoteEndpoint]<~RemoteEndpoint>
+ endpoints : typing.Sequence[~RemoteEndpoint]
icon_url_path : str
model_tag : str
name : str
_toPy = {'results': 'results'}
def __init__(self, results=None, **unknown_fields):
'''
- results : typing.Sequence<+T_co>[~RemoteApplicationInfoResult]<~RemoteApplicationInfoResult>
+ results : typing.Sequence[~RemoteApplicationInfoResult]
'''
self.results = [RemoteApplicationInfoResult.from_json(o) for o in results or []]
+class RemoteApplicationResult(Type):
+ _toSchema = {'error': 'error', 'result': 'result'}
+ _toPy = {'error': 'error', 'result': 'result'}
+ def __init__(self, error=None, result=None, **unknown_fields):
+ '''
+ error : Error
+ result : RemoteApplication
+ '''
+ self.error = Error.from_json(error) if error else None
+ self.result = RemoteApplication.from_json(result) if result else None
+
+
+
+class RemoteApplicationResults(Type):
+ _toSchema = {'results': 'results'}
+ _toPy = {'results': 'results'}
+ def __init__(self, results=None, **unknown_fields):
+ '''
+ results : typing.Sequence[~RemoteApplicationResult]
+ '''
+ self.results = [RemoteApplicationResult.from_json(o) for o in results or []]
+
+
+
class RemoteApplicationStatus(Type):
_toSchema = {'application_name': 'application-name', 'application_url': 'application-url', 'endpoints': 'endpoints', 'err': 'err', 'life': 'life', 'relations': 'relations', 'status': 'status'}
_toPy = {'application-name': 'application_name', 'application-url': 'application_url', 'endpoints': 'endpoints', 'err': 'err', 'life': 'life', 'relations': 'relations', 'status': 'status'}
'''
application_name : str
application_url : str
- endpoints : typing.Sequence<+T_co>[~RemoteEndpoint]<~RemoteEndpoint>
- err : typing.Mapping<~KT, +VT_co>[str, typing.Any]
+ endpoints : typing.Sequence[~RemoteEndpoint]
+ err : typing.Mapping[str, typing.Any]
life : str
- relations : typing.Sequence<+T_co>[str]
+ relations : typing.Sequence[str]
status : DetailedStatus
'''
self.application_name = application_name
+class RemoteEntityArg(Type):
+ _toSchema = {'macaroons': 'macaroons', 'relation_token': 'relation-token'}
+ _toPy = {'macaroons': 'macaroons', 'relation-token': 'relation_token'}
+ def __init__(self, macaroons=None, relation_token=None, **unknown_fields):
+ '''
+ macaroons : typing.Sequence[~Macaroon]
+ relation_token : str
+ '''
+ self.macaroons = [Macaroon.from_json(o) for o in macaroons or []]
+ self.relation_token = relation_token
+
+
+
+class RemoteEntityArgs(Type):
+ _toSchema = {'args': 'args'}
+ _toPy = {'args': 'args'}
+ def __init__(self, args=None, **unknown_fields):
+ '''
+ args : typing.Sequence[~RemoteEntityArg]
+ '''
+ self.args = [RemoteEntityArg.from_json(o) for o in args or []]
+
+
+
class RemoteEntityId(Type):
_toSchema = {'model_uuid': 'model-uuid', 'token': 'token'}
_toPy = {'model-uuid': 'model_uuid', 'token': 'token'}
+class RemoteEntityTokenArg(Type):
+ _toSchema = {'tag': 'tag', 'token': 'token'}
+ _toPy = {'tag': 'tag', 'token': 'token'}
+ def __init__(self, tag=None, token=None, **unknown_fields):
+ '''
+ tag : str
+ token : str
+ '''
+ self.tag = tag
+ self.token = token
+
+
+
+class RemoteEntityTokenArgs(Type):
+ _toSchema = {'args': 'Args'}
+ _toPy = {'Args': 'args'}
+ def __init__(self, args=None, **unknown_fields):
+ '''
+ args : typing.Sequence[~RemoteEntityTokenArg]
+ '''
+ self.args = [RemoteEntityTokenArg.from_json(o) for o in args or []]
+
+
+
+class RemoteRelation(Type):
+ _toSchema = {'application_name': 'application-name', 'endpoint': 'endpoint', 'id_': 'id', 'key': 'key', 'life': 'life', 'remote_application_name': 'remote-application-name', 'remote_endpoint_name': 'remote-endpoint-name', 'source_model_uuid': 'source-model-uuid', 'suspended': 'suspended'}
+ _toPy = {'application-name': 'application_name', 'endpoint': 'endpoint', 'id': 'id_', 'key': 'key', 'life': 'life', 'remote-application-name': 'remote_application_name', 'remote-endpoint-name': 'remote_endpoint_name', 'source-model-uuid': 'source_model_uuid', 'suspended': 'suspended'}
+ def __init__(self, application_name=None, endpoint=None, id_=None, key=None, life=None, remote_application_name=None, remote_endpoint_name=None, source_model_uuid=None, suspended=None, **unknown_fields):
+ '''
+ application_name : str
+ endpoint : RemoteEndpoint
+ id_ : int
+ key : str
+ life : str
+ remote_application_name : str
+ remote_endpoint_name : str
+ source_model_uuid : str
+ suspended : bool
+ '''
+ self.application_name = application_name
+ self.endpoint = RemoteEndpoint.from_json(endpoint) if endpoint else None
+ self.id_ = id_
+ self.key = key
+ self.life = life
+ self.remote_application_name = remote_application_name
+ self.remote_endpoint_name = remote_endpoint_name
+ self.source_model_uuid = source_model_uuid
+ self.suspended = suspended
+
+
+
class RemoteRelationChange(Type):
_toSchema = {'changed_units': 'changed-units', 'departed_units': 'departed-units', 'id_': 'id', 'life': 'life'}
_toPy = {'changed-units': 'changed_units', 'departed-units': 'departed_units', 'id': 'id_', 'life': 'life'}
def __init__(self, changed_units=None, departed_units=None, id_=None, life=None, **unknown_fields):
'''
- changed_units : typing.Mapping<~KT, +VT_co>[str, ~RemoteRelationUnitChange]<~RemoteRelationUnitChange>
- departed_units : typing.Sequence<+T_co>[str]
+ changed_units : typing.Mapping[str, ~RemoteRelationUnitChange]
+ departed_units : typing.Sequence[str]
id_ : int
life : str
'''
+class RemoteRelationChangeEvent(Type):
+ _toSchema = {'application_token': 'application-token', 'changed_units': 'changed-units', 'departed_units': 'departed-units', 'force_cleanup': 'force-cleanup', 'life': 'life', 'macaroons': 'macaroons', 'relation_token': 'relation-token', 'suspended': 'suspended', 'suspended_reason': 'suspended-reason'}
+ _toPy = {'application-token': 'application_token', 'changed-units': 'changed_units', 'departed-units': 'departed_units', 'force-cleanup': 'force_cleanup', 'life': 'life', 'macaroons': 'macaroons', 'relation-token': 'relation_token', 'suspended': 'suspended', 'suspended-reason': 'suspended_reason'}
+ def __init__(self, application_token=None, changed_units=None, departed_units=None, force_cleanup=None, life=None, macaroons=None, relation_token=None, suspended=None, suspended_reason=None, **unknown_fields):
+ '''
+ application_token : str
+ changed_units : typing.Sequence[~RemoteRelationUnitChange]
+ departed_units : typing.Sequence[int]
+ force_cleanup : bool
+ life : str
+ macaroons : typing.Sequence[~Macaroon]
+ relation_token : str
+ suspended : bool
+ suspended_reason : str
+ '''
+ self.application_token = application_token
+ self.changed_units = [RemoteRelationUnitChange.from_json(o) for o in changed_units or []]
+ self.departed_units = departed_units
+ self.force_cleanup = force_cleanup
+ self.life = life
+ self.macaroons = [Macaroon.from_json(o) for o in macaroons or []]
+ self.relation_token = relation_token
+ self.suspended = suspended
+ self.suspended_reason = suspended_reason
+
+
+
+class RemoteRelationDetails(Type):
+ _toSchema = {'macaroon': 'macaroon', 'relation_token': 'relation-token'}
+ _toPy = {'macaroon': 'macaroon', 'relation-token': 'relation_token'}
+ def __init__(self, macaroon=None, relation_token=None, **unknown_fields):
+ '''
+ macaroon : Macaroon
+ relation_token : str
+ '''
+ self.macaroon = Macaroon.from_json(macaroon) if macaroon else None
+ self.relation_token = relation_token
+
+
+
+class RemoteRelationResult(Type):
+ _toSchema = {'error': 'error', 'result': 'result'}
+ _toPy = {'error': 'error', 'result': 'result'}
+ def __init__(self, error=None, result=None, **unknown_fields):
+ '''
+ error : Error
+ result : RemoteRelation
+ '''
+ self.error = Error.from_json(error) if error else None
+ self.result = RemoteRelation.from_json(result) if result else None
+
+
+
+class RemoteRelationResults(Type):
+ _toSchema = {'results': 'results'}
+ _toPy = {'results': 'results'}
+ def __init__(self, results=None, **unknown_fields):
+ '''
+ results : typing.Sequence[~RemoteRelationResult]
+ '''
+ self.results = [RemoteRelationResult.from_json(o) for o in results or []]
+
+
+
+class RemoteRelationUnit(Type):
+ _toSchema = {'macaroons': 'macaroons', 'relation_token': 'relation-token', 'unit': 'unit'}
+ _toPy = {'macaroons': 'macaroons', 'relation-token': 'relation_token', 'unit': 'unit'}
+ def __init__(self, macaroons=None, relation_token=None, unit=None, **unknown_fields):
+ '''
+ macaroons : typing.Sequence[~Macaroon]
+ relation_token : str
+ unit : str
+ '''
+ self.macaroons = [Macaroon.from_json(o) for o in macaroons or []]
+ self.relation_token = relation_token
+ self.unit = unit
+
+
+
class RemoteRelationUnitChange(Type):
_toSchema = {'settings': 'settings', 'unit_id': 'unit-id'}
_toPy = {'settings': 'settings', 'unit-id': 'unit_id'}
def __init__(self, settings=None, unit_id=None, **unknown_fields):
'''
- settings : typing.Mapping<~KT, +VT_co>[str, typing.Any]
- unit_id : RemoteEntityId
+ settings : typing.Mapping[str, typing.Any]
+ unit_id : RemoteEntityId
+ '''
+ self.settings = settings
+ self.unit_id = RemoteEntityId.from_json(unit_id) if unit_id else None
+
+
+
+class RemoteRelationUnits(Type):
+ _toSchema = {'relation_units': 'relation-units'}
+ _toPy = {'relation-units': 'relation_units'}
+ def __init__(self, relation_units=None, **unknown_fields):
+ '''
+ relation_units : typing.Sequence[~RemoteRelationUnit]
'''
- self.settings = settings
- self.unit_id = RemoteEntityId.from_json(unit_id) if unit_id else None
+ self.relation_units = [RemoteRelationUnit.from_json(o) for o in relation_units or []]
_toPy = {'changed': 'changed', 'initial': 'initial', 'removed': 'removed'}
def __init__(self, changed=None, initial=None, removed=None, **unknown_fields):
'''
- changed : typing.Sequence<+T_co>[~RemoteRelationChange]<~RemoteRelationChange>
+ changed : typing.Sequence[~RemoteRelationChange]
initial : bool
- removed : typing.Sequence<+T_co>[int]
+ removed : typing.Sequence[int]
'''
self.changed = [RemoteRelationChange.from_json(o) for o in changed or []]
self.initial = initial
+class RemoteRelationsChanges(Type):
+ _toSchema = {'changes': 'changes'}
+ _toPy = {'changes': 'changes'}
+ def __init__(self, changes=None, **unknown_fields):
+ '''
+ changes : typing.Sequence[~RemoteRelationChangeEvent]
+ '''
+ self.changes = [RemoteRelationChangeEvent.from_json(o) for o in changes or []]
+
+
+
class RemoteRelationsWatchResult(Type):
_toSchema = {'change': 'change', 'error': 'error', 'remoterelationswatcherid': 'RemoteRelationsWatcherId'}
_toPy = {'RemoteRelationsWatcherId': 'remoterelationswatcherid', 'change': 'change', 'error': 'error'}
'''
cloud_type : str
name : str
- provider_attributes : typing.Mapping<~KT, +VT_co>[str, typing.Any]
+ provider_attributes : typing.Mapping[str, typing.Any]
provider_id : str
- subnets : typing.Sequence<+T_co>[~Subnet]<~Subnet>
+ subnets : typing.Sequence[~Subnet]
'''
self.cloud_type = cloud_type
self.name = name
+class RemoveFilesystemParams(Type):
+ _toSchema = {'destroy': 'destroy', 'filesystem_id': 'filesystem-id', 'provider': 'provider'}
+ _toPy = {'destroy': 'destroy', 'filesystem-id': 'filesystem_id', 'provider': 'provider'}
+ def __init__(self, destroy=None, filesystem_id=None, provider=None, **unknown_fields):
+ '''
+ destroy : bool
+ filesystem_id : str
+ provider : str
+ '''
+ self.destroy = destroy
+ self.filesystem_id = filesystem_id
+ self.provider = provider
+
+
+
+class RemoveFilesystemParamsResult(Type):
+ _toSchema = {'error': 'error', 'result': 'result'}
+ _toPy = {'error': 'error', 'result': 'result'}
+ def __init__(self, error=None, result=None, **unknown_fields):
+ '''
+ error : Error
+ result : RemoveFilesystemParams
+ '''
+ self.error = Error.from_json(error) if error else None
+ self.result = RemoveFilesystemParams.from_json(result) if result else None
+
+
+
+class RemoveFilesystemParamsResults(Type):
+ _toSchema = {'results': 'results'}
+ _toPy = {'results': 'results'}
+ def __init__(self, results=None, **unknown_fields):
+ '''
+ results : typing.Sequence[~RemoveFilesystemParamsResult]
+ '''
+ self.results = [RemoveFilesystemParamsResult.from_json(o) for o in results or []]
+
+
+
+class RemoveStorage(Type):
+ _toSchema = {'storage': 'storage'}
+ _toPy = {'storage': 'storage'}
+ def __init__(self, storage=None, **unknown_fields):
+ '''
+ storage : typing.Sequence[~RemoveStorageInstance]
+ '''
+ self.storage = [RemoveStorageInstance.from_json(o) for o in storage or []]
+
+
+
+class RemoveStorageInstance(Type):
+ _toSchema = {'destroy_attachments': 'destroy-attachments', 'destroy_storage': 'destroy-storage', 'tag': 'tag'}
+ _toPy = {'destroy-attachments': 'destroy_attachments', 'destroy-storage': 'destroy_storage', 'tag': 'tag'}
+ def __init__(self, destroy_attachments=None, destroy_storage=None, tag=None, **unknown_fields):
+ '''
+ destroy_attachments : bool
+ destroy_storage : bool
+ tag : str
+ '''
+ self.destroy_attachments = destroy_attachments
+ self.destroy_storage = destroy_storage
+ self.tag = tag
+
+
+
+class RemoveVolumeParams(Type):
+ _toSchema = {'destroy': 'destroy', 'provider': 'provider', 'volume_id': 'volume-id'}
+ _toPy = {'destroy': 'destroy', 'provider': 'provider', 'volume-id': 'volume_id'}
+ def __init__(self, destroy=None, provider=None, volume_id=None, **unknown_fields):
+ '''
+ destroy : bool
+ provider : str
+ volume_id : str
+ '''
+ self.destroy = destroy
+ self.provider = provider
+ self.volume_id = volume_id
+
+
+
+class RemoveVolumeParamsResult(Type):
+ _toSchema = {'error': 'error', 'result': 'result'}
+ _toPy = {'error': 'error', 'result': 'result'}
+ def __init__(self, error=None, result=None, **unknown_fields):
+ '''
+ error : Error
+ result : RemoveVolumeParams
+ '''
+ self.error = Error.from_json(error) if error else None
+ self.result = RemoveVolumeParams.from_json(result) if result else None
+
+
+
+class RemoveVolumeParamsResults(Type):
+ _toSchema = {'results': 'results'}
+ _toPy = {'results': 'results'}
+ def __init__(self, results=None, **unknown_fields):
+ '''
+ results : typing.Sequence[~RemoveVolumeParamsResult]
+ '''
+ self.results = [RemoveVolumeParamsResult.from_json(o) for o in results or []]
+
+
+
class ResolveCharmResult(Type):
_toSchema = {'error': 'error', 'url': 'url'}
_toPy = {'error': 'error', 'url': 'url'}
_toPy = {'urls': 'urls'}
def __init__(self, urls=None, **unknown_fields):
'''
- urls : typing.Sequence<+T_co>[~ResolveCharmResult]<~ResolveCharmResult>
+ urls : typing.Sequence[~ResolveCharmResult]
'''
self.urls = [ResolveCharmResult.from_json(o) for o in urls or []]
_toPy = {'references': 'references'}
def __init__(self, references=None, **unknown_fields):
'''
- references : typing.Sequence<+T_co>[str]
+ references : typing.Sequence[str]
'''
self.references = references
_toPy = {'results': 'results'}
def __init__(self, results=None, **unknown_fields):
'''
- results : typing.Sequence<+T_co>[~ResolvedModeResult]<~ResolvedModeResult>
+ results : typing.Sequence[~ResolvedModeResult]
'''
self.results = [ResolvedModeResult.from_json(o) for o in results or []]
def __init__(self, errorresult=None, charm_store_resources=None, resources=None, unit_resources=None, **unknown_fields):
'''
errorresult : ErrorResult
- charm_store_resources : typing.Sequence<+T_co>[~CharmResource]<~CharmResource>
- resources : typing.Sequence<+T_co>[~Resource]<~Resource>
- unit_resources : typing.Sequence<+T_co>[~UnitResources]<~UnitResources>
+ charm_store_resources : typing.Sequence[~CharmResource]
+ resources : typing.Sequence[~Resource]
+ unit_resources : typing.Sequence[~UnitResources]
'''
self.errorresult = ErrorResult.from_json(errorresult) if errorresult else None
self.charm_store_resources = [CharmResource.from_json(o) for o in charm_store_resources or []]
_toPy = {'results': 'results'}
def __init__(self, results=None, **unknown_fields):
'''
- results : typing.Sequence<+T_co>[~ResourcesResult]<~ResourcesResult>
+ results : typing.Sequence[~ResourcesResult]
'''
self.results = [ResourcesResult.from_json(o) for o in results or []]
_toPy = {'members': 'members'}
def __init__(self, members=None, **unknown_fields):
'''
- members : typing.Sequence<+T_co>[~Member]<~Member>
+ members : typing.Sequence[~Member]
'''
self.members = [Member.from_json(o) for o in members or []]
_toPy = {'results': 'results'}
def __init__(self, results=None, **unknown_fields):
'''
- results : typing.Sequence<+T_co>[~RetryStrategyResult]<~RetryStrategyResult>
+ results : typing.Sequence[~RetryStrategyResult]
'''
self.results = [RetryStrategyResult.from_json(o) for o in results or []]
+class RevokeCredentialArg(Type):
+ _toSchema = {'force': 'force', 'tag': 'tag'}
+ _toPy = {'force': 'force', 'tag': 'tag'}
+ def __init__(self, force=None, tag=None, **unknown_fields):
+ '''
+ force : bool
+ tag : str
+ '''
+ self.force = force
+ self.tag = tag
+
+
+
+class RevokeCredentialArgs(Type):
+ _toSchema = {'credentials': 'credentials'}
+ _toPy = {'credentials': 'credentials'}
+ def __init__(self, credentials=None, **unknown_fields):
+ '''
+ credentials : typing.Sequence[~RevokeCredentialArg]
+ '''
+ self.credentials = [RevokeCredentialArg.from_json(o) for o in credentials or []]
+
+
+
class RunParams(Type):
_toSchema = {'applications': 'applications', 'commands': 'commands', 'machines': 'machines', 'timeout': 'timeout', 'units': 'units'}
_toPy = {'applications': 'applications', 'commands': 'commands', 'machines': 'machines', 'timeout': 'timeout', 'units': 'units'}
def __init__(self, applications=None, commands=None, machines=None, timeout=None, units=None, **unknown_fields):
'''
- applications : typing.Sequence<+T_co>[str]
+ applications : typing.Sequence[str]
commands : str
- machines : typing.Sequence<+T_co>[str]
+ machines : typing.Sequence[str]
timeout : int
- units : typing.Sequence<+T_co>[str]
+ units : typing.Sequence[str]
'''
self.applications = applications
self.commands = commands
_toPy = {'results': 'results'}
def __init__(self, results=None, **unknown_fields):
'''
- results : typing.Sequence<+T_co>[~SSHAddressResult]<~SSHAddressResult>
+ results : typing.Sequence[~SSHAddressResult]
'''
self.results = [SSHAddressResult.from_json(o) for o in results or []]
_toPy = {'addresses': 'addresses', 'error': 'error'}
def __init__(self, addresses=None, error=None, **unknown_fields):
'''
- addresses : typing.Sequence<+T_co>[str]
+ addresses : typing.Sequence[str]
error : Error
'''
self.addresses = addresses
_toPy = {'results': 'results'}
def __init__(self, results=None, **unknown_fields):
'''
- results : typing.Sequence<+T_co>[~SSHAddressesResult]<~SSHAddressesResult>
+ results : typing.Sequence[~SSHAddressesResult]
'''
self.results = [SSHAddressesResult.from_json(o) for o in results or []]
_toPy = {'entity-keys': 'entity_keys'}
def __init__(self, entity_keys=None, **unknown_fields):
'''
- entity_keys : typing.Sequence<+T_co>[~SSHHostKeys]<~SSHHostKeys>
+ entity_keys : typing.Sequence[~SSHHostKeys]
'''
self.entity_keys = [SSHHostKeys.from_json(o) for o in entity_keys or []]
_toPy = {'public-keys': 'public_keys', 'tag': 'tag'}
def __init__(self, public_keys=None, tag=None, **unknown_fields):
'''
- public_keys : typing.Sequence<+T_co>[str]
+ public_keys : typing.Sequence[str]
tag : str
'''
self.public_keys = public_keys
def __init__(self, error=None, public_keys=None, **unknown_fields):
'''
error : Error
- public_keys : typing.Sequence<+T_co>[str]
+ public_keys : typing.Sequence[str]
'''
self.error = Error.from_json(error) if error else None
self.public_keys = public_keys
_toPy = {'results': 'results'}
def __init__(self, results=None, **unknown_fields):
'''
- results : typing.Sequence<+T_co>[~SSHPublicKeysResult]<~SSHPublicKeysResult>
+ results : typing.Sequence[~SSHPublicKeysResult]
'''
self.results = [SSHPublicKeysResult.from_json(o) for o in results or []]
+class ScaleApplicationInfo(Type):
+ _toSchema = {'num_units': 'num-units'}
+ _toPy = {'num-units': 'num_units'}
+ def __init__(self, num_units=None, **unknown_fields):
+ '''
+ num_units : int
+ '''
+ self.num_units = num_units
+
+
+
+class ScaleApplicationParams(Type):
+ _toSchema = {'application_tag': 'application-tag', 'scale': 'scale', 'scale_change': 'scale-change'}
+ _toPy = {'application-tag': 'application_tag', 'scale': 'scale', 'scale-change': 'scale_change'}
+ def __init__(self, application_tag=None, scale=None, scale_change=None, **unknown_fields):
+ '''
+ application_tag : str
+ scale : int
+ scale_change : int
+ '''
+ self.application_tag = application_tag
+ self.scale = scale
+ self.scale_change = scale_change
+
+
+
+class ScaleApplicationResult(Type):
+ _toSchema = {'error': 'error', 'info': 'info'}
+ _toPy = {'error': 'error', 'info': 'info'}
+ def __init__(self, error=None, info=None, **unknown_fields):
+ '''
+ error : Error
+ info : ScaleApplicationInfo
+ '''
+ self.error = Error.from_json(error) if error else None
+ self.info = ScaleApplicationInfo.from_json(info) if info else None
+
+
+
+class ScaleApplicationResults(Type):
+ _toSchema = {'results': 'results'}
+ _toPy = {'results': 'results'}
+ def __init__(self, results=None, **unknown_fields):
+ '''
+ results : typing.Sequence[~ScaleApplicationResult]
+ '''
+ self.results = [ScaleApplicationResult.from_json(o) for o in results or []]
+
+
+
+class ScaleApplicationsParams(Type):
+ _toSchema = {'applications': 'applications'}
+ _toPy = {'applications': 'applications'}
+ def __init__(self, applications=None, **unknown_fields):
+ '''
+ applications : typing.Sequence[~ScaleApplicationParams]
+ '''
+ self.applications = [ScaleApplicationParams.from_json(o) for o in applications or []]
+
+
+
class SerializedModel(Type):
_toSchema = {'bytes_': 'bytes', 'charms': 'charms', 'tools': 'tools'}
_toPy = {'bytes': 'bytes_', 'charms': 'charms', 'tools': 'tools'}
def __init__(self, bytes_=None, charms=None, tools=None, **unknown_fields):
'''
- bytes_ : typing.Sequence<+T_co>[int]
- charms : typing.Sequence<+T_co>[str]
- tools : typing.Sequence<+T_co>[~SerializedModelTools]<~SerializedModelTools>
+ bytes_ : typing.Sequence[int]
+ charms : typing.Sequence[str]
+ tools : typing.Sequence[~SerializedModelTools]
'''
self.bytes_ = bytes_
self.charms = charms
application_revision : SerializedModelResourceRevision
charmstore_revision : SerializedModelResourceRevision
name : str
- unit_revisions : typing.Mapping<~KT, +VT_co>[str, ~SerializedModelResourceRevision]<~SerializedModelResourceRevision>
+ unit_revisions : typing.Mapping[str, ~SerializedModelResourceRevision]
'''
self.application = application
self.application_revision = SerializedModelResourceRevision.from_json(application_revision) if application_revision else None
+class SetExternalControllerInfoParams(Type):
+ _toSchema = {'info': 'info'}
+ _toPy = {'info': 'info'}
+ def __init__(self, info=None, **unknown_fields):
+ '''
+ info : ExternalControllerInfo
+ '''
+ self.info = ExternalControllerInfo.from_json(info) if info else None
+
+
+
+class SetExternalControllersInfoParams(Type):
+ _toSchema = {'controllers': 'controllers'}
+ _toPy = {'controllers': 'controllers'}
+ def __init__(self, controllers=None, **unknown_fields):
+ '''
+ controllers : typing.Sequence[~SetExternalControllerInfoParams]
+ '''
+ self.controllers = [SetExternalControllerInfoParams.from_json(o) for o in controllers or []]
+
+
+
class SetMachineBlockDevices(Type):
_toSchema = {'machine_block_devices': 'machine-block-devices'}
_toPy = {'machine-block-devices': 'machine_block_devices'}
def __init__(self, machine_block_devices=None, **unknown_fields):
'''
- machine_block_devices : typing.Sequence<+T_co>[~MachineBlockDevices]<~MachineBlockDevices>
+ machine_block_devices : typing.Sequence[~MachineBlockDevices]
'''
self.machine_block_devices = [MachineBlockDevices.from_json(o) for o in machine_block_devices or []]
_toPy = {'config': 'config', 'tag': 'tag'}
def __init__(self, config=None, tag=None, **unknown_fields):
'''
- config : typing.Sequence<+T_co>[~NetworkConfig]<~NetworkConfig>
+ config : typing.Sequence[~NetworkConfig]
tag : str
'''
self.config = [NetworkConfig.from_json(o) for o in config or []]
_toPy = {'machine-addresses': 'machine_addresses'}
def __init__(self, machine_addresses=None, **unknown_fields):
'''
- machine_addresses : typing.Sequence<+T_co>[~MachineAddresses]<~MachineAddresses>
+ machine_addresses : typing.Sequence[~MachineAddresses]
'''
self.machine_addresses = [MachineAddresses.from_json(o) for o in machine_addresses or []]
_toPy = {'config': 'config'}
def __init__(self, config=None, **unknown_fields):
'''
- config : typing.Sequence<+T_co>[~ModelDefaultValues]<~ModelDefaultValues>
+ config : typing.Sequence[~ModelDefaultValues]
'''
self.config = [ModelDefaultValues.from_json(o) for o in config or []]
+class SetModelEnvironVersion(Type):
+ _toSchema = {'model_tag': 'model-tag', 'version': 'version'}
+ _toPy = {'model-tag': 'model_tag', 'version': 'version'}
+ def __init__(self, model_tag=None, version=None, **unknown_fields):
+ '''
+ model_tag : str
+ version : int
+ '''
+ self.model_tag = model_tag
+ self.version = version
+
+
+
+class SetModelEnvironVersions(Type):
+ _toSchema = {'models': 'models'}
+ _toPy = {'models': 'models'}
+ def __init__(self, models=None, **unknown_fields):
+ '''
+ models : typing.Sequence[~SetModelEnvironVersion]
+ '''
+ self.models = [SetModelEnvironVersion.from_json(o) for o in models or []]
+
+
+
class SetPayloadStatusArg(Type):
_toSchema = {'entity': 'Entity', 'status': 'status'}
_toPy = {'Entity': 'entity', 'status': 'status'}
_toPy = {'args': 'args'}
def __init__(self, args=None, **unknown_fields):
'''
- args : typing.Sequence<+T_co>[~SetPayloadStatusArg]<~SetPayloadStatusArg>
+ args : typing.Sequence[~SetPayloadStatusArg]
'''
self.args = [SetPayloadStatusArg.from_json(o) for o in args or []]
+class SetPodSpecParams(Type):
+ _toSchema = {'specs': 'specs'}
+ _toPy = {'specs': 'specs'}
+ def __init__(self, specs=None, **unknown_fields):
+ '''
+ specs : typing.Sequence[~EntityString]
+ '''
+ self.specs = [EntityString.from_json(o) for o in specs or []]
+
+
+
+class SetProfileArg(Type):
+ _toSchema = {'entity': 'entity', 'profiles': 'profiles'}
+ _toPy = {'entity': 'entity', 'profiles': 'profiles'}
+ def __init__(self, entity=None, profiles=None, **unknown_fields):
+ '''
+ entity : Entity
+ profiles : typing.Sequence[str]
+ '''
+ self.entity = Entity.from_json(entity) if entity else None
+ self.profiles = profiles
+
+
+
+class SetProfileArgs(Type):
+ _toSchema = {'args': 'args'}
+ _toPy = {'args': 'args'}
+ def __init__(self, args=None, **unknown_fields):
+ '''
+ args : typing.Sequence[~SetProfileArg]
+ '''
+ self.args = [SetProfileArg.from_json(o) for o in args or []]
+
+
+
+class SetProfileUpgradeCompleteArg(Type):
+ _toSchema = {'entity': 'entity', 'message': 'message'}
+ _toPy = {'entity': 'entity', 'message': 'message'}
+ def __init__(self, entity=None, message=None, **unknown_fields):
+ '''
+ entity : Entity
+ message : str
+ '''
+ self.entity = Entity.from_json(entity) if entity else None
+ self.message = message
+
+
+
+class SetProfileUpgradeCompleteArgs(Type):
+ _toSchema = {'args': 'args'}
+ _toPy = {'args': 'args'}
+ def __init__(self, args=None, **unknown_fields):
+ '''
+ args : typing.Sequence[~SetProfileUpgradeCompleteArg]
+ '''
+ self.args = [SetProfileUpgradeCompleteArg.from_json(o) for o in args or []]
+
+
+
class SetStatus(Type):
_toSchema = {'entities': 'entities'}
_toPy = {'entities': 'entities'}
def __init__(self, entities=None, **unknown_fields):
'''
- entities : typing.Sequence<+T_co>[~EntityStatusArgs]<~EntityStatusArgs>
+ entities : typing.Sequence[~EntityStatusArgs]
'''
self.entities = [EntityStatusArgs.from_json(o) for o in entities or []]
_toPy = {'args': 'args'}
def __init__(self, args=None, **unknown_fields):
'''
- args : typing.Sequence<+T_co>[~SetStatusArg]<~SetStatusArg>
+ args : typing.Sequence[~SetStatusArg]
'''
self.args = [SetStatusArg.from_json(o) for o in args or []]
def __init__(self, error=None, settings=None, **unknown_fields):
'''
error : Error
- settings : typing.Mapping<~KT, +VT_co>[str, str]
+ settings : typing.Mapping[str, str]
'''
self.error = Error.from_json(error) if error else None
self.settings = settings
_toPy = {'results': 'results'}
def __init__(self, results=None, **unknown_fields):
'''
- results : typing.Sequence<+T_co>[~SettingsResult]<~SettingsResult>
+ results : typing.Sequence[~SettingsResult]
'''
self.results = [SettingsResult.from_json(o) for o in results or []]
_toPy = {'claims': 'claims'}
def __init__(self, claims=None, **unknown_fields):
'''
- claims : typing.Sequence<+T_co>[~SingularClaim]<~SingularClaim>
+ claims : typing.Sequence[~SingularClaim]
'''
self.claims = [SingularClaim.from_json(o) for o in claims or []]
'''
error : Error
name : str
- subnets : typing.Sequence<+T_co>[~Subnet]<~Subnet>
+ subnets : typing.Sequence[~Subnet]
'''
self.error = Error.from_json(error) if error else None
self.name = name
_toPy = {'results': 'results'}
def __init__(self, results=None, **unknown_fields):
'''
- results : typing.Sequence<+T_co>[~SpaceResult]<~SpaceResult>
+ results : typing.Sequence[~SpaceResult]
'''
self.results = [SpaceResult.from_json(o) for o in results or []]
_toPy = {'requests': 'requests'}
def __init__(self, requests=None, **unknown_fields):
'''
- requests : typing.Sequence<+T_co>[~StatusHistoryRequest]<~StatusHistoryRequest>
+ requests : typing.Sequence[~StatusHistoryRequest]
'''
self.requests = [StatusHistoryRequest.from_json(o) for o in requests or []]
_toPy = {'results': 'results'}
def __init__(self, results=None, **unknown_fields):
'''
- results : typing.Sequence<+T_co>[~StatusHistoryResult]<~StatusHistoryResult>
+ results : typing.Sequence[~StatusHistoryResult]
'''
self.results = [StatusHistoryResult.from_json(o) for o in results or []]
_toPy = {'patterns': 'patterns'}
def __init__(self, patterns=None, **unknown_fields):
'''
- patterns : typing.Sequence<+T_co>[str]
+ patterns : typing.Sequence[str]
'''
self.patterns = patterns
_toPy = {'data': 'data', 'error': 'error', 'id': 'id_', 'info': 'info', 'life': 'life', 'since': 'since', 'status': 'status'}
def __init__(self, data=None, error=None, id_=None, info=None, life=None, since=None, status=None, **unknown_fields):
'''
- data : typing.Mapping<~KT, +VT_co>[str, typing.Any]
+ data : typing.Mapping[str, typing.Any]
error : Error
id_ : str
info : str
_toPy = {'results': 'results'}
def __init__(self, results=None, **unknown_fields):
'''
- results : typing.Sequence<+T_co>[~StatusResult]<~StatusResult>
+ results : typing.Sequence[~StatusResult]
'''
self.results = [StatusResult.from_json(o) for o in results or []]
_toPy = {'ids': 'ids'}
def __init__(self, ids=None, **unknown_fields):
'''
- ids : typing.Sequence<+T_co>[~StorageAttachmentId]<~StorageAttachmentId>
+ ids : typing.Sequence[~StorageAttachmentId]
'''
self.ids = [StorageAttachmentId.from_json(o) for o in ids or []]
_toPy = {'results': 'results'}
def __init__(self, results=None, **unknown_fields):
'''
- results : typing.Sequence<+T_co>[~StorageAttachmentIdsResult]<~StorageAttachmentIdsResult>
+ results : typing.Sequence[~StorageAttachmentIdsResult]
'''
self.results = [StorageAttachmentIdsResult.from_json(o) for o in results or []]
_toPy = {'results': 'results'}
def __init__(self, results=None, **unknown_fields):
'''
- results : typing.Sequence<+T_co>[~StorageAttachmentResult]<~StorageAttachmentResult>
+ results : typing.Sequence[~StorageAttachmentResult]
'''
self.results = [StorageAttachmentResult.from_json(o) for o in results or []]
_toPy = {'attachments': 'attachments', 'kind': 'kind', 'owner-tag': 'owner_tag', 'persistent': 'persistent', 'status': 'status', 'storage-tag': 'storage_tag'}
def __init__(self, attachments=None, kind=None, owner_tag=None, persistent=None, status=None, storage_tag=None, **unknown_fields):
'''
- attachments : typing.Mapping<~KT, +VT_co>[str, ~StorageAttachmentDetails]<~StorageAttachmentDetails>
+ attachments : typing.Mapping[str, ~StorageAttachmentDetails]
kind : int
owner_tag : str
persistent : bool
def __init__(self, error=None, result=None, **unknown_fields):
'''
error : Error
- result : typing.Sequence<+T_co>[~StorageDetails]<~StorageDetails>
+ result : typing.Sequence[~StorageDetails]
'''
self.error = Error.from_json(error) if error else None
self.result = [StorageDetails.from_json(o) for o in result or []]
_toPy = {'results': 'results'}
def __init__(self, results=None, **unknown_fields):
'''
- results : typing.Sequence<+T_co>[~StorageDetailsListResult]<~StorageDetailsListResult>
+ results : typing.Sequence[~StorageDetailsListResult]
'''
self.results = [StorageDetailsListResult.from_json(o) for o in results or []]
_toPy = {'results': 'results'}
def __init__(self, results=None, **unknown_fields):
'''
- results : typing.Sequence<+T_co>[~StorageDetailsResult]<~StorageDetailsResult>
+ results : typing.Sequence[~StorageDetailsResult]
'''
self.results = [StorageDetailsResult.from_json(o) for o in results or []]
_toPy = {'filters': 'filters'}
def __init__(self, filters=None, **unknown_fields):
'''
- filters : typing.Sequence<+T_co>[~StorageFilter]<~StorageFilter>
+ filters : typing.Sequence[~StorageFilter]
'''
self.filters = [StorageFilter.from_json(o) for o in filters or []]
_toPy = {'attrs': 'attrs', 'name': 'name', 'provider': 'provider'}
def __init__(self, attrs=None, name=None, provider=None, **unknown_fields):
'''
- attrs : typing.Mapping<~KT, +VT_co>[str, typing.Any]
+ attrs : typing.Mapping[str, typing.Any]
name : str
provider : str
'''
_toPy = {'names': 'names', 'providers': 'providers'}
def __init__(self, names=None, providers=None, **unknown_fields):
'''
- names : typing.Sequence<+T_co>[str]
- providers : typing.Sequence<+T_co>[str]
+ names : typing.Sequence[str]
+ providers : typing.Sequence[str]
'''
self.names = names
self.providers = providers
_toPy = {'filters': 'filters'}
def __init__(self, filters=None, **unknown_fields):
'''
- filters : typing.Sequence<+T_co>[~StoragePoolFilter]<~StoragePoolFilter>
+ filters : typing.Sequence[~StoragePoolFilter]
'''
self.filters = [StoragePoolFilter.from_json(o) for o in filters or []]
def __init__(self, error=None, storage_pools=None, **unknown_fields):
'''
error : Error
- storage_pools : typing.Sequence<+T_co>[~StoragePool]<~StoragePool>
+ storage_pools : typing.Sequence[~StoragePool]
'''
self.error = Error.from_json(error) if error else None
self.storage_pools = [StoragePool.from_json(o) for o in storage_pools or []]
_toPy = {'results': 'results'}
def __init__(self, results=None, **unknown_fields):
'''
- results : typing.Sequence<+T_co>[~StoragePoolsResult]<~StoragePoolsResult>
+ results : typing.Sequence[~StoragePoolsResult]
'''
self.results = [StoragePoolsResult.from_json(o) for o in results or []]
_toPy = {'storages': 'storages'}
def __init__(self, storages=None, **unknown_fields):
'''
- storages : typing.Sequence<+T_co>[~StorageAddParams]<~StorageAddParams>
+ storages : typing.Sequence[~StorageAddParams]
'''
self.storages = [StorageAddParams.from_json(o) for o in storages or []]
_toPy = {'results': 'results'}
def __init__(self, results=None, **unknown_fields):
'''
- results : typing.Sequence<+T_co>[~StringBoolResult]<~StringBoolResult>
+ results : typing.Sequence[~StringBoolResult]
'''
self.results = [StringBoolResult.from_json(o) for o in results or []]
_toPy = {'results': 'results'}
def __init__(self, results=None, **unknown_fields):
'''
- results : typing.Sequence<+T_co>[~StringResult]<~StringResult>
+ results : typing.Sequence[~StringResult]
'''
self.results = [StringResult.from_json(o) for o in results or []]
def __init__(self, error=None, result=None, **unknown_fields):
'''
error : Error
- result : typing.Sequence<+T_co>[str]
+ result : typing.Sequence[str]
'''
self.error = Error.from_json(error) if error else None
self.result = result
_toPy = {'results': 'results'}
def __init__(self, results=None, **unknown_fields):
'''
- results : typing.Sequence<+T_co>[~StringsResult]<~StringsResult>
+ results : typing.Sequence[~StringsResult]
'''
self.results = [StringsResult.from_json(o) for o in results or []]
_toPy = {'changes': 'changes', 'error': 'error', 'watcher-id': 'watcher_id'}
def __init__(self, changes=None, error=None, watcher_id=None, **unknown_fields):
'''
- changes : typing.Sequence<+T_co>[str]
+ changes : typing.Sequence[str]
error : Error
watcher_id : str
'''
_toPy = {'results': 'results'}
def __init__(self, results=None, **unknown_fields):
'''
- results : typing.Sequence<+T_co>[~StringsWatchResult]<~StringsWatchResult>
+ results : typing.Sequence[~StringsWatchResult]
+ '''
+ self.results = [StringsWatchResult.from_json(o) for o in results or []]
+
+
+
+class Subnet(Type):
+ _toSchema = {'cidr': 'cidr', 'life': 'life', 'provider_id': 'provider-id', 'space_tag': 'space-tag', 'status': 'status', 'vlan_tag': 'vlan-tag', 'zones': 'zones'}
+ _toPy = {'cidr': 'cidr', 'life': 'life', 'provider-id': 'provider_id', 'space-tag': 'space_tag', 'status': 'status', 'vlan-tag': 'vlan_tag', 'zones': 'zones'}
+ def __init__(self, cidr=None, life=None, provider_id=None, space_tag=None, status=None, vlan_tag=None, zones=None, **unknown_fields):
+ '''
+ cidr : str
+ life : str
+ provider_id : str
+ space_tag : str
+ status : str
+ vlan_tag : int
+ zones : typing.Sequence[str]
+ '''
+ self.cidr = cidr
+ self.life = life
+ self.provider_id = provider_id
+ self.space_tag = space_tag
+ self.status = status
+ self.vlan_tag = vlan_tag
+ self.zones = zones
+
+
+
+class SubnetsFilters(Type):
+ _toSchema = {'space_tag': 'space-tag', 'zone': 'zone'}
+ _toPy = {'space-tag': 'space_tag', 'zone': 'zone'}
+ def __init__(self, space_tag=None, zone=None, **unknown_fields):
+ '''
+ space_tag : str
+ zone : str
+ '''
+ self.space_tag = space_tag
+ self.zone = zone
+
+
+
+class TaggedCredential(Type):
+ _toSchema = {'credential': 'credential', 'tag': 'tag'}
+ _toPy = {'credential': 'credential', 'tag': 'tag'}
+ def __init__(self, credential=None, tag=None, **unknown_fields):
+ '''
+ credential : CloudCredential
+ tag : str
+ '''
+ self.credential = CloudCredential.from_json(credential) if credential else None
+ self.tag = tag
+
+
+
+class TaggedCredentials(Type):
+ _toSchema = {'credentials': 'credentials'}
+ _toPy = {'credentials': 'credentials'}
+ def __init__(self, credentials=None, **unknown_fields):
+ '''
+ credentials : typing.Sequence[~TaggedCredential]
'''
- self.results = [StringsWatchResult.from_json(o) for o in results or []]
+ self.credentials = [TaggedCredential.from_json(o) for o in credentials or []]
-class Subnet(Type):
- _toSchema = {'cidr': 'cidr', 'life': 'life', 'provider_id': 'provider-id', 'space_tag': 'space-tag', 'status': 'status', 'vlan_tag': 'vlan-tag', 'zones': 'zones'}
- _toPy = {'cidr': 'cidr', 'life': 'life', 'provider-id': 'provider_id', 'space-tag': 'space_tag', 'status': 'status', 'vlan-tag': 'vlan_tag', 'zones': 'zones'}
- def __init__(self, cidr=None, life=None, provider_id=None, space_tag=None, status=None, vlan_tag=None, zones=None, **unknown_fields):
+class TokenResult(Type):
+ _toSchema = {'error': 'error', 'token': 'token'}
+ _toPy = {'error': 'error', 'token': 'token'}
+ def __init__(self, error=None, token=None, **unknown_fields):
'''
- cidr : str
- life : str
- provider_id : str
- space_tag : str
- status : str
- vlan_tag : int
- zones : typing.Sequence<+T_co>[str]
+ error : Error
+ token : str
'''
- self.cidr = cidr
- self.life = life
- self.provider_id = provider_id
- self.space_tag = space_tag
- self.status = status
- self.vlan_tag = vlan_tag
- self.zones = zones
+ self.error = Error.from_json(error) if error else None
+ self.token = token
-class SubnetsFilters(Type):
- _toSchema = {'space_tag': 'space-tag', 'zone': 'zone'}
- _toPy = {'space-tag': 'space_tag', 'zone': 'zone'}
- def __init__(self, space_tag=None, zone=None, **unknown_fields):
+class TokenResults(Type):
+ _toSchema = {'results': 'results'}
+ _toPy = {'results': 'results'}
+ def __init__(self, results=None, **unknown_fields):
'''
- space_tag : str
- zone : str
+ results : typing.Sequence[~TokenResult]
'''
- self.space_tag = space_tag
- self.zone = zone
+ self.results = [TokenResult.from_json(o) for o in results or []]
'''
disable_ssl_hostname_verification : bool
error : Error
- tools : typing.Sequence<+T_co>[~Tools]<~Tools>
+ tools : typing.Sequence[~Tools]
'''
self.disable_ssl_hostname_verification = disable_ssl_hostname_verification
self.error = Error.from_json(error) if error else None
_toPy = {'results': 'results'}
def __init__(self, results=None, **unknown_fields):
'''
- results : typing.Sequence<+T_co>[~ToolsResult]<~ToolsResult>
+ results : typing.Sequence[~ToolsResult]
'''
self.results = [ToolsResult.from_json(o) for o in results or []]
_toPy = {'payloads': 'payloads'}
def __init__(self, payloads=None, **unknown_fields):
'''
- payloads : typing.Sequence<+T_co>[~Payload]<~Payload>
+ payloads : typing.Sequence[~Payload]
'''
self.payloads = [Payload.from_json(o) for o in payloads or []]
_toPy = {'payloads': 'payloads'}
def __init__(self, payloads=None, **unknown_fields):
'''
- payloads : typing.Sequence<+T_co>[~Payload]<~Payload>
+ payloads : typing.Sequence[~Payload]
'''
self.payloads = [Payload.from_json(o) for o in payloads or []]
def __init__(self, error=None, info=None, **unknown_fields):
'''
error : Error
- info : typing.Sequence<+T_co>[~NetworkConfig]<~NetworkConfig>
+ info : typing.Sequence[~NetworkConfig]
'''
self.error = Error.from_json(error) if error else None
self.info = [NetworkConfig.from_json(o) for o in info or []]
_toPy = {'results': 'results'}
def __init__(self, results=None, **unknown_fields):
'''
- results : typing.Sequence<+T_co>[~UnitNetworkConfigResult]<~UnitNetworkConfigResult>
+ results : typing.Sequence[~UnitNetworkConfigResult]
'''
self.results = [UnitNetworkConfigResult.from_json(o) for o in results or []]
+class UnitRefreshResult(Type):
+ _toSchema = {'error': 'Error', 'life': 'Life', 'resolved': 'Resolved'}
+ _toPy = {'Error': 'error', 'Life': 'life', 'Resolved': 'resolved'}
+ def __init__(self, error=None, life=None, resolved=None, **unknown_fields):
+ '''
+ error : Error
+ life : str
+ resolved : str
+ '''
+ self.error = Error.from_json(error) if error else None
+ self.life = life
+ self.resolved = resolved
+
+
+
+class UnitRefreshResults(Type):
+ _toSchema = {'results': 'Results'}
+ _toPy = {'Results': 'results'}
+ def __init__(self, results=None, **unknown_fields):
+ '''
+ results : typing.Sequence[~UnitRefreshResult]
+ '''
+ self.results = [UnitRefreshResult.from_json(o) for o in results or []]
+
+
+
class UnitResourceResult(Type):
_toSchema = {'errorresult': 'ErrorResult', 'resource': 'resource'}
_toPy = {'ErrorResult': 'errorresult', 'resource': 'resource'}
def __init__(self, entity=None, download_progress=None, resources=None, **unknown_fields):
'''
entity : Entity
- download_progress : typing.Mapping<~KT, +VT_co>[str, int]
- resources : typing.Sequence<+T_co>[~Resource]<~Resource>
+ download_progress : typing.Mapping[str, int]
+ resources : typing.Sequence[~Resource]
'''
self.entity = Entity.from_json(entity) if entity else None
self.download_progress = download_progress
def __init__(self, errorresult=None, resources=None, **unknown_fields):
'''
errorresult : ErrorResult
- resources : typing.Sequence<+T_co>[~UnitResourceResult]<~UnitResourceResult>
+ resources : typing.Sequence[~UnitResourceResult]
'''
self.errorresult = ErrorResult.from_json(errorresult) if errorresult else None
self.resources = [UnitResourceResult.from_json(o) for o in resources or []]
charm : str
leader : bool
machine : str
- opened_ports : typing.Sequence<+T_co>[str]
+ opened_ports : typing.Sequence[str]
public_address : str
- subordinates : typing.Mapping<~KT, +VT_co>[str, ~UnitStatus]<~UnitStatus>
+ subordinates : typing.Mapping[str, ~UnitStatus]
workload_status : DetailedStatus
workload_version : str
'''
_toPy = {'args': 'args'}
def __init__(self, args=None, **unknown_fields):
'''
- args : typing.Sequence<+T_co>[~UnitNetworkConfig]<~UnitNetworkConfig>
+ args : typing.Sequence[~UnitNetworkConfig]
'''
self.args = [UnitNetworkConfig.from_json(o) for o in args or []]
+class UnitsResolved(Type):
+ _toSchema = {'all_': 'all', 'retry': 'retry', 'tags': 'tags'}
+ _toPy = {'all': 'all_', 'retry': 'retry', 'tags': 'tags'}
+ def __init__(self, all_=None, retry=None, tags=None, **unknown_fields):
+ '''
+ all_ : bool
+ retry : bool
+ tags : Entities
+ '''
+ self.all_ = all_
+ self.retry = retry
+ self.tags = Entities.from_json(tags) if tags else None
+
+
+
class UnsetModelDefaults(Type):
_toSchema = {'keys': 'keys'}
_toPy = {'keys': 'keys'}
def __init__(self, keys=None, **unknown_fields):
'''
- keys : typing.Sequence<+T_co>[~ModelUnsetKeys]<~ModelUnsetKeys>
+ keys : typing.Sequence[~ModelUnsetKeys]
'''
self.keys = [ModelUnsetKeys.from_json(o) for o in keys or []]
+class UpdateApplicationServiceArg(Type):
+ _toSchema = {'addresses': 'addresses', 'application_tag': 'application-tag', 'provider_id': 'provider-id'}
+ _toPy = {'addresses': 'addresses', 'application-tag': 'application_tag', 'provider-id': 'provider_id'}
+ def __init__(self, addresses=None, application_tag=None, provider_id=None, **unknown_fields):
+ '''
+ addresses : typing.Sequence[~Address]
+ application_tag : str
+ provider_id : str
+ '''
+ self.addresses = [Address.from_json(o) for o in addresses or []]
+ self.application_tag = application_tag
+ self.provider_id = provider_id
+
+
+
+class UpdateApplicationServiceArgs(Type):
+ _toSchema = {'args': 'args'}
+ _toPy = {'args': 'args'}
+ def __init__(self, args=None, **unknown_fields):
+ '''
+ args : typing.Sequence[~UpdateApplicationServiceArg]
+ '''
+ self.args = [UpdateApplicationServiceArg.from_json(o) for o in args or []]
+
+
+
+class UpdateApplicationUnitArgs(Type):
+ _toSchema = {'args': 'args'}
+ _toPy = {'args': 'args'}
+ def __init__(self, args=None, **unknown_fields):
+ '''
+ args : typing.Sequence[~UpdateApplicationUnits]
+ '''
+ self.args = [UpdateApplicationUnits.from_json(o) for o in args or []]
+
+
+
+class UpdateApplicationUnits(Type):
+ _toSchema = {'application_tag': 'application-tag', 'units': 'units'}
+ _toPy = {'application-tag': 'application_tag', 'units': 'units'}
+ def __init__(self, application_tag=None, units=None, **unknown_fields):
+ '''
+ application_tag : str
+ units : typing.Sequence[~ApplicationUnitParams]
+ '''
+ self.application_tag = application_tag
+ self.units = [ApplicationUnitParams.from_json(o) for o in units or []]
+
+
+
class UpdateBehavior(Type):
_toSchema = {'enable_os_refresh_update': 'enable-os-refresh-update', 'enable_os_upgrade': 'enable-os-upgrade'}
_toPy = {'enable-os-refresh-update': 'enable_os_refresh_update', 'enable-os-upgrade': 'enable_os_upgrade'}
_toPy = {'credentials': 'credentials'}
def __init__(self, credentials=None, **unknown_fields):
'''
- credentials : typing.Sequence<+T_co>[~UpdateCloudCredential]<~UpdateCloudCredential>
+ credentials : typing.Sequence[~UpdateCloudCredential]
'''
self.credentials = [UpdateCloudCredential.from_json(o) for o in credentials or []]
+class UpdateCredentialArgs(Type):
+ _toSchema = {'credentials': 'credentials', 'force': 'force'}
+ _toPy = {'credentials': 'credentials', 'force': 'force'}
+ def __init__(self, credentials=None, force=None, **unknown_fields):
+ '''
+ credentials : typing.Sequence[~TaggedCredential]
+ force : bool
+ '''
+ self.credentials = [TaggedCredential.from_json(o) for o in credentials or []]
+ self.force = force
+
+
+
+class UpdateCredentialModelResult(Type):
+ _toSchema = {'errors': 'errors', 'name': 'name', 'uuid': 'uuid'}
+ _toPy = {'errors': 'errors', 'name': 'name', 'uuid': 'uuid'}
+ def __init__(self, errors=None, name=None, uuid=None, **unknown_fields):
+ '''
+ errors : typing.Sequence[~ErrorResult]
+ name : str
+ uuid : str
+ '''
+ self.errors = [ErrorResult.from_json(o) for o in errors or []]
+ self.name = name
+ self.uuid = uuid
+
+
+
+class UpdateCredentialResult(Type):
+ _toSchema = {'error': 'error', 'models': 'models', 'tag': 'tag'}
+ _toPy = {'error': 'error', 'models': 'models', 'tag': 'tag'}
+ def __init__(self, error=None, models=None, tag=None, **unknown_fields):
+ '''
+ error : Error
+ models : typing.Sequence[~UpdateCredentialModelResult]
+ tag : str
+ '''
+ self.error = Error.from_json(error) if error else None
+ self.models = [UpdateCredentialModelResult.from_json(o) for o in models or []]
+ self.tag = tag
+
+
+
+class UpdateCredentialResults(Type):
+ _toSchema = {'results': 'results'}
+ _toPy = {'results': 'results'}
+ def __init__(self, results=None, **unknown_fields):
+ '''
+ results : typing.Sequence[~UpdateCredentialResult]
+ '''
+ self.results = [UpdateCredentialResult.from_json(o) for o in results or []]
+
+
+
+class UpdateSeriesArg(Type):
+ _toSchema = {'force': 'force', 'series': 'series', 'tag': 'tag'}
+ _toPy = {'force': 'force', 'series': 'series', 'tag': 'tag'}
+ def __init__(self, force=None, series=None, tag=None, **unknown_fields):
+ '''
+ force : bool
+ series : str
+ tag : Entity
+ '''
+ self.force = force
+ self.series = series
+ self.tag = Entity.from_json(tag) if tag else None
+
+
+
+class UpdateSeriesArgs(Type):
+ _toSchema = {'args': 'args'}
+ _toPy = {'args': 'args'}
+ def __init__(self, args=None, **unknown_fields):
+ '''
+ args : typing.Sequence[~UpdateSeriesArg]
+ '''
+ self.args = [UpdateSeriesArg.from_json(o) for o in args or []]
+
+
+
class UpgradeMongoParams(Type):
_toSchema = {'target': 'target'}
_toPy = {'target': 'target'}
+class UpgradeSeriesNotificationParam(Type):
+ _toSchema = {'entity': 'entity', 'watcher_id': 'watcher-id'}
+ _toPy = {'entity': 'entity', 'watcher-id': 'watcher_id'}
+ def __init__(self, entity=None, watcher_id=None, **unknown_fields):
+ '''
+ entity : Entity
+ watcher_id : str
+ '''
+ self.entity = Entity.from_json(entity) if entity else None
+ self.watcher_id = watcher_id
+
+
+
+class UpgradeSeriesNotificationParams(Type):
+ _toSchema = {'params': 'params'}
+ _toPy = {'params': 'params'}
+ def __init__(self, params=None, **unknown_fields):
+ '''
+ params : typing.Sequence[~UpgradeSeriesNotificationParam]
+ '''
+ self.params = [UpgradeSeriesNotificationParam.from_json(o) for o in params or []]
+
+
+
+class UpgradeSeriesStartUnitCompletionParam(Type):
+ _toSchema = {'entities': 'entities', 'message': 'message'}
+ _toPy = {'entities': 'entities', 'message': 'message'}
+ def __init__(self, entities=None, message=None, **unknown_fields):
+ '''
+ entities : typing.Sequence[~Entity]
+ message : str
+ '''
+ self.entities = [Entity.from_json(o) for o in entities or []]
+ self.message = message
+
+
+
+class UpgradeSeriesStatusParam(Type):
+ _toSchema = {'entity': 'entity', 'message': 'message', 'status': 'status'}
+ _toPy = {'entity': 'entity', 'message': 'message', 'status': 'status'}
+ def __init__(self, entity=None, message=None, status=None, **unknown_fields):
+ '''
+ entity : Entity
+ message : str
+ status : str
+ '''
+ self.entity = Entity.from_json(entity) if entity else None
+ self.message = message
+ self.status = status
+
+
+
+class UpgradeSeriesStatusParams(Type):
+ _toSchema = {'params': 'params'}
+ _toPy = {'params': 'params'}
+ def __init__(self, params=None, **unknown_fields):
+ '''
+ params : typing.Sequence[~UpgradeSeriesStatusParam]
+ '''
+ self.params = [UpgradeSeriesStatusParam.from_json(o) for o in params or []]
+
+
+
+class UpgradeSeriesStatusResult(Type):
+ _toSchema = {'error': 'error', 'status': 'status'}
+ _toPy = {'error': 'error', 'status': 'status'}
+ def __init__(self, error=None, status=None, **unknown_fields):
+ '''
+ error : Error
+ status : str
+ '''
+ self.error = Error.from_json(error) if error else None
+ self.status = status
+
+
+
+class UpgradeSeriesStatusResults(Type):
+ _toSchema = {'results': 'results'}
+ _toPy = {'results': 'results'}
+ def __init__(self, results=None, **unknown_fields):
+ '''
+ results : typing.Sequence[~UpgradeSeriesStatusResult]
+ '''
+ self.results = [UpgradeSeriesStatusResult.from_json(o) for o in results or []]
+
+
+
+class UpgradeSeriesUnitsResult(Type):
+ _toSchema = {'error': 'error', 'unit_names': 'unit-names'}
+ _toPy = {'error': 'error', 'unit-names': 'unit_names'}
+ def __init__(self, error=None, unit_names=None, **unknown_fields):
+ '''
+ error : Error
+ unit_names : typing.Sequence[str]
+ '''
+ self.error = Error.from_json(error) if error else None
+ self.unit_names = unit_names
+
+
+
+class UpgradeSeriesUnitsResults(Type):
+ _toSchema = {'results': 'Results'}
+ _toPy = {'Results': 'results'}
+ def __init__(self, results=None, **unknown_fields):
+ '''
+ results : typing.Sequence[~UpgradeSeriesUnitsResult]
+ '''
+ self.results = [UpgradeSeriesUnitsResult.from_json(o) for o in results or []]
+
+
+
class UserAccess(Type):
_toSchema = {'access': 'access', 'user_tag': 'user-tag'}
_toPy = {'access': 'access', 'user-tag': 'user_tag'}
_toPy = {'results': 'results'}
def __init__(self, results=None, **unknown_fields):
'''
- results : typing.Sequence<+T_co>[~UserAccessResult]<~UserAccessResult>
+ results : typing.Sequence[~UserAccessResult]
'''
self.results = [UserAccessResult.from_json(o) for o in results or []]
_toPy = {'user-clouds': 'user_clouds'}
def __init__(self, user_clouds=None, **unknown_fields):
'''
- user_clouds : typing.Sequence<+T_co>[~UserCloud]<~UserCloud>
+ user_clouds : typing.Sequence[~UserCloud]
'''
self.user_clouds = [UserCloud.from_json(o) for o in user_clouds or []]
_toPy = {'entities': 'entities', 'include-disabled': 'include_disabled'}
def __init__(self, entities=None, include_disabled=None, **unknown_fields):
'''
- entities : typing.Sequence<+T_co>[~Entity]<~Entity>
+ entities : typing.Sequence[~Entity]
include_disabled : bool
'''
self.entities = [Entity.from_json(o) for o in entities or []]
_toPy = {'results': 'results'}
def __init__(self, results=None, **unknown_fields):
'''
- results : typing.Sequence<+T_co>[~UserInfoResult]<~UserInfoResult>
+ results : typing.Sequence[~UserInfoResult]
'''
self.results = [UserInfoResult.from_json(o) for o in results or []]
_toPy = {'user-models': 'user_models'}
def __init__(self, user_models=None, **unknown_fields):
'''
- user_models : typing.Sequence<+T_co>[~UserModel]<~UserModel>
+ user_models : typing.Sequence[~UserModel]
'''
self.user_models = [UserModel.from_json(o) for o in user_models or []]
instance_type : str
mem : int
root_disk : int
- spaces : typing.Sequence<+T_co>[str]
- tags : typing.Sequence<+T_co>[str]
+ spaces : typing.Sequence[str]
+ tags : typing.Sequence[str]
virt_type : str
'''
self.arch = arch
_toPy = {'results': 'results'}
def __init__(self, results=None, **unknown_fields):
'''
- results : typing.Sequence<+T_co>[~VersionResult]<~VersionResult>
+ results : typing.Sequence[~VersionResult]
'''
self.results = [VersionResult.from_json(o) for o in results or []]
_toPy = {'results': 'results'}
def __init__(self, results=None, **unknown_fields):
'''
- results : typing.Sequence<+T_co>[~VolumeAttachmentParamsResult]<~VolumeAttachmentParamsResult>
+ results : typing.Sequence[~VolumeAttachmentParamsResult]
'''
self.results = [VolumeAttachmentParamsResult.from_json(o) for o in results or []]
+class VolumeAttachmentPlan(Type):
+ _toSchema = {'block_device': 'block-device', 'life': 'life', 'machine_tag': 'machine-tag', 'plan_info': 'plan-info', 'volume_tag': 'volume-tag'}
+ _toPy = {'block-device': 'block_device', 'life': 'life', 'machine-tag': 'machine_tag', 'plan-info': 'plan_info', 'volume-tag': 'volume_tag'}
+ def __init__(self, block_device=None, life=None, machine_tag=None, plan_info=None, volume_tag=None, **unknown_fields):
+ '''
+ block_device : BlockDevice
+ life : str
+ machine_tag : str
+ plan_info : VolumeAttachmentPlanInfo
+ volume_tag : str
+ '''
+ self.block_device = BlockDevice.from_json(block_device) if block_device else None
+ self.life = life
+ self.machine_tag = machine_tag
+ self.plan_info = VolumeAttachmentPlanInfo.from_json(plan_info) if plan_info else None
+ self.volume_tag = volume_tag
+
+
+
+class VolumeAttachmentPlanInfo(Type):
+ _toSchema = {'device_attributes': 'device-attributes', 'device_type': 'device-type'}
+ _toPy = {'device-attributes': 'device_attributes', 'device-type': 'device_type'}
+ def __init__(self, device_attributes=None, device_type=None, **unknown_fields):
+ '''
+ device_attributes : typing.Mapping[str, str]
+ device_type : str
+ '''
+ self.device_attributes = device_attributes
+ self.device_type = device_type
+
+
+
+class VolumeAttachmentPlanResult(Type):
+ _toSchema = {'error': 'error', 'result': 'result'}
+ _toPy = {'error': 'error', 'result': 'result'}
+ def __init__(self, error=None, result=None, **unknown_fields):
+ '''
+ error : Error
+ result : VolumeAttachmentPlan
+ '''
+ self.error = Error.from_json(error) if error else None
+ self.result = VolumeAttachmentPlan.from_json(result) if result else None
+
+
+
+class VolumeAttachmentPlanResults(Type):
+ _toSchema = {'results': 'results'}
+ _toPy = {'results': 'results'}
+ def __init__(self, results=None, **unknown_fields):
+ '''
+ results : typing.Sequence[~VolumeAttachmentPlanResult]
+ '''
+ self.results = [VolumeAttachmentPlanResult.from_json(o) for o in results or []]
+
+
+
+class VolumeAttachmentPlans(Type):
+ _toSchema = {'volume_plans': 'volume-plans'}
+ _toPy = {'volume-plans': 'volume_plans'}
+ def __init__(self, volume_plans=None, **unknown_fields):
+ '''
+ volume_plans : typing.Sequence[~VolumeAttachmentPlan]
+ '''
+ self.volume_plans = [VolumeAttachmentPlan.from_json(o) for o in volume_plans or []]
+
+
+
class VolumeAttachmentResult(Type):
_toSchema = {'error': 'error', 'result': 'result'}
_toPy = {'error': 'error', 'result': 'result'}
_toPy = {'results': 'results'}
def __init__(self, results=None, **unknown_fields):
'''
- results : typing.Sequence<+T_co>[~VolumeAttachmentResult]<~VolumeAttachmentResult>
+ results : typing.Sequence[~VolumeAttachmentResult]
'''
self.results = [VolumeAttachmentResult.from_json(o) for o in results or []]
_toPy = {'volume-attachments': 'volume_attachments'}
def __init__(self, volume_attachments=None, **unknown_fields):
'''
- volume_attachments : typing.Sequence<+T_co>[~VolumeAttachment]<~VolumeAttachment>
+ volume_attachments : typing.Sequence[~VolumeAttachment]
'''
self.volume_attachments = [VolumeAttachment.from_json(o) for o in volume_attachments or []]
def __init__(self, info=None, machine_attachments=None, status=None, storage=None, volume_tag=None, **unknown_fields):
'''
info : VolumeInfo
- machine_attachments : typing.Mapping<~KT, +VT_co>[str, ~VolumeAttachmentInfo]<~VolumeAttachmentInfo>
+ machine_attachments : typing.Mapping[str, ~VolumeAttachmentInfo]
status : EntityStatus
storage : StorageDetails
volume_tag : str
def __init__(self, error=None, result=None, **unknown_fields):
'''
error : Error
- result : typing.Sequence<+T_co>[~VolumeDetails]<~VolumeDetails>
+ result : typing.Sequence[~VolumeDetails]
'''
self.error = Error.from_json(error) if error else None
self.result = [VolumeDetails.from_json(o) for o in result or []]
_toPy = {'results': 'results'}
def __init__(self, results=None, **unknown_fields):
'''
- results : typing.Sequence<+T_co>[~VolumeDetailsListResult]<~VolumeDetailsListResult>
+ results : typing.Sequence[~VolumeDetailsListResult]
'''
self.results = [VolumeDetailsListResult.from_json(o) for o in results or []]
_toPy = {'machines': 'machines'}
def __init__(self, machines=None, **unknown_fields):
'''
- machines : typing.Sequence<+T_co>[str]
+ machines : typing.Sequence[str]
'''
self.machines = machines
_toPy = {'filters': 'filters'}
def __init__(self, filters=None, **unknown_fields):
'''
- filters : typing.Sequence<+T_co>[~VolumeFilter]<~VolumeFilter>
+ filters : typing.Sequence[~VolumeFilter]
'''
self.filters = [VolumeFilter.from_json(o) for o in filters or []]
def __init__(self, attachment=None, attributes=None, provider=None, size=None, tags=None, volume_tag=None, **unknown_fields):
'''
attachment : VolumeAttachmentParams
- attributes : typing.Mapping<~KT, +VT_co>[str, typing.Any]
+ attributes : typing.Mapping[str, typing.Any]
provider : str
size : int
- tags : typing.Mapping<~KT, +VT_co>[str, str]
+ tags : typing.Mapping[str, str]
volume_tag : str
'''
self.attachment = VolumeAttachmentParams.from_json(attachment) if attachment else None
_toPy = {'results': 'results'}
def __init__(self, results=None, **unknown_fields):
'''
- results : typing.Sequence<+T_co>[~VolumeParamsResult]<~VolumeParamsResult>
+ results : typing.Sequence[~VolumeParamsResult]
'''
self.results = [VolumeParamsResult.from_json(o) for o in results or []]
_toPy = {'results': 'results'}
def __init__(self, results=None, **unknown_fields):
'''
- results : typing.Sequence<+T_co>[~VolumeResult]<~VolumeResult>
+ results : typing.Sequence[~VolumeResult]
'''
self.results = [VolumeResult.from_json(o) for o in results or []]
_toPy = {'volumes': 'volumes'}
def __init__(self, volumes=None, **unknown_fields):
'''
- volumes : typing.Sequence<+T_co>[~Volume]<~Volume>
+ volumes : typing.Sequence[~Volume]
'''
self.volumes = [Volume.from_json(o) for o in volumes or []]
_toPy = {'params': 'params'}
def __init__(self, params=None, **unknown_fields):
'''
- params : typing.Sequence<+T_co>[~WatchContainer]<~WatchContainer>
+ params : typing.Sequence[~WatchContainer]
'''
self.params = [WatchContainer.from_json(o) for o in params or []]
_toPy = {'results': 'results'}
def __init__(self, results=None, **unknown_fields):
'''
- results : typing.Sequence<+T_co>[~ZoneResult]<~ZoneResult>
+ results : typing.Sequence[~ZoneResult]
'''
self.results = [ZoneResult.from_json(o) for o in results or []]
projects / osm / N2VC.git / blobdiff