hexsha stringlengths 40 40 | repo stringlengths 7 114 | path stringlengths 4 124 | license listlengths 1 9 | language stringclasses 1
value | identifier stringlengths 1 71 | return_type stringlengths 1 749 ⌀ | original_string stringlengths 76 22.7k | original_docstring stringlengths 16 7.61k | docstring stringlengths 16 2.47k | docstring_tokens listlengths 6 477 | code stringlengths 14 10.2k | code_tokens listlengths 6 996 | short_docstring stringlengths 2 644 | short_docstring_tokens listlengths 1 116 | comment listlengths 1 89 | parameters listlengths 0 64 | docstring_params dict |
|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
f697638db76b9fc35cd762f0cbbb058c9ee6f5b1 | sed-i/python-libjuju | juju/client/_client2.py | [
"Apache-2.0"
] | Python | WatchApplications | <not_specific> | async def WatchApplications(self):
'''
WatchApplications starts a StringsWatcher to watch applications deployed to this model.
Returns -> StringsWatchResult
'''
# map input types to rpc msg
_params = dict()
msg = dict(type='CAASUnitProvisioner',
... |
WatchApplications starts a StringsWatcher to watch applications deployed to this model.
Returns -> StringsWatchResult
| WatchApplications starts a StringsWatcher to watch applications deployed to this model. | [
"WatchApplications",
"starts",
"a",
"StringsWatcher",
"to",
"watch",
"applications",
"deployed",
"to",
"this",
"model",
"."
] | async def WatchApplications(self):
_params = dict()
msg = dict(type='CAASUnitProvisioner',
request='WatchApplications',
version=2,
params=_params)
reply = await self.rpc(msg)
return reply | [
"async",
"def",
"WatchApplications",
"(",
"self",
")",
":",
"_params",
"=",
"dict",
"(",
")",
"msg",
"=",
"dict",
"(",
"type",
"=",
"'CAASUnitProvisioner'",
",",
"request",
"=",
"'WatchApplications'",
",",
"version",
"=",
"2",
",",
"params",
"=",
"_params"... | WatchApplications starts a StringsWatcher to watch applications deployed to this model. | [
"WatchApplications",
"starts",
"a",
"StringsWatcher",
"to",
"watch",
"applications",
"deployed",
"to",
"this",
"model",
"."
] | [
"'''\n WatchApplications starts a StringsWatcher to watch applications deployed to this model.\n\n\n Returns -> StringsWatchResult\n '''",
"# map input types to rpc msg"
] | [
{
"param": "self",
"type": null
}
] | {
"returns": [],
"raises": [],
"params": [
{
"identifier": "self",
"type": null,
"docstring": null,
"docstring_tokens": [],
"default": null,
"is_optional": null
}
],
"outlier_params": [],
"others": []
} |
f697638db76b9fc35cd762f0cbbb058c9ee6f5b1 | sed-i/python-libjuju | juju/client/_client2.py | [
"Apache-2.0"
] | Python | WatchApplicationsScale | <not_specific> | async def WatchApplicationsScale(self, entities=None):
'''
WatchApplicationsScale starts a NotifyWatcher to watch changes
to the applications' scale.
entities : typing.Sequence[~Entity]
Returns -> NotifyWatchResults
'''
if entities is not None and not isinstance(... |
WatchApplicationsScale starts a NotifyWatcher to watch changes
to the applications' scale.
entities : typing.Sequence[~Entity]
Returns -> NotifyWatchResults
| WatchApplicationsScale starts a NotifyWatcher to watch changes
to the applications' scale.
entities : typing.Sequence[~Entity]
Returns -> NotifyWatchResults | [
"WatchApplicationsScale",
"starts",
"a",
"NotifyWatcher",
"to",
"watch",
"changes",
"to",
"the",
"applications",
"'",
"scale",
".",
"entities",
":",
"typing",
".",
"Sequence",
"[",
"~Entity",
"]",
"Returns",
"-",
">",
"NotifyWatchResults"
] | async def WatchApplicationsScale(self, entities=None):
if entities is not None and not isinstance(entities, (bytes, str, list)):
raise Exception("Expected entities to be a Sequence, received: {}".format(type(entities)))
_params = dict()
msg = dict(type='CAASUnitProvisioner',
... | [
"async",
"def",
"WatchApplicationsScale",
"(",
"self",
",",
"entities",
"=",
"None",
")",
":",
"if",
"entities",
"is",
"not",
"None",
"and",
"not",
"isinstance",
"(",
"entities",
",",
"(",
"bytes",
",",
"str",
",",
"list",
")",
")",
":",
"raise",
"Exce... | WatchApplicationsScale starts a NotifyWatcher to watch changes
to the applications' scale. | [
"WatchApplicationsScale",
"starts",
"a",
"NotifyWatcher",
"to",
"watch",
"changes",
"to",
"the",
"applications",
"'",
"scale",
"."
] | [
"'''\n WatchApplicationsScale starts a NotifyWatcher to watch changes\n to the applications' scale.\n\n entities : typing.Sequence[~Entity]\n Returns -> NotifyWatchResults\n '''",
"# map input types to rpc msg"
] | [
{
"param": "self",
"type": null
},
{
"param": "entities",
"type": null
}
] | {
"returns": [],
"raises": [],
"params": [
{
"identifier": "self",
"type": null,
"docstring": null,
"docstring_tokens": [],
"default": null,
"is_optional": null
},
{
"identifier": "entities",
"type": null,
"docstring": null,
"docstring_tokens... |
f697638db76b9fc35cd762f0cbbb058c9ee6f5b1 | sed-i/python-libjuju | juju/client/_client2.py | [
"Apache-2.0"
] | Python | WatchApplicationsTrustHash | <not_specific> | async def WatchApplicationsTrustHash(self, entities=None):
'''
WatchApplicationsTrustHash starts a StringsWatcher to watch changes
to the applications' trust status.
entities : typing.Sequence[~Entity]
Returns -> StringsWatchResults
'''
if entities is not None an... |
WatchApplicationsTrustHash starts a StringsWatcher to watch changes
to the applications' trust status.
entities : typing.Sequence[~Entity]
Returns -> StringsWatchResults
| WatchApplicationsTrustHash starts a StringsWatcher to watch changes
to the applications' trust status.
entities : typing.Sequence[~Entity]
Returns -> StringsWatchResults | [
"WatchApplicationsTrustHash",
"starts",
"a",
"StringsWatcher",
"to",
"watch",
"changes",
"to",
"the",
"applications",
"'",
"trust",
"status",
".",
"entities",
":",
"typing",
".",
"Sequence",
"[",
"~Entity",
"]",
"Returns",
"-",
">",
"StringsWatchResults"
] | async def WatchApplicationsTrustHash(self, entities=None):
if entities is not None and not isinstance(entities, (bytes, str, list)):
raise Exception("Expected entities to be a Sequence, received: {}".format(type(entities)))
_params = dict()
msg = dict(type='CAASUnitProvisioner',
... | [
"async",
"def",
"WatchApplicationsTrustHash",
"(",
"self",
",",
"entities",
"=",
"None",
")",
":",
"if",
"entities",
"is",
"not",
"None",
"and",
"not",
"isinstance",
"(",
"entities",
",",
"(",
"bytes",
",",
"str",
",",
"list",
")",
")",
":",
"raise",
"... | WatchApplicationsTrustHash starts a StringsWatcher to watch changes
to the applications' trust status. | [
"WatchApplicationsTrustHash",
"starts",
"a",
"StringsWatcher",
"to",
"watch",
"changes",
"to",
"the",
"applications",
"'",
"trust",
"status",
"."
] | [
"'''\n WatchApplicationsTrustHash starts a StringsWatcher to watch changes\n to the applications' trust status.\n\n entities : typing.Sequence[~Entity]\n Returns -> StringsWatchResults\n '''",
"# map input types to rpc msg"
] | [
{
"param": "self",
"type": null
},
{
"param": "entities",
"type": null
}
] | {
"returns": [],
"raises": [],
"params": [
{
"identifier": "self",
"type": null,
"docstring": null,
"docstring_tokens": [],
"default": null,
"is_optional": null
},
{
"identifier": "entities",
"type": null,
"docstring": null,
"docstring_tokens... |
f697638db76b9fc35cd762f0cbbb058c9ee6f5b1 | sed-i/python-libjuju | juju/client/_client2.py | [
"Apache-2.0"
] | Python | WatchPodSpec | <not_specific> | async def WatchPodSpec(self, entities=None):
'''
WatchPodSpec starts a NotifyWatcher to watch changes to the
pod spec for specified units in this model.
entities : typing.Sequence[~Entity]
Returns -> NotifyWatchResults
'''
if entities is not None and not isinstan... |
WatchPodSpec starts a NotifyWatcher to watch changes to the
pod spec for specified units in this model.
entities : typing.Sequence[~Entity]
Returns -> NotifyWatchResults
| WatchPodSpec starts a NotifyWatcher to watch changes to the
pod spec for specified units in this model.
entities : typing.Sequence[~Entity]
Returns -> NotifyWatchResults | [
"WatchPodSpec",
"starts",
"a",
"NotifyWatcher",
"to",
"watch",
"changes",
"to",
"the",
"pod",
"spec",
"for",
"specified",
"units",
"in",
"this",
"model",
".",
"entities",
":",
"typing",
".",
"Sequence",
"[",
"~Entity",
"]",
"Returns",
"-",
">",
"NotifyWatchR... | async def WatchPodSpec(self, entities=None):
if entities is not None and not isinstance(entities, (bytes, str, list)):
raise Exception("Expected entities to be a Sequence, received: {}".format(type(entities)))
_params = dict()
msg = dict(type='CAASUnitProvisioner',
... | [
"async",
"def",
"WatchPodSpec",
"(",
"self",
",",
"entities",
"=",
"None",
")",
":",
"if",
"entities",
"is",
"not",
"None",
"and",
"not",
"isinstance",
"(",
"entities",
",",
"(",
"bytes",
",",
"str",
",",
"list",
")",
")",
":",
"raise",
"Exception",
... | WatchPodSpec starts a NotifyWatcher to watch changes to the
pod spec for specified units in this model. | [
"WatchPodSpec",
"starts",
"a",
"NotifyWatcher",
"to",
"watch",
"changes",
"to",
"the",
"pod",
"spec",
"for",
"specified",
"units",
"in",
"this",
"model",
"."
] | [
"'''\n WatchPodSpec starts a NotifyWatcher to watch changes to the\n pod spec for specified units in this model.\n\n entities : typing.Sequence[~Entity]\n Returns -> NotifyWatchResults\n '''",
"# map input types to rpc msg"
] | [
{
"param": "self",
"type": null
},
{
"param": "entities",
"type": null
}
] | {
"returns": [],
"raises": [],
"params": [
{
"identifier": "self",
"type": null,
"docstring": null,
"docstring_tokens": [],
"default": null,
"is_optional": null
},
{
"identifier": "entities",
"type": null,
"docstring": null,
"docstring_tokens... |
f697638db76b9fc35cd762f0cbbb058c9ee6f5b1 | sed-i/python-libjuju | juju/client/_client2.py | [
"Apache-2.0"
] | Python | UpdateLatestRevisions | <not_specific> | async def UpdateLatestRevisions(self):
'''
UpdateLatestRevisions retrieves the latest revision information from the charm store for all deployed charms
and records this information in state.
Returns -> ErrorResult
'''
# map input types to rpc msg
_params = dict... |
UpdateLatestRevisions retrieves the latest revision information from the charm store for all deployed charms
and records this information in state.
Returns -> ErrorResult
| UpdateLatestRevisions retrieves the latest revision information from the charm store for all deployed charms
and records this information in state.
| [
"UpdateLatestRevisions",
"retrieves",
"the",
"latest",
"revision",
"information",
"from",
"the",
"charm",
"store",
"for",
"all",
"deployed",
"charms",
"and",
"records",
"this",
"information",
"in",
"state",
"."
] | async def UpdateLatestRevisions(self):
_params = dict()
msg = dict(type='CharmRevisionUpdater',
request='UpdateLatestRevisions',
version=2,
params=_params)
reply = await self.rpc(msg)
return reply | [
"async",
"def",
"UpdateLatestRevisions",
"(",
"self",
")",
":",
"_params",
"=",
"dict",
"(",
")",
"msg",
"=",
"dict",
"(",
"type",
"=",
"'CharmRevisionUpdater'",
",",
"request",
"=",
"'UpdateLatestRevisions'",
",",
"version",
"=",
"2",
",",
"params",
"=",
... | UpdateLatestRevisions retrieves the latest revision information from the charm store for all deployed charms
and records this information in state. | [
"UpdateLatestRevisions",
"retrieves",
"the",
"latest",
"revision",
"information",
"from",
"the",
"charm",
"store",
"for",
"all",
"deployed",
"charms",
"and",
"records",
"this",
"information",
"in",
"state",
"."
] | [
"'''\n UpdateLatestRevisions retrieves the latest revision information from the charm store for all deployed charms\n and records this information in state.\n\n\n Returns -> ErrorResult\n '''",
"# map input types to rpc msg"
] | [
{
"param": "self",
"type": null
}
] | {
"returns": [],
"raises": [],
"params": [
{
"identifier": "self",
"type": null,
"docstring": null,
"docstring_tokens": [],
"default": null,
"is_optional": null
}
],
"outlier_params": [],
"others": []
} |
f697638db76b9fc35cd762f0cbbb058c9ee6f5b1 | sed-i/python-libjuju | juju/client/_client2.py | [
"Apache-2.0"
] | Python | CharmInfo | <not_specific> | async def CharmInfo(self, url=None):
'''
CharmInfo returns information about the requested charm.
NOTE: thumper 2016-06-29, this is not a bulk call and probably should be.
url : str
Returns -> Charm
'''
if url is not None and not isinstance(url, (bytes, str)):
... |
CharmInfo returns information about the requested charm.
NOTE: thumper 2016-06-29, this is not a bulk call and probably should be.
url : str
Returns -> Charm
| CharmInfo returns information about the requested charm.
NOTE: thumper 2016-06-29, this is not a bulk call and probably should be.
url : str
Returns -> Charm | [
"CharmInfo",
"returns",
"information",
"about",
"the",
"requested",
"charm",
".",
"NOTE",
":",
"thumper",
"2016",
"-",
"06",
"-",
"29",
"this",
"is",
"not",
"a",
"bulk",
"call",
"and",
"probably",
"should",
"be",
".",
"url",
":",
"str",
"Returns",
"-",
... | async def CharmInfo(self, url=None):
if url is not None and not isinstance(url, (bytes, str)):
raise Exception("Expected url to be a str, received: {}".format(type(url)))
_params = dict()
msg = dict(type='Charms',
request='CharmInfo',
version=2,
... | [
"async",
"def",
"CharmInfo",
"(",
"self",
",",
"url",
"=",
"None",
")",
":",
"if",
"url",
"is",
"not",
"None",
"and",
"not",
"isinstance",
"(",
"url",
",",
"(",
"bytes",
",",
"str",
")",
")",
":",
"raise",
"Exception",
"(",
"\"Expected url to be a str,... | CharmInfo returns information about the requested charm. | [
"CharmInfo",
"returns",
"information",
"about",
"the",
"requested",
"charm",
"."
] | [
"'''\n CharmInfo returns information about the requested charm.\n NOTE: thumper 2016-06-29, this is not a bulk call and probably should be.\n\n url : str\n Returns -> Charm\n '''",
"# map input types to rpc msg"
] | [
{
"param": "self",
"type": null
},
{
"param": "url",
"type": null
}
] | {
"returns": [],
"raises": [],
"params": [
{
"identifier": "self",
"type": null,
"docstring": null,
"docstring_tokens": [],
"default": null,
"is_optional": null
},
{
"identifier": "url",
"type": null,
"docstring": null,
"docstring_tokens": []... |
f697638db76b9fc35cd762f0cbbb058c9ee6f5b1 | sed-i/python-libjuju | juju/client/_client2.py | [
"Apache-2.0"
] | Python | IsMetered | <not_specific> | async def IsMetered(self, url=None):
'''
IsMetered returns whether or not the charm is metered.
url : str
Returns -> IsMeteredResult
'''
if url is not None and not isinstance(url, (bytes, str)):
raise Exception("Expected url to be a str, received: {}".format(... |
IsMetered returns whether or not the charm is metered.
url : str
Returns -> IsMeteredResult
| IsMetered returns whether or not the charm is metered.
url : str
Returns -> IsMeteredResult | [
"IsMetered",
"returns",
"whether",
"or",
"not",
"the",
"charm",
"is",
"metered",
".",
"url",
":",
"str",
"Returns",
"-",
">",
"IsMeteredResult"
] | async def IsMetered(self, url=None):
if url is not None and not isinstance(url, (bytes, str)):
raise Exception("Expected url to be a str, received: {}".format(type(url)))
_params = dict()
msg = dict(type='Charms',
request='IsMetered',
version=2,
... | [
"async",
"def",
"IsMetered",
"(",
"self",
",",
"url",
"=",
"None",
")",
":",
"if",
"url",
"is",
"not",
"None",
"and",
"not",
"isinstance",
"(",
"url",
",",
"(",
"bytes",
",",
"str",
")",
")",
":",
"raise",
"Exception",
"(",
"\"Expected url to be a str,... | IsMetered returns whether or not the charm is metered. | [
"IsMetered",
"returns",
"whether",
"or",
"not",
"the",
"charm",
"is",
"metered",
"."
] | [
"'''\n IsMetered returns whether or not the charm is metered.\n\n url : str\n Returns -> IsMeteredResult\n '''",
"# map input types to rpc msg"
] | [
{
"param": "self",
"type": null
},
{
"param": "url",
"type": null
}
] | {
"returns": [],
"raises": [],
"params": [
{
"identifier": "self",
"type": null,
"docstring": null,
"docstring_tokens": [],
"default": null,
"is_optional": null
},
{
"identifier": "url",
"type": null,
"docstring": null,
"docstring_tokens": []... |
f697638db76b9fc35cd762f0cbbb058c9ee6f5b1 | sed-i/python-libjuju | juju/client/_client2.py | [
"Apache-2.0"
] | Python | List | <not_specific> | async def List(self, names=None):
'''
List returns a list of charm URLs currently in the state.
If supplied parameter contains any names, the result will be filtered
to return only the charms with supplied names.
names : typing.Sequence[str]
Returns -> CharmsListResult
... |
List returns a list of charm URLs currently in the state.
If supplied parameter contains any names, the result will be filtered
to return only the charms with supplied names.
names : typing.Sequence[str]
Returns -> CharmsListResult
| List returns a list of charm URLs currently in the state.
If supplied parameter contains any names, the result will be filtered
to return only the charms with supplied names.
names : typing.Sequence[str]
Returns -> CharmsListResult | [
"List",
"returns",
"a",
"list",
"of",
"charm",
"URLs",
"currently",
"in",
"the",
"state",
".",
"If",
"supplied",
"parameter",
"contains",
"any",
"names",
"the",
"result",
"will",
"be",
"filtered",
"to",
"return",
"only",
"the",
"charms",
"with",
"supplied",
... | async def List(self, names=None):
if names is not None and not isinstance(names, (bytes, str, list)):
raise Exception("Expected names to be a Sequence, received: {}".format(type(names)))
_params = dict()
msg = dict(type='Charms',
request='List',
... | [
"async",
"def",
"List",
"(",
"self",
",",
"names",
"=",
"None",
")",
":",
"if",
"names",
"is",
"not",
"None",
"and",
"not",
"isinstance",
"(",
"names",
",",
"(",
"bytes",
",",
"str",
",",
"list",
")",
")",
":",
"raise",
"Exception",
"(",
"\"Expecte... | List returns a list of charm URLs currently in the state. | [
"List",
"returns",
"a",
"list",
"of",
"charm",
"URLs",
"currently",
"in",
"the",
"state",
"."
] | [
"'''\n List returns a list of charm URLs currently in the state.\n If supplied parameter contains any names, the result will be filtered\n to return only the charms with supplied names.\n\n names : typing.Sequence[str]\n Returns -> CharmsListResult\n '''",
"# map input ty... | [
{
"param": "self",
"type": null
},
{
"param": "names",
"type": null
}
] | {
"returns": [],
"raises": [],
"params": [
{
"identifier": "self",
"type": null,
"docstring": null,
"docstring_tokens": [],
"default": null,
"is_optional": null
},
{
"identifier": "names",
"type": null,
"docstring": null,
"docstring_tokens": ... |
f697638db76b9fc35cd762f0cbbb058c9ee6f5b1 | sed-i/python-libjuju | juju/client/_client2.py | [
"Apache-2.0"
] | Python | Cleanup | <not_specific> | async def Cleanup(self):
'''
Cleanup triggers a state cleanup
Returns -> None
'''
# map input types to rpc msg
_params = dict()
msg = dict(type='Cleaner',
request='Cleanup',
version=2,
params=_params)
... |
Cleanup triggers a state cleanup
Returns -> None
| Cleanup triggers a state cleanup
Returns -> None | [
"Cleanup",
"triggers",
"a",
"state",
"cleanup",
"Returns",
"-",
">",
"None"
] | async def Cleanup(self):
_params = dict()
msg = dict(type='Cleaner',
request='Cleanup',
version=2,
params=_params)
reply = await self.rpc(msg)
return reply | [
"async",
"def",
"Cleanup",
"(",
"self",
")",
":",
"_params",
"=",
"dict",
"(",
")",
"msg",
"=",
"dict",
"(",
"type",
"=",
"'Cleaner'",
",",
"request",
"=",
"'Cleanup'",
",",
"version",
"=",
"2",
",",
"params",
"=",
"_params",
")",
"reply",
"=",
"aw... | Cleanup triggers a state cleanup
Returns -> None | [
"Cleanup",
"triggers",
"a",
"state",
"cleanup",
"Returns",
"-",
">",
"None"
] | [
"'''\n Cleanup triggers a state cleanup\n\n\n Returns -> None\n '''",
"# map input types to rpc msg"
] | [
{
"param": "self",
"type": null
}
] | {
"returns": [],
"raises": [],
"params": [
{
"identifier": "self",
"type": null,
"docstring": null,
"docstring_tokens": [],
"default": null,
"is_optional": null
}
],
"outlier_params": [],
"others": []
} |
f697638db76b9fc35cd762f0cbbb058c9ee6f5b1 | sed-i/python-libjuju | juju/client/_client2.py | [
"Apache-2.0"
] | Python | WatchCleanups | <not_specific> | async def WatchCleanups(self):
'''
WatchChanges watches for cleanups to be perfomed in state
Returns -> NotifyWatchResult
'''
# map input types to rpc msg
_params = dict()
msg = dict(type='Cleaner',
request='WatchCleanups',
... |
WatchChanges watches for cleanups to be perfomed in state
Returns -> NotifyWatchResult
| WatchChanges watches for cleanups to be perfomed in state
Returns -> NotifyWatchResult | [
"WatchChanges",
"watches",
"for",
"cleanups",
"to",
"be",
"perfomed",
"in",
"state",
"Returns",
"-",
">",
"NotifyWatchResult"
] | async def WatchCleanups(self):
_params = dict()
msg = dict(type='Cleaner',
request='WatchCleanups',
version=2,
params=_params)
reply = await self.rpc(msg)
return reply | [
"async",
"def",
"WatchCleanups",
"(",
"self",
")",
":",
"_params",
"=",
"dict",
"(",
")",
"msg",
"=",
"dict",
"(",
"type",
"=",
"'Cleaner'",
",",
"request",
"=",
"'WatchCleanups'",
",",
"version",
"=",
"2",
",",
"params",
"=",
"_params",
")",
"reply",
... | WatchChanges watches for cleanups to be perfomed in state
Returns -> NotifyWatchResult | [
"WatchChanges",
"watches",
"for",
"cleanups",
"to",
"be",
"perfomed",
"in",
"state",
"Returns",
"-",
">",
"NotifyWatchResult"
] | [
"'''\n WatchChanges watches for cleanups to be perfomed in state\n\n\n Returns -> NotifyWatchResult\n '''",
"# map input types to rpc msg"
] | [
{
"param": "self",
"type": null
}
] | {
"returns": [],
"raises": [],
"params": [
{
"identifier": "self",
"type": null,
"docstring": null,
"docstring_tokens": [],
"default": null,
"is_optional": null
}
],
"outlier_params": [],
"others": []
} |
f697638db76b9fc35cd762f0cbbb058c9ee6f5b1 | sed-i/python-libjuju | juju/client/_client2.py | [
"Apache-2.0"
] | Python | APIHostPorts | <not_specific> | async def APIHostPorts(self):
'''
APIHostPorts returns the API host/port addresses stored in state.
Returns -> APIHostPortsResult
'''
# map input types to rpc msg
_params = dict()
msg = dict(type='Client',
request='APIHostPorts',
... |
APIHostPorts returns the API host/port addresses stored in state.
Returns -> APIHostPortsResult
| APIHostPorts returns the API host/port addresses stored in state. | [
"APIHostPorts",
"returns",
"the",
"API",
"host",
"/",
"port",
"addresses",
"stored",
"in",
"state",
"."
] | async def APIHostPorts(self):
_params = dict()
msg = dict(type='Client',
request='APIHostPorts',
version=2,
params=_params)
reply = await self.rpc(msg)
return reply | [
"async",
"def",
"APIHostPorts",
"(",
"self",
")",
":",
"_params",
"=",
"dict",
"(",
")",
"msg",
"=",
"dict",
"(",
"type",
"=",
"'Client'",
",",
"request",
"=",
"'APIHostPorts'",
",",
"version",
"=",
"2",
",",
"params",
"=",
"_params",
")",
"reply",
"... | APIHostPorts returns the API host/port addresses stored in state. | [
"APIHostPorts",
"returns",
"the",
"API",
"host",
"/",
"port",
"addresses",
"stored",
"in",
"state",
"."
] | [
"'''\n APIHostPorts returns the API host/port addresses stored in state.\n\n\n Returns -> APIHostPortsResult\n '''",
"# map input types to rpc msg"
] | [
{
"param": "self",
"type": null
}
] | {
"returns": [],
"raises": [],
"params": [
{
"identifier": "self",
"type": null,
"docstring": null,
"docstring_tokens": [],
"default": null,
"is_optional": null
}
],
"outlier_params": [],
"others": []
} |
f697638db76b9fc35cd762f0cbbb058c9ee6f5b1 | sed-i/python-libjuju | juju/client/_client2.py | [
"Apache-2.0"
] | Python | AbortCurrentUpgrade | <not_specific> | async def AbortCurrentUpgrade(self):
'''
AbortCurrentUpgrade aborts and archives the current upgrade
synchronisation record, if any.
Returns -> None
'''
# map input types to rpc msg
_params = dict()
msg = dict(type='Client',
request='... |
AbortCurrentUpgrade aborts and archives the current upgrade
synchronisation record, if any.
Returns -> None
| AbortCurrentUpgrade aborts and archives the current upgrade
synchronisation record, if any.
> None | [
"AbortCurrentUpgrade",
"aborts",
"and",
"archives",
"the",
"current",
"upgrade",
"synchronisation",
"record",
"if",
"any",
".",
">",
"None"
] | async def AbortCurrentUpgrade(self):
_params = dict()
msg = dict(type='Client',
request='AbortCurrentUpgrade',
version=2,
params=_params)
reply = await self.rpc(msg)
return reply | [
"async",
"def",
"AbortCurrentUpgrade",
"(",
"self",
")",
":",
"_params",
"=",
"dict",
"(",
")",
"msg",
"=",
"dict",
"(",
"type",
"=",
"'Client'",
",",
"request",
"=",
"'AbortCurrentUpgrade'",
",",
"version",
"=",
"2",
",",
"params",
"=",
"_params",
")",
... | AbortCurrentUpgrade aborts and archives the current upgrade
synchronisation record, if any. | [
"AbortCurrentUpgrade",
"aborts",
"and",
"archives",
"the",
"current",
"upgrade",
"synchronisation",
"record",
"if",
"any",
"."
] | [
"'''\n AbortCurrentUpgrade aborts and archives the current upgrade\n synchronisation record, if any.\n\n\n Returns -> None\n '''",
"# map input types to rpc msg"
] | [
{
"param": "self",
"type": null
}
] | {
"returns": [],
"raises": [],
"params": [
{
"identifier": "self",
"type": null,
"docstring": null,
"docstring_tokens": [],
"default": null,
"is_optional": null
}
],
"outlier_params": [],
"others": []
} |
f697638db76b9fc35cd762f0cbbb058c9ee6f5b1 | sed-i/python-libjuju | juju/client/_client2.py | [
"Apache-2.0"
] | Python | AddCharmWithAuthorization | <not_specific> | async def AddCharmWithAuthorization(self, channel=None, force=None, macaroon=None, url=None):
'''
AddCharmWithAuthorization adds the given charm URL (which must include
revision) to the model, if it does not exist yet. Local charms are not
supported, only charm store URLs. See also AddLo... |
AddCharmWithAuthorization adds the given charm URL (which must include
revision) to the model, if it does not exist yet. Local charms are not
supported, only charm store URLs. See also AddLocalCharm().
The authorization macaroon, args.CharmStoreMacaroon, may be omitted, in
whic... | AddCharmWithAuthorization adds the given charm URL (which must include
revision) to the model, if it does not exist yet. Local charms are not
supported, only charm store URLs.
The authorization macaroon, args.CharmStoreMacaroon, may be omitted, in
which case this call is equivalent to AddCharm.
AddCharmWithAuthorizat... | [
"AddCharmWithAuthorization",
"adds",
"the",
"given",
"charm",
"URL",
"(",
"which",
"must",
"include",
"revision",
")",
"to",
"the",
"model",
"if",
"it",
"does",
"not",
"exist",
"yet",
".",
"Local",
"charms",
"are",
"not",
"supported",
"only",
"charm",
"store... | async def AddCharmWithAuthorization(self, channel=None, force=None, macaroon=None, url=None):
if channel is not None and not isinstance(channel, (bytes, str)):
raise Exception("Expected channel to be a str, received: {}".format(type(channel)))
if force is not None and not isinstance(force, b... | [
"async",
"def",
"AddCharmWithAuthorization",
"(",
"self",
",",
"channel",
"=",
"None",
",",
"force",
"=",
"None",
",",
"macaroon",
"=",
"None",
",",
"url",
"=",
"None",
")",
":",
"if",
"channel",
"is",
"not",
"None",
"and",
"not",
"isinstance",
"(",
"c... | AddCharmWithAuthorization adds the given charm URL (which must include
revision) to the model, if it does not exist yet. | [
"AddCharmWithAuthorization",
"adds",
"the",
"given",
"charm",
"URL",
"(",
"which",
"must",
"include",
"revision",
")",
"to",
"the",
"model",
"if",
"it",
"does",
"not",
"exist",
"yet",
"."
] | [
"'''\n AddCharmWithAuthorization adds the given charm URL (which must include\n revision) to the model, if it does not exist yet. Local charms are not\n supported, only charm store URLs. See also AddLocalCharm().\n\n The authorization macaroon, args.CharmStoreMacaroon, may be omitted, in... | [
{
"param": "self",
"type": null
},
{
"param": "channel",
"type": null
},
{
"param": "force",
"type": null
},
{
"param": "macaroon",
"type": null
},
{
"param": "url",
"type": null
}
] | {
"returns": [],
"raises": [],
"params": [
{
"identifier": "self",
"type": null,
"docstring": null,
"docstring_tokens": [],
"default": null,
"is_optional": null
},
{
"identifier": "channel",
"type": null,
"docstring": null,
"docstring_tokens"... |
f697638db76b9fc35cd762f0cbbb058c9ee6f5b1 | sed-i/python-libjuju | juju/client/_client2.py | [
"Apache-2.0"
] | Python | AddMachines | <not_specific> | async def AddMachines(self, params=None):
'''
AddMachines adds new machines with the supplied parameters.
params : typing.Sequence[~AddMachineParams]
Returns -> AddMachinesResults
'''
if params is not None and not isinstance(params, (bytes, str, list)):
raise... |
AddMachines adds new machines with the supplied parameters.
params : typing.Sequence[~AddMachineParams]
Returns -> AddMachinesResults
| AddMachines adds new machines with the supplied parameters. | [
"AddMachines",
"adds",
"new",
"machines",
"with",
"the",
"supplied",
"parameters",
"."
] | async def AddMachines(self, params=None):
if params is not None and not isinstance(params, (bytes, str, list)):
raise Exception("Expected params to be a Sequence, received: {}".format(type(params)))
_params = dict()
msg = dict(type='Client',
request='AddMachines',
... | [
"async",
"def",
"AddMachines",
"(",
"self",
",",
"params",
"=",
"None",
")",
":",
"if",
"params",
"is",
"not",
"None",
"and",
"not",
"isinstance",
"(",
"params",
",",
"(",
"bytes",
",",
"str",
",",
"list",
")",
")",
":",
"raise",
"Exception",
"(",
... | AddMachines adds new machines with the supplied parameters. | [
"AddMachines",
"adds",
"new",
"machines",
"with",
"the",
"supplied",
"parameters",
"."
] | [
"'''\n AddMachines adds new machines with the supplied parameters.\n\n params : typing.Sequence[~AddMachineParams]\n Returns -> AddMachinesResults\n '''",
"# map input types to rpc msg"
] | [
{
"param": "self",
"type": null
},
{
"param": "params",
"type": null
}
] | {
"returns": [],
"raises": [],
"params": [
{
"identifier": "self",
"type": null,
"docstring": null,
"docstring_tokens": [],
"default": null,
"is_optional": null
},
{
"identifier": "params",
"type": null,
"docstring": null,
"docstring_tokens":... |
f697638db76b9fc35cd762f0cbbb058c9ee6f5b1 | sed-i/python-libjuju | juju/client/_client2.py | [
"Apache-2.0"
] | Python | AddMachinesV2 | <not_specific> | async def AddMachinesV2(self, params=None):
'''
AddMachinesV2 adds new machines with the supplied parameters.
params : typing.Sequence[~AddMachineParams]
Returns -> AddMachinesResults
'''
if params is not None and not isinstance(params, (bytes, str, list)):
r... |
AddMachinesV2 adds new machines with the supplied parameters.
params : typing.Sequence[~AddMachineParams]
Returns -> AddMachinesResults
| AddMachinesV2 adds new machines with the supplied parameters. | [
"AddMachinesV2",
"adds",
"new",
"machines",
"with",
"the",
"supplied",
"parameters",
"."
] | async def AddMachinesV2(self, params=None):
if params is not None and not isinstance(params, (bytes, str, list)):
raise Exception("Expected params to be a Sequence, received: {}".format(type(params)))
_params = dict()
msg = dict(type='Client',
request='AddMachinesV... | [
"async",
"def",
"AddMachinesV2",
"(",
"self",
",",
"params",
"=",
"None",
")",
":",
"if",
"params",
"is",
"not",
"None",
"and",
"not",
"isinstance",
"(",
"params",
",",
"(",
"bytes",
",",
"str",
",",
"list",
")",
")",
":",
"raise",
"Exception",
"(",
... | AddMachinesV2 adds new machines with the supplied parameters. | [
"AddMachinesV2",
"adds",
"new",
"machines",
"with",
"the",
"supplied",
"parameters",
"."
] | [
"'''\n AddMachinesV2 adds new machines with the supplied parameters.\n\n params : typing.Sequence[~AddMachineParams]\n Returns -> AddMachinesResults\n '''",
"# map input types to rpc msg"
] | [
{
"param": "self",
"type": null
},
{
"param": "params",
"type": null
}
] | {
"returns": [],
"raises": [],
"params": [
{
"identifier": "self",
"type": null,
"docstring": null,
"docstring_tokens": [],
"default": null,
"is_optional": null
},
{
"identifier": "params",
"type": null,
"docstring": null,
"docstring_tokens":... |
f697638db76b9fc35cd762f0cbbb058c9ee6f5b1 | sed-i/python-libjuju | juju/client/_client2.py | [
"Apache-2.0"
] | Python | AgentVersion | <not_specific> | async def AgentVersion(self):
'''
AgentVersion returns the current version that the API server is running.
Returns -> AgentVersionResult
'''
# map input types to rpc msg
_params = dict()
msg = dict(type='Client',
request='AgentVersion',
... |
AgentVersion returns the current version that the API server is running.
Returns -> AgentVersionResult
| AgentVersion returns the current version that the API server is running. | [
"AgentVersion",
"returns",
"the",
"current",
"version",
"that",
"the",
"API",
"server",
"is",
"running",
"."
] | async def AgentVersion(self):
_params = dict()
msg = dict(type='Client',
request='AgentVersion',
version=2,
params=_params)
reply = await self.rpc(msg)
return reply | [
"async",
"def",
"AgentVersion",
"(",
"self",
")",
":",
"_params",
"=",
"dict",
"(",
")",
"msg",
"=",
"dict",
"(",
"type",
"=",
"'Client'",
",",
"request",
"=",
"'AgentVersion'",
",",
"version",
"=",
"2",
",",
"params",
"=",
"_params",
")",
"reply",
"... | AgentVersion returns the current version that the API server is running. | [
"AgentVersion",
"returns",
"the",
"current",
"version",
"that",
"the",
"API",
"server",
"is",
"running",
"."
] | [
"'''\n AgentVersion returns the current version that the API server is running.\n\n\n Returns -> AgentVersionResult\n '''",
"# map input types to rpc msg"
] | [
{
"param": "self",
"type": null
}
] | {
"returns": [],
"raises": [],
"params": [
{
"identifier": "self",
"type": null,
"docstring": null,
"docstring_tokens": [],
"default": null,
"is_optional": null
}
],
"outlier_params": [],
"others": []
} |
f697638db76b9fc35cd762f0cbbb058c9ee6f5b1 | sed-i/python-libjuju | juju/client/_client2.py | [
"Apache-2.0"
] | Python | CACert | <not_specific> | async def CACert(self):
'''
CACert returns the certificate used to validate the state connection.
Returns -> BytesResult
'''
# map input types to rpc msg
_params = dict()
msg = dict(type='Client',
request='CACert',
version=... |
CACert returns the certificate used to validate the state connection.
Returns -> BytesResult
| CACert returns the certificate used to validate the state connection. | [
"CACert",
"returns",
"the",
"certificate",
"used",
"to",
"validate",
"the",
"state",
"connection",
"."
] | async def CACert(self):
_params = dict()
msg = dict(type='Client',
request='CACert',
version=2,
params=_params)
reply = await self.rpc(msg)
return reply | [
"async",
"def",
"CACert",
"(",
"self",
")",
":",
"_params",
"=",
"dict",
"(",
")",
"msg",
"=",
"dict",
"(",
"type",
"=",
"'Client'",
",",
"request",
"=",
"'CACert'",
",",
"version",
"=",
"2",
",",
"params",
"=",
"_params",
")",
"reply",
"=",
"await... | CACert returns the certificate used to validate the state connection. | [
"CACert",
"returns",
"the",
"certificate",
"used",
"to",
"validate",
"the",
"state",
"connection",
"."
] | [
"'''\n CACert returns the certificate used to validate the state connection.\n\n\n Returns -> BytesResult\n '''",
"# map input types to rpc msg"
] | [
{
"param": "self",
"type": null
}
] | {
"returns": [],
"raises": [],
"params": [
{
"identifier": "self",
"type": null,
"docstring": null,
"docstring_tokens": [],
"default": null,
"is_optional": null
}
],
"outlier_params": [],
"others": []
} |
f697638db76b9fc35cd762f0cbbb058c9ee6f5b1 | sed-i/python-libjuju | juju/client/_client2.py | [
"Apache-2.0"
] | Python | FindTools | <not_specific> | async def FindTools(self, agentstream=None, arch=None, major=None, minor=None, number=None, series=None):
'''
FindTools returns a List containing all tools matching the given parameters.
agentstream : str
arch : str
major : int
minor : int
number : Number
... |
FindTools returns a List containing all tools matching the given parameters.
agentstream : str
arch : str
major : int
minor : int
number : Number
series : str
Returns -> FindToolsResult
| FindTools returns a List containing all tools matching the given parameters. | [
"FindTools",
"returns",
"a",
"List",
"containing",
"all",
"tools",
"matching",
"the",
"given",
"parameters",
"."
] | async def FindTools(self, agentstream=None, arch=None, major=None, minor=None, number=None, series=None):
if agentstream is not None and not isinstance(agentstream, (bytes, str)):
raise Exception("Expected agentstream to be a str, received: {}".format(type(agentstream)))
if arch is not None ... | [
"async",
"def",
"FindTools",
"(",
"self",
",",
"agentstream",
"=",
"None",
",",
"arch",
"=",
"None",
",",
"major",
"=",
"None",
",",
"minor",
"=",
"None",
",",
"number",
"=",
"None",
",",
"series",
"=",
"None",
")",
":",
"if",
"agentstream",
"is",
... | FindTools returns a List containing all tools matching the given parameters. | [
"FindTools",
"returns",
"a",
"List",
"containing",
"all",
"tools",
"matching",
"the",
"given",
"parameters",
"."
] | [
"'''\n FindTools returns a List containing all tools matching the given parameters.\n\n agentstream : str\n arch : str\n major : int\n minor : int\n number : Number\n series : str\n Returns -> FindToolsResult\n '''",
"# map input types to rpc msg"
] | [
{
"param": "self",
"type": null
},
{
"param": "agentstream",
"type": null
},
{
"param": "arch",
"type": null
},
{
"param": "major",
"type": null
},
{
"param": "minor",
"type": null
},
{
"param": "number",
"type": null
},
{
"param": "series"... | {
"returns": [],
"raises": [],
"params": [
{
"identifier": "self",
"type": null,
"docstring": null,
"docstring_tokens": [],
"default": null,
"is_optional": null
},
{
"identifier": "agentstream",
"type": null,
"docstring": null,
"docstring_tok... |
f697638db76b9fc35cd762f0cbbb058c9ee6f5b1 | sed-i/python-libjuju | juju/client/_client2.py | [
"Apache-2.0"
] | Python | FullStatus | <not_specific> | async def FullStatus(self, patterns=None):
'''
FullStatus gives the information needed for juju status over the api
patterns : typing.Sequence[str]
Returns -> FullStatus
'''
if patterns is not None and not isinstance(patterns, (bytes, str, list)):
raise Excep... |
FullStatus gives the information needed for juju status over the api
patterns : typing.Sequence[str]
Returns -> FullStatus
| FullStatus gives the information needed for juju status over the api
patterns : typing.Sequence[str]
Returns -> FullStatus | [
"FullStatus",
"gives",
"the",
"information",
"needed",
"for",
"juju",
"status",
"over",
"the",
"api",
"patterns",
":",
"typing",
".",
"Sequence",
"[",
"str",
"]",
"Returns",
"-",
">",
"FullStatus"
] | async def FullStatus(self, patterns=None):
if patterns is not None and not isinstance(patterns, (bytes, str, list)):
raise Exception("Expected patterns to be a Sequence, received: {}".format(type(patterns)))
_params = dict()
msg = dict(type='Client',
request='FullS... | [
"async",
"def",
"FullStatus",
"(",
"self",
",",
"patterns",
"=",
"None",
")",
":",
"if",
"patterns",
"is",
"not",
"None",
"and",
"not",
"isinstance",
"(",
"patterns",
",",
"(",
"bytes",
",",
"str",
",",
"list",
")",
")",
":",
"raise",
"Exception",
"(... | FullStatus gives the information needed for juju status over the api
patterns : typing.Sequence[str]
Returns -> FullStatus | [
"FullStatus",
"gives",
"the",
"information",
"needed",
"for",
"juju",
"status",
"over",
"the",
"api",
"patterns",
":",
"typing",
".",
"Sequence",
"[",
"str",
"]",
"Returns",
"-",
">",
"FullStatus"
] | [
"'''\n FullStatus gives the information needed for juju status over the api\n\n patterns : typing.Sequence[str]\n Returns -> FullStatus\n '''",
"# map input types to rpc msg"
] | [
{
"param": "self",
"type": null
},
{
"param": "patterns",
"type": null
}
] | {
"returns": [],
"raises": [],
"params": [
{
"identifier": "self",
"type": null,
"docstring": null,
"docstring_tokens": [],
"default": null,
"is_optional": null
},
{
"identifier": "patterns",
"type": null,
"docstring": null,
"docstring_tokens... |
f697638db76b9fc35cd762f0cbbb058c9ee6f5b1 | sed-i/python-libjuju | juju/client/_client2.py | [
"Apache-2.0"
] | Python | GetBundleChanges | <not_specific> | async def GetBundleChanges(self, bundleurl=None, yaml=None):
'''
GetBundleChanges returns the list of changes required to deploy the given
bundle data. The changes are sorted by requirements, so that they can be
applied in order.
This call is deprecated, clients should use the Ge... |
GetBundleChanges returns the list of changes required to deploy the given
bundle data. The changes are sorted by requirements, so that they can be
applied in order.
This call is deprecated, clients should use the GetChanges endpoint on the
Bundle facade.
Note: any new fe... | GetBundleChanges returns the list of changes required to deploy the given
bundle data. The changes are sorted by requirements, so that they can be
applied in order.
This call is deprecated, clients should use the GetChanges endpoint on the
Bundle facade.
Note: any new feature in the future like devices will never be su... | [
"GetBundleChanges",
"returns",
"the",
"list",
"of",
"changes",
"required",
"to",
"deploy",
"the",
"given",
"bundle",
"data",
".",
"The",
"changes",
"are",
"sorted",
"by",
"requirements",
"so",
"that",
"they",
"can",
"be",
"applied",
"in",
"order",
".",
"This... | async def GetBundleChanges(self, bundleurl=None, yaml=None):
if bundleurl is not None and not isinstance(bundleurl, (bytes, str)):
raise Exception("Expected bundleurl to be a str, received: {}".format(type(bundleurl)))
if yaml is not None and not isinstance(yaml, (bytes, str)):
r... | [
"async",
"def",
"GetBundleChanges",
"(",
"self",
",",
"bundleurl",
"=",
"None",
",",
"yaml",
"=",
"None",
")",
":",
"if",
"bundleurl",
"is",
"not",
"None",
"and",
"not",
"isinstance",
"(",
"bundleurl",
",",
"(",
"bytes",
",",
"str",
")",
")",
":",
"r... | GetBundleChanges returns the list of changes required to deploy the given
bundle data. | [
"GetBundleChanges",
"returns",
"the",
"list",
"of",
"changes",
"required",
"to",
"deploy",
"the",
"given",
"bundle",
"data",
"."
] | [
"'''\n GetBundleChanges returns the list of changes required to deploy the given\n bundle data. The changes are sorted by requirements, so that they can be\n applied in order.\n This call is deprecated, clients should use the GetChanges endpoint on the\n Bundle facade.\n No... | [
{
"param": "self",
"type": null
},
{
"param": "bundleurl",
"type": null
},
{
"param": "yaml",
"type": null
}
] | {
"returns": [],
"raises": [],
"params": [
{
"identifier": "self",
"type": null,
"docstring": null,
"docstring_tokens": [],
"default": null,
"is_optional": null
},
{
"identifier": "bundleurl",
"type": null,
"docstring": null,
"docstring_token... |
f697638db76b9fc35cd762f0cbbb058c9ee6f5b1 | sed-i/python-libjuju | juju/client/_client2.py | [
"Apache-2.0"
] | Python | GetModelConstraints | <not_specific> | async def GetModelConstraints(self):
'''
GetModelConstraints returns the constraints for the model.
Returns -> GetConstraintsResults
'''
# map input types to rpc msg
_params = dict()
msg = dict(type='Client',
request='GetModelConstraints',
... |
GetModelConstraints returns the constraints for the model.
Returns -> GetConstraintsResults
| GetModelConstraints returns the constraints for the model. | [
"GetModelConstraints",
"returns",
"the",
"constraints",
"for",
"the",
"model",
"."
] | async def GetModelConstraints(self):
_params = dict()
msg = dict(type='Client',
request='GetModelConstraints',
version=2,
params=_params)
reply = await self.rpc(msg)
return reply | [
"async",
"def",
"GetModelConstraints",
"(",
"self",
")",
":",
"_params",
"=",
"dict",
"(",
")",
"msg",
"=",
"dict",
"(",
"type",
"=",
"'Client'",
",",
"request",
"=",
"'GetModelConstraints'",
",",
"version",
"=",
"2",
",",
"params",
"=",
"_params",
")",
... | GetModelConstraints returns the constraints for the model. | [
"GetModelConstraints",
"returns",
"the",
"constraints",
"for",
"the",
"model",
"."
] | [
"'''\n GetModelConstraints returns the constraints for the model.\n\n\n Returns -> GetConstraintsResults\n '''",
"# map input types to rpc msg"
] | [
{
"param": "self",
"type": null
}
] | {
"returns": [],
"raises": [],
"params": [
{
"identifier": "self",
"type": null,
"docstring": null,
"docstring_tokens": [],
"default": null,
"is_optional": null
}
],
"outlier_params": [],
"others": []
} |
f697638db76b9fc35cd762f0cbbb058c9ee6f5b1 | sed-i/python-libjuju | juju/client/_client2.py | [
"Apache-2.0"
] | Python | InjectMachines | <not_specific> | async def InjectMachines(self, params=None):
'''
InjectMachines injects a machine into state with provisioned status.
params : typing.Sequence[~AddMachineParams]
Returns -> AddMachinesResults
'''
if params is not None and not isinstance(params, (bytes, str, list)):
... |
InjectMachines injects a machine into state with provisioned status.
params : typing.Sequence[~AddMachineParams]
Returns -> AddMachinesResults
| InjectMachines injects a machine into state with provisioned status. | [
"InjectMachines",
"injects",
"a",
"machine",
"into",
"state",
"with",
"provisioned",
"status",
"."
] | async def InjectMachines(self, params=None):
if params is not None and not isinstance(params, (bytes, str, list)):
raise Exception("Expected params to be a Sequence, received: {}".format(type(params)))
_params = dict()
msg = dict(type='Client',
request='InjectMachi... | [
"async",
"def",
"InjectMachines",
"(",
"self",
",",
"params",
"=",
"None",
")",
":",
"if",
"params",
"is",
"not",
"None",
"and",
"not",
"isinstance",
"(",
"params",
",",
"(",
"bytes",
",",
"str",
",",
"list",
")",
")",
":",
"raise",
"Exception",
"(",... | InjectMachines injects a machine into state with provisioned status. | [
"InjectMachines",
"injects",
"a",
"machine",
"into",
"state",
"with",
"provisioned",
"status",
"."
] | [
"'''\n InjectMachines injects a machine into state with provisioned status.\n\n params : typing.Sequence[~AddMachineParams]\n Returns -> AddMachinesResults\n '''",
"# map input types to rpc msg"
] | [
{
"param": "self",
"type": null
},
{
"param": "params",
"type": null
}
] | {
"returns": [],
"raises": [],
"params": [
{
"identifier": "self",
"type": null,
"docstring": null,
"docstring_tokens": [],
"default": null,
"is_optional": null
},
{
"identifier": "params",
"type": null,
"docstring": null,
"docstring_tokens":... |
f697638db76b9fc35cd762f0cbbb058c9ee6f5b1 | sed-i/python-libjuju | juju/client/_client2.py | [
"Apache-2.0"
] | Python | ModelGet | <not_specific> | async def ModelGet(self):
'''
ModelGet implements the server-side part of the
model-config CLI command.
Returns -> ModelConfigResults
'''
# map input types to rpc msg
_params = dict()
msg = dict(type='Client',
request='ModelGet',
... |
ModelGet implements the server-side part of the
model-config CLI command.
Returns -> ModelConfigResults
| ModelGet implements the server-side part of the
model-config CLI command.
| [
"ModelGet",
"implements",
"the",
"server",
"-",
"side",
"part",
"of",
"the",
"model",
"-",
"config",
"CLI",
"command",
"."
] | async def ModelGet(self):
_params = dict()
msg = dict(type='Client',
request='ModelGet',
version=2,
params=_params)
reply = await self.rpc(msg)
return reply | [
"async",
"def",
"ModelGet",
"(",
"self",
")",
":",
"_params",
"=",
"dict",
"(",
")",
"msg",
"=",
"dict",
"(",
"type",
"=",
"'Client'",
",",
"request",
"=",
"'ModelGet'",
",",
"version",
"=",
"2",
",",
"params",
"=",
"_params",
")",
"reply",
"=",
"a... | ModelGet implements the server-side part of the
model-config CLI command. | [
"ModelGet",
"implements",
"the",
"server",
"-",
"side",
"part",
"of",
"the",
"model",
"-",
"config",
"CLI",
"command",
"."
] | [
"'''\n ModelGet implements the server-side part of the\n model-config CLI command.\n\n\n Returns -> ModelConfigResults\n '''",
"# map input types to rpc msg"
] | [
{
"param": "self",
"type": null
}
] | {
"returns": [],
"raises": [],
"params": [
{
"identifier": "self",
"type": null,
"docstring": null,
"docstring_tokens": [],
"default": null,
"is_optional": null
}
],
"outlier_params": [],
"others": []
} |
f697638db76b9fc35cd762f0cbbb058c9ee6f5b1 | sed-i/python-libjuju | juju/client/_client2.py | [
"Apache-2.0"
] | Python | ModelInfo | <not_specific> | async def ModelInfo(self):
'''
ModelInfo returns information about the current model.
Returns -> ModelInfo
'''
# map input types to rpc msg
_params = dict()
msg = dict(type='Client',
request='ModelInfo',
version=2,
... |
ModelInfo returns information about the current model.
Returns -> ModelInfo
| ModelInfo returns information about the current model. | [
"ModelInfo",
"returns",
"information",
"about",
"the",
"current",
"model",
"."
] | async def ModelInfo(self):
_params = dict()
msg = dict(type='Client',
request='ModelInfo',
version=2,
params=_params)
reply = await self.rpc(msg)
return reply | [
"async",
"def",
"ModelInfo",
"(",
"self",
")",
":",
"_params",
"=",
"dict",
"(",
")",
"msg",
"=",
"dict",
"(",
"type",
"=",
"'Client'",
",",
"request",
"=",
"'ModelInfo'",
",",
"version",
"=",
"2",
",",
"params",
"=",
"_params",
")",
"reply",
"=",
... | ModelInfo returns information about the current model. | [
"ModelInfo",
"returns",
"information",
"about",
"the",
"current",
"model",
"."
] | [
"'''\n ModelInfo returns information about the current model.\n\n\n Returns -> ModelInfo\n '''",
"# map input types to rpc msg"
] | [
{
"param": "self",
"type": null
}
] | {
"returns": [],
"raises": [],
"params": [
{
"identifier": "self",
"type": null,
"docstring": null,
"docstring_tokens": [],
"default": null,
"is_optional": null
}
],
"outlier_params": [],
"others": []
} |
f697638db76b9fc35cd762f0cbbb058c9ee6f5b1 | sed-i/python-libjuju | juju/client/_client2.py | [
"Apache-2.0"
] | Python | ModelSet | <not_specific> | async def ModelSet(self, config=None):
'''
ModelSet implements the server-side part of the
set-model-config CLI command.
config : typing.Mapping[str, typing.Any]
Returns -> None
'''
if config is not None and not isinstance(config, dict):
raise Excepti... |
ModelSet implements the server-side part of the
set-model-config CLI command.
config : typing.Mapping[str, typing.Any]
Returns -> None
| ModelSet implements the server-side part of the
set-model-config CLI command.
| [
"ModelSet",
"implements",
"the",
"server",
"-",
"side",
"part",
"of",
"the",
"set",
"-",
"model",
"-",
"config",
"CLI",
"command",
"."
] | async def ModelSet(self, config=None):
if config is not None and not isinstance(config, dict):
raise Exception("Expected config to be a Mapping, received: {}".format(type(config)))
_params = dict()
msg = dict(type='Client',
request='ModelSet',
ve... | [
"async",
"def",
"ModelSet",
"(",
"self",
",",
"config",
"=",
"None",
")",
":",
"if",
"config",
"is",
"not",
"None",
"and",
"not",
"isinstance",
"(",
"config",
",",
"dict",
")",
":",
"raise",
"Exception",
"(",
"\"Expected config to be a Mapping, received: {}\""... | ModelSet implements the server-side part of the
set-model-config CLI command. | [
"ModelSet",
"implements",
"the",
"server",
"-",
"side",
"part",
"of",
"the",
"set",
"-",
"model",
"-",
"config",
"CLI",
"command",
"."
] | [
"'''\n ModelSet implements the server-side part of the\n set-model-config CLI command.\n\n config : typing.Mapping[str, typing.Any]\n Returns -> None\n '''",
"# map input types to rpc msg"
] | [
{
"param": "self",
"type": null
},
{
"param": "config",
"type": null
}
] | {
"returns": [],
"raises": [],
"params": [
{
"identifier": "self",
"type": null,
"docstring": null,
"docstring_tokens": [],
"default": null,
"is_optional": null
},
{
"identifier": "config",
"type": null,
"docstring": null,
"docstring_tokens":... |
f697638db76b9fc35cd762f0cbbb058c9ee6f5b1 | sed-i/python-libjuju | juju/client/_client2.py | [
"Apache-2.0"
] | Python | ModelUserInfo | <not_specific> | async def ModelUserInfo(self):
'''
ModelUserInfo returns information on all users in the model.
Returns -> ModelUserInfoResults
'''
# map input types to rpc msg
_params = dict()
msg = dict(type='Client',
request='ModelUserInfo',
... |
ModelUserInfo returns information on all users in the model.
Returns -> ModelUserInfoResults
| ModelUserInfo returns information on all users in the model. | [
"ModelUserInfo",
"returns",
"information",
"on",
"all",
"users",
"in",
"the",
"model",
"."
] | async def ModelUserInfo(self):
_params = dict()
msg = dict(type='Client',
request='ModelUserInfo',
version=2,
params=_params)
reply = await self.rpc(msg)
return reply | [
"async",
"def",
"ModelUserInfo",
"(",
"self",
")",
":",
"_params",
"=",
"dict",
"(",
")",
"msg",
"=",
"dict",
"(",
"type",
"=",
"'Client'",
",",
"request",
"=",
"'ModelUserInfo'",
",",
"version",
"=",
"2",
",",
"params",
"=",
"_params",
")",
"reply",
... | ModelUserInfo returns information on all users in the model. | [
"ModelUserInfo",
"returns",
"information",
"on",
"all",
"users",
"in",
"the",
"model",
"."
] | [
"'''\n ModelUserInfo returns information on all users in the model.\n\n\n Returns -> ModelUserInfoResults\n '''",
"# map input types to rpc msg"
] | [
{
"param": "self",
"type": null
}
] | {
"returns": [],
"raises": [],
"params": [
{
"identifier": "self",
"type": null,
"docstring": null,
"docstring_tokens": [],
"default": null,
"is_optional": null
}
],
"outlier_params": [],
"others": []
} |
f697638db76b9fc35cd762f0cbbb058c9ee6f5b1 | sed-i/python-libjuju | juju/client/_client2.py | [
"Apache-2.0"
] | Python | PrivateAddress | <not_specific> | async def PrivateAddress(self, target=None):
'''
PrivateAddress implements the server side of Client.PrivateAddress.
target : str
Returns -> PrivateAddressResults
'''
if target is not None and not isinstance(target, (bytes, str)):
raise Exception("Expected ta... |
PrivateAddress implements the server side of Client.PrivateAddress.
target : str
Returns -> PrivateAddressResults
| PrivateAddress implements the server side of Client.PrivateAddress.
target : str
Returns -> PrivateAddressResults | [
"PrivateAddress",
"implements",
"the",
"server",
"side",
"of",
"Client",
".",
"PrivateAddress",
".",
"target",
":",
"str",
"Returns",
"-",
">",
"PrivateAddressResults"
] | async def PrivateAddress(self, target=None):
if target is not None and not isinstance(target, (bytes, str)):
raise Exception("Expected target to be a str, received: {}".format(type(target)))
_params = dict()
msg = dict(type='Client',
request='PrivateAddress',
... | [
"async",
"def",
"PrivateAddress",
"(",
"self",
",",
"target",
"=",
"None",
")",
":",
"if",
"target",
"is",
"not",
"None",
"and",
"not",
"isinstance",
"(",
"target",
",",
"(",
"bytes",
",",
"str",
")",
")",
":",
"raise",
"Exception",
"(",
"\"Expected ta... | PrivateAddress implements the server side of Client.PrivateAddress. | [
"PrivateAddress",
"implements",
"the",
"server",
"side",
"of",
"Client",
".",
"PrivateAddress",
"."
] | [
"'''\n PrivateAddress implements the server side of Client.PrivateAddress.\n\n target : str\n Returns -> PrivateAddressResults\n '''",
"# map input types to rpc msg"
] | [
{
"param": "self",
"type": null
},
{
"param": "target",
"type": null
}
] | {
"returns": [],
"raises": [],
"params": [
{
"identifier": "self",
"type": null,
"docstring": null,
"docstring_tokens": [],
"default": null,
"is_optional": null
},
{
"identifier": "target",
"type": null,
"docstring": null,
"docstring_tokens":... |
f697638db76b9fc35cd762f0cbbb058c9ee6f5b1 | sed-i/python-libjuju | juju/client/_client2.py | [
"Apache-2.0"
] | Python | ProvisioningScript | <not_specific> | async def ProvisioningScript(self, data_dir=None, disable_package_commands=None, machine_id=None, nonce=None):
'''
ProvisioningScript returns a shell script that, when run,
provisions a machine agent on the machine executing the script.
data_dir : str
disable_package_commands : ... |
ProvisioningScript returns a shell script that, when run,
provisions a machine agent on the machine executing the script.
data_dir : str
disable_package_commands : bool
machine_id : str
nonce : str
Returns -> ProvisioningScriptResult
| ProvisioningScript returns a shell script that, when run,
provisions a machine agent on the machine executing the script.
| [
"ProvisioningScript",
"returns",
"a",
"shell",
"script",
"that",
"when",
"run",
"provisions",
"a",
"machine",
"agent",
"on",
"the",
"machine",
"executing",
"the",
"script",
"."
] | async def ProvisioningScript(self, data_dir=None, disable_package_commands=None, machine_id=None, nonce=None):
if data_dir is not None and not isinstance(data_dir, (bytes, str)):
raise Exception("Expected data_dir to be a str, received: {}".format(type(data_dir)))
if disable_package_commands... | [
"async",
"def",
"ProvisioningScript",
"(",
"self",
",",
"data_dir",
"=",
"None",
",",
"disable_package_commands",
"=",
"None",
",",
"machine_id",
"=",
"None",
",",
"nonce",
"=",
"None",
")",
":",
"if",
"data_dir",
"is",
"not",
"None",
"and",
"not",
"isinst... | ProvisioningScript returns a shell script that, when run,
provisions a machine agent on the machine executing the script. | [
"ProvisioningScript",
"returns",
"a",
"shell",
"script",
"that",
"when",
"run",
"provisions",
"a",
"machine",
"agent",
"on",
"the",
"machine",
"executing",
"the",
"script",
"."
] | [
"'''\n ProvisioningScript returns a shell script that, when run,\n provisions a machine agent on the machine executing the script.\n\n data_dir : str\n disable_package_commands : bool\n machine_id : str\n nonce : str\n Returns -> ProvisioningScriptResult\n '''... | [
{
"param": "self",
"type": null
},
{
"param": "data_dir",
"type": null
},
{
"param": "disable_package_commands",
"type": null
},
{
"param": "machine_id",
"type": null
},
{
"param": "nonce",
"type": null
}
] | {
"returns": [],
"raises": [],
"params": [
{
"identifier": "self",
"type": null,
"docstring": null,
"docstring_tokens": [],
"default": null,
"is_optional": null
},
{
"identifier": "data_dir",
"type": null,
"docstring": null,
"docstring_tokens... |
f697638db76b9fc35cd762f0cbbb058c9ee6f5b1 | sed-i/python-libjuju | juju/client/_client2.py | [
"Apache-2.0"
] | Python | PublicAddress | <not_specific> | async def PublicAddress(self, target=None):
'''
PublicAddress implements the server side of Client.PublicAddress.
target : str
Returns -> PublicAddressResults
'''
if target is not None and not isinstance(target, (bytes, str)):
raise Exception("Expected target... |
PublicAddress implements the server side of Client.PublicAddress.
target : str
Returns -> PublicAddressResults
| PublicAddress implements the server side of Client.PublicAddress.
target : str
Returns -> PublicAddressResults | [
"PublicAddress",
"implements",
"the",
"server",
"side",
"of",
"Client",
".",
"PublicAddress",
".",
"target",
":",
"str",
"Returns",
"-",
">",
"PublicAddressResults"
] | async def PublicAddress(self, target=None):
if target is not None and not isinstance(target, (bytes, str)):
raise Exception("Expected target to be a str, received: {}".format(type(target)))
_params = dict()
msg = dict(type='Client',
request='PublicAddress',
... | [
"async",
"def",
"PublicAddress",
"(",
"self",
",",
"target",
"=",
"None",
")",
":",
"if",
"target",
"is",
"not",
"None",
"and",
"not",
"isinstance",
"(",
"target",
",",
"(",
"bytes",
",",
"str",
")",
")",
":",
"raise",
"Exception",
"(",
"\"Expected tar... | PublicAddress implements the server side of Client.PublicAddress. | [
"PublicAddress",
"implements",
"the",
"server",
"side",
"of",
"Client",
".",
"PublicAddress",
"."
] | [
"'''\n PublicAddress implements the server side of Client.PublicAddress.\n\n target : str\n Returns -> PublicAddressResults\n '''",
"# map input types to rpc msg"
] | [
{
"param": "self",
"type": null
},
{
"param": "target",
"type": null
}
] | {
"returns": [],
"raises": [],
"params": [
{
"identifier": "self",
"type": null,
"docstring": null,
"docstring_tokens": [],
"default": null,
"is_optional": null
},
{
"identifier": "target",
"type": null,
"docstring": null,
"docstring_tokens":... |
f697638db76b9fc35cd762f0cbbb058c9ee6f5b1 | sed-i/python-libjuju | juju/client/_client2.py | [
"Apache-2.0"
] | Python | ResolveCharms | <not_specific> | async def ResolveCharms(self, references=None):
'''
ResolveCharm resolves the best available charm URLs with series, for charm
locations without a series specified.
NOTE: ResolveCharms is deprecated as of juju 2.9 and charms facade version 3.
Please discontinue use and move to t... |
ResolveCharm resolves the best available charm URLs with series, for charm
locations without a series specified.
NOTE: ResolveCharms is deprecated as of juju 2.9 and charms facade version 3.
Please discontinue use and move to the charms facade version.
TODO: remove in juju 3.0... | ResolveCharm resolves the best available charm URLs with series, for charm
locations without a series specified.
ResolveCharms is deprecated as of juju 2.9 and charms facade version 3.
Please discontinue use and move to the charms facade version.
references : typing.Sequence[str]
Returns -> ResolveCharmResults | [
"ResolveCharm",
"resolves",
"the",
"best",
"available",
"charm",
"URLs",
"with",
"series",
"for",
"charm",
"locations",
"without",
"a",
"series",
"specified",
".",
"ResolveCharms",
"is",
"deprecated",
"as",
"of",
"juju",
"2",
".",
"9",
"and",
"charms",
"facade... | async def ResolveCharms(self, references=None):
if references is not None and not isinstance(references, (bytes, str, list)):
raise Exception("Expected references to be a Sequence, received: {}".format(type(references)))
_params = dict()
msg = dict(type='Client',
r... | [
"async",
"def",
"ResolveCharms",
"(",
"self",
",",
"references",
"=",
"None",
")",
":",
"if",
"references",
"is",
"not",
"None",
"and",
"not",
"isinstance",
"(",
"references",
",",
"(",
"bytes",
",",
"str",
",",
"list",
")",
")",
":",
"raise",
"Excepti... | ResolveCharm resolves the best available charm URLs with series, for charm
locations without a series specified. | [
"ResolveCharm",
"resolves",
"the",
"best",
"available",
"charm",
"URLs",
"with",
"series",
"for",
"charm",
"locations",
"without",
"a",
"series",
"specified",
"."
] | [
"'''\n ResolveCharm resolves the best available charm URLs with series, for charm\n locations without a series specified.\n\n NOTE: ResolveCharms is deprecated as of juju 2.9 and charms facade version 3.\n Please discontinue use and move to the charms facade version.\n\n TODO: rem... | [
{
"param": "self",
"type": null
},
{
"param": "references",
"type": null
}
] | {
"returns": [],
"raises": [],
"params": [
{
"identifier": "self",
"type": null,
"docstring": null,
"docstring_tokens": [],
"default": null,
"is_optional": null
},
{
"identifier": "references",
"type": null,
"docstring": null,
"docstring_toke... |
f697638db76b9fc35cd762f0cbbb058c9ee6f5b1 | sed-i/python-libjuju | juju/client/_client2.py | [
"Apache-2.0"
] | Python | RetryProvisioning | <not_specific> | async def RetryProvisioning(self, entities=None):
'''
RetryProvisioning marks a provisioning error as transient on the machines.
entities : typing.Sequence[~Entity]
Returns -> ErrorResults
'''
if entities is not None and not isinstance(entities, (bytes, str, list)):
... |
RetryProvisioning marks a provisioning error as transient on the machines.
entities : typing.Sequence[~Entity]
Returns -> ErrorResults
| RetryProvisioning marks a provisioning error as transient on the machines.
entities : typing.Sequence[~Entity]
Returns -> ErrorResults | [
"RetryProvisioning",
"marks",
"a",
"provisioning",
"error",
"as",
"transient",
"on",
"the",
"machines",
".",
"entities",
":",
"typing",
".",
"Sequence",
"[",
"~Entity",
"]",
"Returns",
"-",
">",
"ErrorResults"
] | async def RetryProvisioning(self, entities=None):
if entities is not None and not isinstance(entities, (bytes, str, list)):
raise Exception("Expected entities to be a Sequence, received: {}".format(type(entities)))
_params = dict()
msg = dict(type='Client',
request... | [
"async",
"def",
"RetryProvisioning",
"(",
"self",
",",
"entities",
"=",
"None",
")",
":",
"if",
"entities",
"is",
"not",
"None",
"and",
"not",
"isinstance",
"(",
"entities",
",",
"(",
"bytes",
",",
"str",
",",
"list",
")",
")",
":",
"raise",
"Exception... | RetryProvisioning marks a provisioning error as transient on the machines. | [
"RetryProvisioning",
"marks",
"a",
"provisioning",
"error",
"as",
"transient",
"on",
"the",
"machines",
"."
] | [
"'''\n RetryProvisioning marks a provisioning error as transient on the machines.\n\n entities : typing.Sequence[~Entity]\n Returns -> ErrorResults\n '''",
"# map input types to rpc msg"
] | [
{
"param": "self",
"type": null
},
{
"param": "entities",
"type": null
}
] | {
"returns": [],
"raises": [],
"params": [
{
"identifier": "self",
"type": null,
"docstring": null,
"docstring_tokens": [],
"default": null,
"is_optional": null
},
{
"identifier": "entities",
"type": null,
"docstring": null,
"docstring_tokens... |
f697638db76b9fc35cd762f0cbbb058c9ee6f5b1 | sed-i/python-libjuju | juju/client/_client2.py | [
"Apache-2.0"
] | Python | SLALevel | <not_specific> | async def SLALevel(self):
'''
SLALevel returns the current sla level for the model.
Returns -> StringResult
'''
# map input types to rpc msg
_params = dict()
msg = dict(type='Client',
request='SLALevel',
version=2,
... |
SLALevel returns the current sla level for the model.
Returns -> StringResult
| SLALevel returns the current sla level for the model. | [
"SLALevel",
"returns",
"the",
"current",
"sla",
"level",
"for",
"the",
"model",
"."
] | async def SLALevel(self):
_params = dict()
msg = dict(type='Client',
request='SLALevel',
version=2,
params=_params)
reply = await self.rpc(msg)
return reply | [
"async",
"def",
"SLALevel",
"(",
"self",
")",
":",
"_params",
"=",
"dict",
"(",
")",
"msg",
"=",
"dict",
"(",
"type",
"=",
"'Client'",
",",
"request",
"=",
"'SLALevel'",
",",
"version",
"=",
"2",
",",
"params",
"=",
"_params",
")",
"reply",
"=",
"a... | SLALevel returns the current sla level for the model. | [
"SLALevel",
"returns",
"the",
"current",
"sla",
"level",
"for",
"the",
"model",
"."
] | [
"'''\n SLALevel returns the current sla level for the model.\n\n\n Returns -> StringResult\n '''",
"# map input types to rpc msg"
] | [
{
"param": "self",
"type": null
}
] | {
"returns": [],
"raises": [],
"params": [
{
"identifier": "self",
"type": null,
"docstring": null,
"docstring_tokens": [],
"default": null,
"is_optional": null
}
],
"outlier_params": [],
"others": []
} |
f697638db76b9fc35cd762f0cbbb058c9ee6f5b1 | sed-i/python-libjuju | juju/client/_client2.py | [
"Apache-2.0"
] | Python | SetModelAgentVersion | <not_specific> | async def SetModelAgentVersion(self, force=None, version=None):
'''
SetModelAgentVersion sets the model agent version.
force : bool
version : Number
Returns -> None
'''
if force is not None and not isinstance(force, bool):
raise Exception("Expected fo... |
SetModelAgentVersion sets the model agent version.
force : bool
version : Number
Returns -> None
| SetModelAgentVersion sets the model agent version.
force : bool
version : Number
Returns -> None | [
"SetModelAgentVersion",
"sets",
"the",
"model",
"agent",
"version",
".",
"force",
":",
"bool",
"version",
":",
"Number",
"Returns",
"-",
">",
"None"
] | async def SetModelAgentVersion(self, force=None, version=None):
if force is not None and not isinstance(force, bool):
raise Exception("Expected force to be a bool, received: {}".format(type(force)))
if version is not None and not isinstance(version, (dict, Number)):
raise Excepti... | [
"async",
"def",
"SetModelAgentVersion",
"(",
"self",
",",
"force",
"=",
"None",
",",
"version",
"=",
"None",
")",
":",
"if",
"force",
"is",
"not",
"None",
"and",
"not",
"isinstance",
"(",
"force",
",",
"bool",
")",
":",
"raise",
"Exception",
"(",
"\"Ex... | SetModelAgentVersion sets the model agent version. | [
"SetModelAgentVersion",
"sets",
"the",
"model",
"agent",
"version",
"."
] | [
"'''\n SetModelAgentVersion sets the model agent version.\n\n force : bool\n version : Number\n Returns -> None\n '''",
"# map input types to rpc msg"
] | [
{
"param": "self",
"type": null
},
{
"param": "force",
"type": null
},
{
"param": "version",
"type": null
}
] | {
"returns": [],
"raises": [],
"params": [
{
"identifier": "self",
"type": null,
"docstring": null,
"docstring_tokens": [],
"default": null,
"is_optional": null
},
{
"identifier": "force",
"type": null,
"docstring": null,
"docstring_tokens": ... |
f697638db76b9fc35cd762f0cbbb058c9ee6f5b1 | sed-i/python-libjuju | juju/client/_client2.py | [
"Apache-2.0"
] | Python | SetModelConstraints | <not_specific> | async def SetModelConstraints(self, application=None, constraints=None):
'''
SetModelConstraints sets the constraints for the model.
application : str
constraints : Value
Returns -> None
'''
if application is not None and not isinstance(application, (bytes, str))... |
SetModelConstraints sets the constraints for the model.
application : str
constraints : Value
Returns -> None
| SetModelConstraints sets the constraints for the model.
application : str
constraints : Value
Returns -> None | [
"SetModelConstraints",
"sets",
"the",
"constraints",
"for",
"the",
"model",
".",
"application",
":",
"str",
"constraints",
":",
"Value",
"Returns",
"-",
">",
"None"
] | async def SetModelConstraints(self, application=None, constraints=None):
if application is not None and not isinstance(application, (bytes, str)):
raise Exception("Expected application to be a str, received: {}".format(type(application)))
if constraints is not None and not isinstance(constra... | [
"async",
"def",
"SetModelConstraints",
"(",
"self",
",",
"application",
"=",
"None",
",",
"constraints",
"=",
"None",
")",
":",
"if",
"application",
"is",
"not",
"None",
"and",
"not",
"isinstance",
"(",
"application",
",",
"(",
"bytes",
",",
"str",
")",
... | SetModelConstraints sets the constraints for the model. | [
"SetModelConstraints",
"sets",
"the",
"constraints",
"for",
"the",
"model",
"."
] | [
"'''\n SetModelConstraints sets the constraints for the model.\n\n application : str\n constraints : Value\n Returns -> None\n '''",
"# map input types to rpc msg"
] | [
{
"param": "self",
"type": null
},
{
"param": "application",
"type": null
},
{
"param": "constraints",
"type": null
}
] | {
"returns": [],
"raises": [],
"params": [
{
"identifier": "self",
"type": null,
"docstring": null,
"docstring_tokens": [],
"default": null,
"is_optional": null
},
{
"identifier": "application",
"type": null,
"docstring": null,
"docstring_tok... |
f697638db76b9fc35cd762f0cbbb058c9ee6f5b1 | sed-i/python-libjuju | juju/client/_client2.py | [
"Apache-2.0"
] | Python | StatusHistory | <not_specific> | async def StatusHistory(self, requests=None):
'''
StatusHistory returns a slice of past statuses for several entities.
requests : typing.Sequence[~StatusHistoryRequest]
Returns -> StatusHistoryResults
'''
if requests is not None and not isinstance(requests, (bytes, str, ... |
StatusHistory returns a slice of past statuses for several entities.
requests : typing.Sequence[~StatusHistoryRequest]
Returns -> StatusHistoryResults
| StatusHistory returns a slice of past statuses for several entities. | [
"StatusHistory",
"returns",
"a",
"slice",
"of",
"past",
"statuses",
"for",
"several",
"entities",
"."
] | async def StatusHistory(self, requests=None):
if requests is not None and not isinstance(requests, (bytes, str, list)):
raise Exception("Expected requests to be a Sequence, received: {}".format(type(requests)))
_params = dict()
msg = dict(type='Client',
request='St... | [
"async",
"def",
"StatusHistory",
"(",
"self",
",",
"requests",
"=",
"None",
")",
":",
"if",
"requests",
"is",
"not",
"None",
"and",
"not",
"isinstance",
"(",
"requests",
",",
"(",
"bytes",
",",
"str",
",",
"list",
")",
")",
":",
"raise",
"Exception",
... | StatusHistory returns a slice of past statuses for several entities. | [
"StatusHistory",
"returns",
"a",
"slice",
"of",
"past",
"statuses",
"for",
"several",
"entities",
"."
] | [
"'''\n StatusHistory returns a slice of past statuses for several entities.\n\n requests : typing.Sequence[~StatusHistoryRequest]\n Returns -> StatusHistoryResults\n '''",
"# map input types to rpc msg"
] | [
{
"param": "self",
"type": null
},
{
"param": "requests",
"type": null
}
] | {
"returns": [],
"raises": [],
"params": [
{
"identifier": "self",
"type": null,
"docstring": null,
"docstring_tokens": [],
"default": null,
"is_optional": null
},
{
"identifier": "requests",
"type": null,
"docstring": null,
"docstring_tokens... |
f697638db76b9fc35cd762f0cbbb058c9ee6f5b1 | sed-i/python-libjuju | juju/client/_client2.py | [
"Apache-2.0"
] | Python | WatchAll | <not_specific> | async def WatchAll(self):
'''
WatchAll initiates a watcher for entities in the connected model.
Returns -> AllWatcherId
'''
# map input types to rpc msg
_params = dict()
msg = dict(type='Client',
request='WatchAll',
version... |
WatchAll initiates a watcher for entities in the connected model.
Returns -> AllWatcherId
| WatchAll initiates a watcher for entities in the connected model. | [
"WatchAll",
"initiates",
"a",
"watcher",
"for",
"entities",
"in",
"the",
"connected",
"model",
"."
] | async def WatchAll(self):
_params = dict()
msg = dict(type='Client',
request='WatchAll',
version=2,
params=_params)
reply = await self.rpc(msg)
return reply | [
"async",
"def",
"WatchAll",
"(",
"self",
")",
":",
"_params",
"=",
"dict",
"(",
")",
"msg",
"=",
"dict",
"(",
"type",
"=",
"'Client'",
",",
"request",
"=",
"'WatchAll'",
",",
"version",
"=",
"2",
",",
"params",
"=",
"_params",
")",
"reply",
"=",
"a... | WatchAll initiates a watcher for entities in the connected model. | [
"WatchAll",
"initiates",
"a",
"watcher",
"for",
"entities",
"in",
"the",
"connected",
"model",
"."
] | [
"'''\n WatchAll initiates a watcher for entities in the connected model.\n\n\n Returns -> AllWatcherId\n '''",
"# map input types to rpc msg"
] | [
{
"param": "self",
"type": null
}
] | {
"returns": [],
"raises": [],
"params": [
{
"identifier": "self",
"type": null,
"docstring": null,
"docstring_tokens": [],
"default": null,
"is_optional": null
}
],
"outlier_params": [],
"others": []
} |
f697638db76b9fc35cd762f0cbbb058c9ee6f5b1 | sed-i/python-libjuju | juju/client/_client2.py | [
"Apache-2.0"
] | Python | InvalidateModelCredential | <not_specific> | async def InvalidateModelCredential(self, reason=None):
'''
InvalidateModelCredential marks the cloud credential for this model as invalid.
reason : str
Returns -> ErrorResult
'''
if reason is not None and not isinstance(reason, (bytes, str)):
raise Exception... |
InvalidateModelCredential marks the cloud credential for this model as invalid.
reason : str
Returns -> ErrorResult
| InvalidateModelCredential marks the cloud credential for this model as invalid.
reason : str
Returns -> ErrorResult | [
"InvalidateModelCredential",
"marks",
"the",
"cloud",
"credential",
"for",
"this",
"model",
"as",
"invalid",
".",
"reason",
":",
"str",
"Returns",
"-",
">",
"ErrorResult"
] | async def InvalidateModelCredential(self, reason=None):
if reason is not None and not isinstance(reason, (bytes, str)):
raise Exception("Expected reason to be a str, received: {}".format(type(reason)))
_params = dict()
msg = dict(type='CredentialValidator',
request... | [
"async",
"def",
"InvalidateModelCredential",
"(",
"self",
",",
"reason",
"=",
"None",
")",
":",
"if",
"reason",
"is",
"not",
"None",
"and",
"not",
"isinstance",
"(",
"reason",
",",
"(",
"bytes",
",",
"str",
")",
")",
":",
"raise",
"Exception",
"(",
"\"... | InvalidateModelCredential marks the cloud credential for this model as invalid. | [
"InvalidateModelCredential",
"marks",
"the",
"cloud",
"credential",
"for",
"this",
"model",
"as",
"invalid",
"."
] | [
"'''\n InvalidateModelCredential marks the cloud credential for this model as invalid.\n\n reason : str\n Returns -> ErrorResult\n '''",
"# map input types to rpc msg"
] | [
{
"param": "self",
"type": null
},
{
"param": "reason",
"type": null
}
] | {
"returns": [],
"raises": [],
"params": [
{
"identifier": "self",
"type": null,
"docstring": null,
"docstring_tokens": [],
"default": null,
"is_optional": null
},
{
"identifier": "reason",
"type": null,
"docstring": null,
"docstring_tokens":... |
f697638db76b9fc35cd762f0cbbb058c9ee6f5b1 | sed-i/python-libjuju | juju/client/_client2.py | [
"Apache-2.0"
] | Python | ModelCredential | <not_specific> | async def ModelCredential(self):
'''
ModelCredential returns cloud credential information for a model.
Returns -> ModelCredential
'''
# map input types to rpc msg
_params = dict()
msg = dict(type='CredentialValidator',
request='ModelCredenti... |
ModelCredential returns cloud credential information for a model.
Returns -> ModelCredential
| ModelCredential returns cloud credential information for a model. | [
"ModelCredential",
"returns",
"cloud",
"credential",
"information",
"for",
"a",
"model",
"."
] | async def ModelCredential(self):
_params = dict()
msg = dict(type='CredentialValidator',
request='ModelCredential',
version=2,
params=_params)
reply = await self.rpc(msg)
return reply | [
"async",
"def",
"ModelCredential",
"(",
"self",
")",
":",
"_params",
"=",
"dict",
"(",
")",
"msg",
"=",
"dict",
"(",
"type",
"=",
"'CredentialValidator'",
",",
"request",
"=",
"'ModelCredential'",
",",
"version",
"=",
"2",
",",
"params",
"=",
"_params",
... | ModelCredential returns cloud credential information for a model. | [
"ModelCredential",
"returns",
"cloud",
"credential",
"information",
"for",
"a",
"model",
"."
] | [
"'''\n ModelCredential returns cloud credential information for a model.\n\n\n Returns -> ModelCredential\n '''",
"# map input types to rpc msg"
] | [
{
"param": "self",
"type": null
}
] | {
"returns": [],
"raises": [],
"params": [
{
"identifier": "self",
"type": null,
"docstring": null,
"docstring_tokens": [],
"default": null,
"is_optional": null
}
],
"outlier_params": [],
"others": []
} |
f697638db76b9fc35cd762f0cbbb058c9ee6f5b1 | sed-i/python-libjuju | juju/client/_client2.py | [
"Apache-2.0"
] | Python | WatchCredential | <not_specific> | async def WatchCredential(self, tag=None):
'''
WatchCredential returns a NotifyWatcher that observes
changes to a given cloud credential.
tag : str
Returns -> NotifyWatchResult
'''
if tag is not None and not isinstance(tag, (bytes, str)):
raise Except... |
WatchCredential returns a NotifyWatcher that observes
changes to a given cloud credential.
tag : str
Returns -> NotifyWatchResult
| WatchCredential returns a NotifyWatcher that observes
changes to a given cloud credential.
tag : str
Returns -> NotifyWatchResult | [
"WatchCredential",
"returns",
"a",
"NotifyWatcher",
"that",
"observes",
"changes",
"to",
"a",
"given",
"cloud",
"credential",
".",
"tag",
":",
"str",
"Returns",
"-",
">",
"NotifyWatchResult"
] | async def WatchCredential(self, tag=None):
if tag is not None and not isinstance(tag, (bytes, str)):
raise Exception("Expected tag to be a str, received: {}".format(type(tag)))
_params = dict()
msg = dict(type='CredentialValidator',
request='WatchCredential',
... | [
"async",
"def",
"WatchCredential",
"(",
"self",
",",
"tag",
"=",
"None",
")",
":",
"if",
"tag",
"is",
"not",
"None",
"and",
"not",
"isinstance",
"(",
"tag",
",",
"(",
"bytes",
",",
"str",
")",
")",
":",
"raise",
"Exception",
"(",
"\"Expected tag to be ... | WatchCredential returns a NotifyWatcher that observes
changes to a given cloud credential. | [
"WatchCredential",
"returns",
"a",
"NotifyWatcher",
"that",
"observes",
"changes",
"to",
"a",
"given",
"cloud",
"credential",
"."
] | [
"'''\n WatchCredential returns a NotifyWatcher that observes\n changes to a given cloud credential.\n\n tag : str\n Returns -> NotifyWatchResult\n '''",
"# map input types to rpc msg"
] | [
{
"param": "self",
"type": null
},
{
"param": "tag",
"type": null
}
] | {
"returns": [],
"raises": [],
"params": [
{
"identifier": "self",
"type": null,
"docstring": null,
"docstring_tokens": [],
"default": null,
"is_optional": null
},
{
"identifier": "tag",
"type": null,
"docstring": null,
"docstring_tokens": []... |
f697638db76b9fc35cd762f0cbbb058c9ee6f5b1 | sed-i/python-libjuju | juju/client/_client2.py | [
"Apache-2.0"
] | Python | WatchModelCredential | <not_specific> | async def WatchModelCredential(self):
'''
WatchModelCredential returns a NotifyWatcher that watches what cloud credential a model uses.
Returns -> NotifyWatchResult
'''
# map input types to rpc msg
_params = dict()
msg = dict(type='CredentialValidator',
... |
WatchModelCredential returns a NotifyWatcher that watches what cloud credential a model uses.
Returns -> NotifyWatchResult
| WatchModelCredential returns a NotifyWatcher that watches what cloud credential a model uses. | [
"WatchModelCredential",
"returns",
"a",
"NotifyWatcher",
"that",
"watches",
"what",
"cloud",
"credential",
"a",
"model",
"uses",
"."
] | async def WatchModelCredential(self):
_params = dict()
msg = dict(type='CredentialValidator',
request='WatchModelCredential',
version=2,
params=_params)
reply = await self.rpc(msg)
return reply | [
"async",
"def",
"WatchModelCredential",
"(",
"self",
")",
":",
"_params",
"=",
"dict",
"(",
")",
"msg",
"=",
"dict",
"(",
"type",
"=",
"'CredentialValidator'",
",",
"request",
"=",
"'WatchModelCredential'",
",",
"version",
"=",
"2",
",",
"params",
"=",
"_p... | WatchModelCredential returns a NotifyWatcher that watches what cloud credential a model uses. | [
"WatchModelCredential",
"returns",
"a",
"NotifyWatcher",
"that",
"watches",
"what",
"cloud",
"credential",
"a",
"model",
"uses",
"."
] | [
"'''\n WatchModelCredential returns a NotifyWatcher that watches what cloud credential a model uses.\n\n\n Returns -> NotifyWatchResult\n '''",
"# map input types to rpc msg"
] | [
{
"param": "self",
"type": null
}
] | {
"returns": [],
"raises": [],
"params": [
{
"identifier": "self",
"type": null,
"docstring": null,
"docstring_tokens": [],
"default": null,
"is_optional": null
}
],
"outlier_params": [],
"others": []
} |
f697638db76b9fc35cd762f0cbbb058c9ee6f5b1 | sed-i/python-libjuju | juju/client/_client2.py | [
"Apache-2.0"
] | Python | PublishIngressNetworkChanges | <not_specific> | async def PublishIngressNetworkChanges(self, changes=None):
'''
PublishIngressNetworkChanges publishes changes to the required
ingress addresses to the model hosting the offer in the relation.
changes : typing.Sequence[~IngressNetworksChangeEvent]
Returns -> ErrorResults
... |
PublishIngressNetworkChanges publishes changes to the required
ingress addresses to the model hosting the offer in the relation.
changes : typing.Sequence[~IngressNetworksChangeEvent]
Returns -> ErrorResults
| PublishIngressNetworkChanges publishes changes to the required
ingress addresses to the model hosting the offer in the relation.
| [
"PublishIngressNetworkChanges",
"publishes",
"changes",
"to",
"the",
"required",
"ingress",
"addresses",
"to",
"the",
"model",
"hosting",
"the",
"offer",
"in",
"the",
"relation",
"."
] | async def PublishIngressNetworkChanges(self, changes=None):
if changes is not None and not isinstance(changes, (bytes, str, list)):
raise Exception("Expected changes to be a Sequence, received: {}".format(type(changes)))
_params = dict()
msg = dict(type='CrossModelRelations',
... | [
"async",
"def",
"PublishIngressNetworkChanges",
"(",
"self",
",",
"changes",
"=",
"None",
")",
":",
"if",
"changes",
"is",
"not",
"None",
"and",
"not",
"isinstance",
"(",
"changes",
",",
"(",
"bytes",
",",
"str",
",",
"list",
")",
")",
":",
"raise",
"E... | PublishIngressNetworkChanges publishes changes to the required
ingress addresses to the model hosting the offer in the relation. | [
"PublishIngressNetworkChanges",
"publishes",
"changes",
"to",
"the",
"required",
"ingress",
"addresses",
"to",
"the",
"model",
"hosting",
"the",
"offer",
"in",
"the",
"relation",
"."
] | [
"'''\n PublishIngressNetworkChanges publishes changes to the required\n ingress addresses to the model hosting the offer in the relation.\n\n changes : typing.Sequence[~IngressNetworksChangeEvent]\n Returns -> ErrorResults\n '''",
"# map input types to rpc msg"
] | [
{
"param": "self",
"type": null
},
{
"param": "changes",
"type": null
}
] | {
"returns": [],
"raises": [],
"params": [
{
"identifier": "self",
"type": null,
"docstring": null,
"docstring_tokens": [],
"default": null,
"is_optional": null
},
{
"identifier": "changes",
"type": null,
"docstring": null,
"docstring_tokens"... |
f697638db76b9fc35cd762f0cbbb058c9ee6f5b1 | sed-i/python-libjuju | juju/client/_client2.py | [
"Apache-2.0"
] | Python | PublishRelationChanges | <not_specific> | async def PublishRelationChanges(self, changes=None):
'''
PublishRelationChanges publishes relation changes to the
model hosting the remote application involved in the relation.
changes : typing.Sequence[~RemoteRelationChangeEvent]
Returns -> ErrorResults
'''
if ... |
PublishRelationChanges publishes relation changes to the
model hosting the remote application involved in the relation.
changes : typing.Sequence[~RemoteRelationChangeEvent]
Returns -> ErrorResults
| PublishRelationChanges publishes relation changes to the
model hosting the remote application involved in the relation.
| [
"PublishRelationChanges",
"publishes",
"relation",
"changes",
"to",
"the",
"model",
"hosting",
"the",
"remote",
"application",
"involved",
"in",
"the",
"relation",
"."
] | async def PublishRelationChanges(self, changes=None):
if changes is not None and not isinstance(changes, (bytes, str, list)):
raise Exception("Expected changes to be a Sequence, received: {}".format(type(changes)))
_params = dict()
msg = dict(type='CrossModelRelations',
... | [
"async",
"def",
"PublishRelationChanges",
"(",
"self",
",",
"changes",
"=",
"None",
")",
":",
"if",
"changes",
"is",
"not",
"None",
"and",
"not",
"isinstance",
"(",
"changes",
",",
"(",
"bytes",
",",
"str",
",",
"list",
")",
")",
":",
"raise",
"Excepti... | PublishRelationChanges publishes relation changes to the
model hosting the remote application involved in the relation. | [
"PublishRelationChanges",
"publishes",
"relation",
"changes",
"to",
"the",
"model",
"hosting",
"the",
"remote",
"application",
"involved",
"in",
"the",
"relation",
"."
] | [
"'''\n PublishRelationChanges publishes relation changes to the\n model hosting the remote application involved in the relation.\n\n changes : typing.Sequence[~RemoteRelationChangeEvent]\n Returns -> ErrorResults\n '''",
"# map input types to rpc msg"
] | [
{
"param": "self",
"type": null
},
{
"param": "changes",
"type": null
}
] | {
"returns": [],
"raises": [],
"params": [
{
"identifier": "self",
"type": null,
"docstring": null,
"docstring_tokens": [],
"default": null,
"is_optional": null
},
{
"identifier": "changes",
"type": null,
"docstring": null,
"docstring_tokens"... |
f697638db76b9fc35cd762f0cbbb058c9ee6f5b1 | sed-i/python-libjuju | juju/client/_client2.py | [
"Apache-2.0"
] | Python | RegisterRemoteRelations | <not_specific> | async def RegisterRemoteRelations(self, relations=None):
'''
RegisterRemoteRelationArgs sets up the model to participate
in the specified relations. This operation is idempotent.
relations : typing.Sequence[~RegisterRemoteRelationArg]
Returns -> RegisterRemoteRelationResults
... |
RegisterRemoteRelationArgs sets up the model to participate
in the specified relations. This operation is idempotent.
relations : typing.Sequence[~RegisterRemoteRelationArg]
Returns -> RegisterRemoteRelationResults
| RegisterRemoteRelationArgs sets up the model to participate
in the specified relations. This operation is idempotent.
| [
"RegisterRemoteRelationArgs",
"sets",
"up",
"the",
"model",
"to",
"participate",
"in",
"the",
"specified",
"relations",
".",
"This",
"operation",
"is",
"idempotent",
"."
] | async def RegisterRemoteRelations(self, relations=None):
if relations is not None and not isinstance(relations, (bytes, str, list)):
raise Exception("Expected relations to be a Sequence, received: {}".format(type(relations)))
_params = dict()
msg = dict(type='CrossModelRelations',
... | [
"async",
"def",
"RegisterRemoteRelations",
"(",
"self",
",",
"relations",
"=",
"None",
")",
":",
"if",
"relations",
"is",
"not",
"None",
"and",
"not",
"isinstance",
"(",
"relations",
",",
"(",
"bytes",
",",
"str",
",",
"list",
")",
")",
":",
"raise",
"... | RegisterRemoteRelationArgs sets up the model to participate
in the specified relations. | [
"RegisterRemoteRelationArgs",
"sets",
"up",
"the",
"model",
"to",
"participate",
"in",
"the",
"specified",
"relations",
"."
] | [
"'''\n RegisterRemoteRelationArgs sets up the model to participate\n in the specified relations. This operation is idempotent.\n\n relations : typing.Sequence[~RegisterRemoteRelationArg]\n Returns -> RegisterRemoteRelationResults\n '''",
"# map input types to rpc msg"
] | [
{
"param": "self",
"type": null
},
{
"param": "relations",
"type": null
}
] | {
"returns": [],
"raises": [],
"params": [
{
"identifier": "self",
"type": null,
"docstring": null,
"docstring_tokens": [],
"default": null,
"is_optional": null
},
{
"identifier": "relations",
"type": null,
"docstring": null,
"docstring_token... |
f697638db76b9fc35cd762f0cbbb058c9ee6f5b1 | sed-i/python-libjuju | juju/client/_client2.py | [
"Apache-2.0"
] | Python | WatchEgressAddressesForRelations | <not_specific> | async def WatchEgressAddressesForRelations(self, args=None):
'''
WatchEgressAddressesForRelations creates a watcher that notifies when addresses, from which
connections will originate for the relation, change.
Each event contains the entire set of addresses which are required for ingress... |
WatchEgressAddressesForRelations creates a watcher that notifies when addresses, from which
connections will originate for the relation, change.
Each event contains the entire set of addresses which are required for ingress for the relation.
args : typing.Sequence[~RemoteEntityArg]
... | WatchEgressAddressesForRelations creates a watcher that notifies when addresses, from which
connections will originate for the relation, change.
Each event contains the entire set of addresses which are required for ingress for the relation.
| [
"WatchEgressAddressesForRelations",
"creates",
"a",
"watcher",
"that",
"notifies",
"when",
"addresses",
"from",
"which",
"connections",
"will",
"originate",
"for",
"the",
"relation",
"change",
".",
"Each",
"event",
"contains",
"the",
"entire",
"set",
"of",
"addresse... | async def WatchEgressAddressesForRelations(self, args=None):
if args is not None and not isinstance(args, (bytes, str, list)):
raise Exception("Expected args to be a Sequence, received: {}".format(type(args)))
_params = dict()
msg = dict(type='CrossModelRelations',
... | [
"async",
"def",
"WatchEgressAddressesForRelations",
"(",
"self",
",",
"args",
"=",
"None",
")",
":",
"if",
"args",
"is",
"not",
"None",
"and",
"not",
"isinstance",
"(",
"args",
",",
"(",
"bytes",
",",
"str",
",",
"list",
")",
")",
":",
"raise",
"Except... | WatchEgressAddressesForRelations creates a watcher that notifies when addresses, from which
connections will originate for the relation, change. | [
"WatchEgressAddressesForRelations",
"creates",
"a",
"watcher",
"that",
"notifies",
"when",
"addresses",
"from",
"which",
"connections",
"will",
"originate",
"for",
"the",
"relation",
"change",
"."
] | [
"'''\n WatchEgressAddressesForRelations creates a watcher that notifies when addresses, from which\n connections will originate for the relation, change.\n Each event contains the entire set of addresses which are required for ingress for the relation.\n\n args : typing.Sequence[~RemoteE... | [
{
"param": "self",
"type": null
},
{
"param": "args",
"type": null
}
] | {
"returns": [],
"raises": [],
"params": [
{
"identifier": "self",
"type": null,
"docstring": null,
"docstring_tokens": [],
"default": null,
"is_optional": null
},
{
"identifier": "args",
"type": null,
"docstring": null,
"docstring_tokens": [... |
f697638db76b9fc35cd762f0cbbb058c9ee6f5b1 | sed-i/python-libjuju | juju/client/_client2.py | [
"Apache-2.0"
] | Python | WatchOfferStatus | <not_specific> | async def WatchOfferStatus(self, args=None):
'''
WatchOfferStatus starts an OfferStatusWatcher for
watching the status of an offer.
args : typing.Sequence[~OfferArg]
Returns -> OfferStatusWatchResults
'''
if args is not None and not isinstance(args, (bytes, str, ... |
WatchOfferStatus starts an OfferStatusWatcher for
watching the status of an offer.
args : typing.Sequence[~OfferArg]
Returns -> OfferStatusWatchResults
| WatchOfferStatus starts an OfferStatusWatcher for
watching the status of an offer.
| [
"WatchOfferStatus",
"starts",
"an",
"OfferStatusWatcher",
"for",
"watching",
"the",
"status",
"of",
"an",
"offer",
"."
] | async def WatchOfferStatus(self, args=None):
if args is not None and not isinstance(args, (bytes, str, list)):
raise Exception("Expected args to be a Sequence, received: {}".format(type(args)))
_params = dict()
msg = dict(type='CrossModelRelations',
request='WatchO... | [
"async",
"def",
"WatchOfferStatus",
"(",
"self",
",",
"args",
"=",
"None",
")",
":",
"if",
"args",
"is",
"not",
"None",
"and",
"not",
"isinstance",
"(",
"args",
",",
"(",
"bytes",
",",
"str",
",",
"list",
")",
")",
":",
"raise",
"Exception",
"(",
"... | WatchOfferStatus starts an OfferStatusWatcher for
watching the status of an offer. | [
"WatchOfferStatus",
"starts",
"an",
"OfferStatusWatcher",
"for",
"watching",
"the",
"status",
"of",
"an",
"offer",
"."
] | [
"'''\n WatchOfferStatus starts an OfferStatusWatcher for\n watching the status of an offer.\n\n args : typing.Sequence[~OfferArg]\n Returns -> OfferStatusWatchResults\n '''",
"# map input types to rpc msg"
] | [
{
"param": "self",
"type": null
},
{
"param": "args",
"type": null
}
] | {
"returns": [],
"raises": [],
"params": [
{
"identifier": "self",
"type": null,
"docstring": null,
"docstring_tokens": [],
"default": null,
"is_optional": null
},
{
"identifier": "args",
"type": null,
"docstring": null,
"docstring_tokens": [... |
f697638db76b9fc35cd762f0cbbb058c9ee6f5b1 | sed-i/python-libjuju | juju/client/_client2.py | [
"Apache-2.0"
] | Python | WatchRelationChanges | <not_specific> | async def WatchRelationChanges(self, args=None):
'''
WatchRelationChanges starts a RemoteRelationChangesWatcher for each
specified relation, returning the watcher IDs and initial values,
or an error if the remote relations couldn't be watched.
args : typing.Sequence[~RemoteEntit... |
WatchRelationChanges starts a RemoteRelationChangesWatcher for each
specified relation, returning the watcher IDs and initial values,
or an error if the remote relations couldn't be watched.
args : typing.Sequence[~RemoteEntityArg]
Returns -> RemoteRelationWatchResults
| WatchRelationChanges starts a RemoteRelationChangesWatcher for each
specified relation, returning the watcher IDs and initial values,
or an error if the remote relations couldn't be watched.
| [
"WatchRelationChanges",
"starts",
"a",
"RemoteRelationChangesWatcher",
"for",
"each",
"specified",
"relation",
"returning",
"the",
"watcher",
"IDs",
"and",
"initial",
"values",
"or",
"an",
"error",
"if",
"the",
"remote",
"relations",
"couldn",
"'",
"t",
"be",
"wat... | async def WatchRelationChanges(self, args=None):
if args is not None and not isinstance(args, (bytes, str, list)):
raise Exception("Expected args to be a Sequence, received: {}".format(type(args)))
_params = dict()
msg = dict(type='CrossModelRelations',
request='Wa... | [
"async",
"def",
"WatchRelationChanges",
"(",
"self",
",",
"args",
"=",
"None",
")",
":",
"if",
"args",
"is",
"not",
"None",
"and",
"not",
"isinstance",
"(",
"args",
",",
"(",
"bytes",
",",
"str",
",",
"list",
")",
")",
":",
"raise",
"Exception",
"(",... | WatchRelationChanges starts a RemoteRelationChangesWatcher for each
specified relation, returning the watcher IDs and initial values,
or an error if the remote relations couldn't be watched. | [
"WatchRelationChanges",
"starts",
"a",
"RemoteRelationChangesWatcher",
"for",
"each",
"specified",
"relation",
"returning",
"the",
"watcher",
"IDs",
"and",
"initial",
"values",
"or",
"an",
"error",
"if",
"the",
"remote",
"relations",
"couldn",
"'",
"t",
"be",
"wat... | [
"'''\n WatchRelationChanges starts a RemoteRelationChangesWatcher for each\n specified relation, returning the watcher IDs and initial values,\n or an error if the remote relations couldn't be watched.\n\n args : typing.Sequence[~RemoteEntityArg]\n Returns -> RemoteRelationWatchRe... | [
{
"param": "self",
"type": null
},
{
"param": "args",
"type": null
}
] | {
"returns": [],
"raises": [],
"params": [
{
"identifier": "self",
"type": null,
"docstring": null,
"docstring_tokens": [],
"default": null,
"is_optional": null
},
{
"identifier": "args",
"type": null,
"docstring": null,
"docstring_tokens": [... |
f697638db76b9fc35cd762f0cbbb058c9ee6f5b1 | sed-i/python-libjuju | juju/client/_client2.py | [
"Apache-2.0"
] | Python | WatchRelationsSuspendedStatus | <not_specific> | async def WatchRelationsSuspendedStatus(self, args=None):
'''
WatchRelationsSuspendedStatus starts a RelationStatusWatcher for
watching the life and suspended status of a relation.
args : typing.Sequence[~RemoteEntityArg]
Returns -> RelationStatusWatchResults
'''
... |
WatchRelationsSuspendedStatus starts a RelationStatusWatcher for
watching the life and suspended status of a relation.
args : typing.Sequence[~RemoteEntityArg]
Returns -> RelationStatusWatchResults
| WatchRelationsSuspendedStatus starts a RelationStatusWatcher for
watching the life and suspended status of a relation.
| [
"WatchRelationsSuspendedStatus",
"starts",
"a",
"RelationStatusWatcher",
"for",
"watching",
"the",
"life",
"and",
"suspended",
"status",
"of",
"a",
"relation",
"."
] | async def WatchRelationsSuspendedStatus(self, args=None):
if args is not None and not isinstance(args, (bytes, str, list)):
raise Exception("Expected args to be a Sequence, received: {}".format(type(args)))
_params = dict()
msg = dict(type='CrossModelRelations',
re... | [
"async",
"def",
"WatchRelationsSuspendedStatus",
"(",
"self",
",",
"args",
"=",
"None",
")",
":",
"if",
"args",
"is",
"not",
"None",
"and",
"not",
"isinstance",
"(",
"args",
",",
"(",
"bytes",
",",
"str",
",",
"list",
")",
")",
":",
"raise",
"Exception... | WatchRelationsSuspendedStatus starts a RelationStatusWatcher for
watching the life and suspended status of a relation. | [
"WatchRelationsSuspendedStatus",
"starts",
"a",
"RelationStatusWatcher",
"for",
"watching",
"the",
"life",
"and",
"suspended",
"status",
"of",
"a",
"relation",
"."
] | [
"'''\n WatchRelationsSuspendedStatus starts a RelationStatusWatcher for\n watching the life and suspended status of a relation.\n\n args : typing.Sequence[~RemoteEntityArg]\n Returns -> RelationStatusWatchResults\n '''",
"# map input types to rpc msg"
] | [
{
"param": "self",
"type": null
},
{
"param": "args",
"type": null
}
] | {
"returns": [],
"raises": [],
"params": [
{
"identifier": "self",
"type": null,
"docstring": null,
"docstring_tokens": [],
"default": null,
"is_optional": null
},
{
"identifier": "args",
"type": null,
"docstring": null,
"docstring_tokens": [... |
f697638db76b9fc35cd762f0cbbb058c9ee6f5b1 | sed-i/python-libjuju | juju/client/_client2.py | [
"Apache-2.0"
] | Python | Next | <not_specific> | async def Next(self):
'''
Next returns when a change has occurred to an entity of the
collection being watched since the most recent call to Next
or the Watch call that created the srvEntitiesWatcher.
Returns -> EntitiesWatchResult
'''
# map input types to rpc ... |
Next returns when a change has occurred to an entity of the
collection being watched since the most recent call to Next
or the Watch call that created the srvEntitiesWatcher.
Returns -> EntitiesWatchResult
| Next returns when a change has occurred to an entity of the
collection being watched since the most recent call to Next
or the Watch call that created the srvEntitiesWatcher.
| [
"Next",
"returns",
"when",
"a",
"change",
"has",
"occurred",
"to",
"an",
"entity",
"of",
"the",
"collection",
"being",
"watched",
"since",
"the",
"most",
"recent",
"call",
"to",
"Next",
"or",
"the",
"Watch",
"call",
"that",
"created",
"the",
"srvEntitiesWatc... | async def Next(self):
_params = dict()
msg = dict(type='EntityWatcher',
request='Next',
version=2,
params=_params)
reply = await self.rpc(msg)
return reply | [
"async",
"def",
"Next",
"(",
"self",
")",
":",
"_params",
"=",
"dict",
"(",
")",
"msg",
"=",
"dict",
"(",
"type",
"=",
"'EntityWatcher'",
",",
"request",
"=",
"'Next'",
",",
"version",
"=",
"2",
",",
"params",
"=",
"_params",
")",
"reply",
"=",
"aw... | Next returns when a change has occurred to an entity of the
collection being watched since the most recent call to Next
or the Watch call that created the srvEntitiesWatcher. | [
"Next",
"returns",
"when",
"a",
"change",
"has",
"occurred",
"to",
"an",
"entity",
"of",
"the",
"collection",
"being",
"watched",
"since",
"the",
"most",
"recent",
"call",
"to",
"Next",
"or",
"the",
"Watch",
"call",
"that",
"created",
"the",
"srvEntitiesWatc... | [
"'''\n Next returns when a change has occurred to an entity of the\n collection being watched since the most recent call to Next\n or the Watch call that created the srvEntitiesWatcher.\n\n\n Returns -> EntitiesWatchResult\n '''",
"# map input types to rpc msg"
] | [
{
"param": "self",
"type": null
}
] | {
"returns": [],
"raises": [],
"params": [
{
"identifier": "self",
"type": null,
"docstring": null,
"docstring_tokens": [],
"default": null,
"is_optional": null
}
],
"outlier_params": [],
"others": []
} |
f697638db76b9fc35cd762f0cbbb058c9ee6f5b1 | sed-i/python-libjuju | juju/client/_client2.py | [
"Apache-2.0"
] | Python | Next | <not_specific> | async def Next(self):
'''
Next returns when a change has occurred to an entity of the
collection being watched since the most recent call to Next
or the Watch call that created the srvMachineStorageIdsWatcher.
Returns -> MachineStorageIdsWatchResult
'''
# map i... |
Next returns when a change has occurred to an entity of the
collection being watched since the most recent call to Next
or the Watch call that created the srvMachineStorageIdsWatcher.
Returns -> MachineStorageIdsWatchResult
| Next returns when a change has occurred to an entity of the
collection being watched since the most recent call to Next
or the Watch call that created the srvMachineStorageIdsWatcher.
| [
"Next",
"returns",
"when",
"a",
"change",
"has",
"occurred",
"to",
"an",
"entity",
"of",
"the",
"collection",
"being",
"watched",
"since",
"the",
"most",
"recent",
"call",
"to",
"Next",
"or",
"the",
"Watch",
"call",
"that",
"created",
"the",
"srvMachineStora... | async def Next(self):
_params = dict()
msg = dict(type='FilesystemAttachmentsWatcher',
request='Next',
version=2,
params=_params)
reply = await self.rpc(msg)
return reply | [
"async",
"def",
"Next",
"(",
"self",
")",
":",
"_params",
"=",
"dict",
"(",
")",
"msg",
"=",
"dict",
"(",
"type",
"=",
"'FilesystemAttachmentsWatcher'",
",",
"request",
"=",
"'Next'",
",",
"version",
"=",
"2",
",",
"params",
"=",
"_params",
")",
"reply... | Next returns when a change has occurred to an entity of the
collection being watched since the most recent call to Next
or the Watch call that created the srvMachineStorageIdsWatcher. | [
"Next",
"returns",
"when",
"a",
"change",
"has",
"occurred",
"to",
"an",
"entity",
"of",
"the",
"collection",
"being",
"watched",
"since",
"the",
"most",
"recent",
"call",
"to",
"Next",
"or",
"the",
"Watch",
"call",
"that",
"created",
"the",
"srvMachineStora... | [
"'''\n Next returns when a change has occurred to an entity of the\n collection being watched since the most recent call to Next\n or the Watch call that created the srvMachineStorageIdsWatcher.\n\n\n Returns -> MachineStorageIdsWatchResult\n '''",
"# map input types to rpc msg"... | [
{
"param": "self",
"type": null
}
] | {
"returns": [],
"raises": [],
"params": [
{
"identifier": "self",
"type": null,
"docstring": null,
"docstring_tokens": [],
"default": null,
"is_optional": null
}
],
"outlier_params": [],
"others": []
} |
f697638db76b9fc35cd762f0cbbb058c9ee6f5b1 | sed-i/python-libjuju | juju/client/_client2.py | [
"Apache-2.0"
] | Python | EnableHA | <not_specific> | async def EnableHA(self, specs=None):
'''
EnableHA adds controller machines as necessary to ensure the
controller has the number of machines specified.
specs : typing.Sequence[~ControllersSpec]
Returns -> ControllersChangeResults
'''
if specs is not None and not ... |
EnableHA adds controller machines as necessary to ensure the
controller has the number of machines specified.
specs : typing.Sequence[~ControllersSpec]
Returns -> ControllersChangeResults
| EnableHA adds controller machines as necessary to ensure the
controller has the number of machines specified.
| [
"EnableHA",
"adds",
"controller",
"machines",
"as",
"necessary",
"to",
"ensure",
"the",
"controller",
"has",
"the",
"number",
"of",
"machines",
"specified",
"."
] | async def EnableHA(self, specs=None):
if specs is not None and not isinstance(specs, (bytes, str, list)):
raise Exception("Expected specs to be a Sequence, received: {}".format(type(specs)))
_params = dict()
msg = dict(type='HighAvailability',
request='EnableHA',
... | [
"async",
"def",
"EnableHA",
"(",
"self",
",",
"specs",
"=",
"None",
")",
":",
"if",
"specs",
"is",
"not",
"None",
"and",
"not",
"isinstance",
"(",
"specs",
",",
"(",
"bytes",
",",
"str",
",",
"list",
")",
")",
":",
"raise",
"Exception",
"(",
"\"Exp... | EnableHA adds controller machines as necessary to ensure the
controller has the number of machines specified. | [
"EnableHA",
"adds",
"controller",
"machines",
"as",
"necessary",
"to",
"ensure",
"the",
"controller",
"has",
"the",
"number",
"of",
"machines",
"specified",
"."
] | [
"'''\n EnableHA adds controller machines as necessary to ensure the\n controller has the number of machines specified.\n\n specs : typing.Sequence[~ControllersSpec]\n Returns -> ControllersChangeResults\n '''",
"# map input types to rpc msg"
] | [
{
"param": "self",
"type": null
},
{
"param": "specs",
"type": null
}
] | {
"returns": [],
"raises": [],
"params": [
{
"identifier": "self",
"type": null,
"docstring": null,
"docstring_tokens": [],
"default": null,
"is_optional": null
},
{
"identifier": "specs",
"type": null,
"docstring": null,
"docstring_tokens": ... |
f697638db76b9fc35cd762f0cbbb058c9ee6f5b1 | sed-i/python-libjuju | juju/client/_client2.py | [
"Apache-2.0"
] | Python | DeleteImages | <not_specific> | async def DeleteImages(self, images=None):
'''
DeleteImages deletes the images matching the specified filter.
images : typing.Sequence[~ImageSpec]
Returns -> ErrorResults
'''
if images is not None and not isinstance(images, (bytes, str, list)):
raise Exceptio... |
DeleteImages deletes the images matching the specified filter.
images : typing.Sequence[~ImageSpec]
Returns -> ErrorResults
| DeleteImages deletes the images matching the specified filter. | [
"DeleteImages",
"deletes",
"the",
"images",
"matching",
"the",
"specified",
"filter",
"."
] | async def DeleteImages(self, images=None):
if images is not None and not isinstance(images, (bytes, str, list)):
raise Exception("Expected images to be a Sequence, received: {}".format(type(images)))
_params = dict()
msg = dict(type='ImageManager',
request='DeleteI... | [
"async",
"def",
"DeleteImages",
"(",
"self",
",",
"images",
"=",
"None",
")",
":",
"if",
"images",
"is",
"not",
"None",
"and",
"not",
"isinstance",
"(",
"images",
",",
"(",
"bytes",
",",
"str",
",",
"list",
")",
")",
":",
"raise",
"Exception",
"(",
... | DeleteImages deletes the images matching the specified filter. | [
"DeleteImages",
"deletes",
"the",
"images",
"matching",
"the",
"specified",
"filter",
"."
] | [
"'''\n DeleteImages deletes the images matching the specified filter.\n\n images : typing.Sequence[~ImageSpec]\n Returns -> ErrorResults\n '''",
"# map input types to rpc msg"
] | [
{
"param": "self",
"type": null
},
{
"param": "images",
"type": null
}
] | {
"returns": [],
"raises": [],
"params": [
{
"identifier": "self",
"type": null,
"docstring": null,
"docstring_tokens": [],
"default": null,
"is_optional": null
},
{
"identifier": "images",
"type": null,
"docstring": null,
"docstring_tokens":... |
f697638db76b9fc35cd762f0cbbb058c9ee6f5b1 | sed-i/python-libjuju | juju/client/_client2.py | [
"Apache-2.0"
] | Python | ListImages | <not_specific> | async def ListImages(self, images=None):
'''
ListImages returns images matching the specified filter.
images : typing.Sequence[~ImageSpec]
Returns -> ListImageResult
'''
if images is not None and not isinstance(images, (bytes, str, list)):
raise Exception("Ex... |
ListImages returns images matching the specified filter.
images : typing.Sequence[~ImageSpec]
Returns -> ListImageResult
| ListImages returns images matching the specified filter. | [
"ListImages",
"returns",
"images",
"matching",
"the",
"specified",
"filter",
"."
] | async def ListImages(self, images=None):
if images is not None and not isinstance(images, (bytes, str, list)):
raise Exception("Expected images to be a Sequence, received: {}".format(type(images)))
_params = dict()
msg = dict(type='ImageManager',
request='ListImage... | [
"async",
"def",
"ListImages",
"(",
"self",
",",
"images",
"=",
"None",
")",
":",
"if",
"images",
"is",
"not",
"None",
"and",
"not",
"isinstance",
"(",
"images",
",",
"(",
"bytes",
",",
"str",
",",
"list",
")",
")",
":",
"raise",
"Exception",
"(",
"... | ListImages returns images matching the specified filter. | [
"ListImages",
"returns",
"images",
"matching",
"the",
"specified",
"filter",
"."
] | [
"'''\n ListImages returns images matching the specified filter.\n\n images : typing.Sequence[~ImageSpec]\n Returns -> ListImageResult\n '''",
"# map input types to rpc msg"
] | [
{
"param": "self",
"type": null
},
{
"param": "images",
"type": null
}
] | {
"returns": [],
"raises": [],
"params": [
{
"identifier": "self",
"type": null,
"docstring": null,
"docstring_tokens": [],
"default": null,
"is_optional": null
},
{
"identifier": "images",
"type": null,
"docstring": null,
"docstring_tokens":... |
f697638db76b9fc35cd762f0cbbb058c9ee6f5b1 | sed-i/python-libjuju | juju/client/_client2.py | [
"Apache-2.0"
] | Python | CharmProfilingInfo | <not_specific> | async def CharmProfilingInfo(self, tag=None):
'''
CharmProfilingInfo returns info to update lxd profiles on the machine. If
the machine is not provisioned, no profile change info will be returned,
nor will an error.
tag : str
Returns -> CharmProfilingInfoResult
'... |
CharmProfilingInfo returns info to update lxd profiles on the machine. If
the machine is not provisioned, no profile change info will be returned,
nor will an error.
tag : str
Returns -> CharmProfilingInfoResult
| CharmProfilingInfo returns info to update lxd profiles on the machine. If
the machine is not provisioned, no profile change info will be returned,
nor will an error.
tag : str
Returns -> CharmProfilingInfoResult | [
"CharmProfilingInfo",
"returns",
"info",
"to",
"update",
"lxd",
"profiles",
"on",
"the",
"machine",
".",
"If",
"the",
"machine",
"is",
"not",
"provisioned",
"no",
"profile",
"change",
"info",
"will",
"be",
"returned",
"nor",
"will",
"an",
"error",
".",
"tag"... | async def CharmProfilingInfo(self, tag=None):
if tag is not None and not isinstance(tag, (bytes, str)):
raise Exception("Expected tag to be a str, received: {}".format(type(tag)))
_params = dict()
msg = dict(type='InstanceMutater',
request='CharmProfilingInfo',
... | [
"async",
"def",
"CharmProfilingInfo",
"(",
"self",
",",
"tag",
"=",
"None",
")",
":",
"if",
"tag",
"is",
"not",
"None",
"and",
"not",
"isinstance",
"(",
"tag",
",",
"(",
"bytes",
",",
"str",
")",
")",
":",
"raise",
"Exception",
"(",
"\"Expected tag to ... | CharmProfilingInfo returns info to update lxd profiles on the machine. | [
"CharmProfilingInfo",
"returns",
"info",
"to",
"update",
"lxd",
"profiles",
"on",
"the",
"machine",
"."
] | [
"'''\n CharmProfilingInfo returns info to update lxd profiles on the machine. If\n the machine is not provisioned, no profile change info will be returned,\n nor will an error.\n\n tag : str\n Returns -> CharmProfilingInfoResult\n '''",
"# map input types to rpc msg"
] | [
{
"param": "self",
"type": null
},
{
"param": "tag",
"type": null
}
] | {
"returns": [],
"raises": [],
"params": [
{
"identifier": "self",
"type": null,
"docstring": null,
"docstring_tokens": [],
"default": null,
"is_optional": null
},
{
"identifier": "tag",
"type": null,
"docstring": null,
"docstring_tokens": []... |
f697638db76b9fc35cd762f0cbbb058c9ee6f5b1 | sed-i/python-libjuju | juju/client/_client2.py | [
"Apache-2.0"
] | Python | ContainerType | <not_specific> | async def ContainerType(self, tag=None):
'''
ContainerType returns the container type of a machine.
tag : str
Returns -> ContainerTypeResult
'''
if tag is not None and not isinstance(tag, (bytes, str)):
raise Exception("Expected tag to be a str, received: {}"... |
ContainerType returns the container type of a machine.
tag : str
Returns -> ContainerTypeResult
| ContainerType returns the container type of a machine.
tag : str
Returns -> ContainerTypeResult | [
"ContainerType",
"returns",
"the",
"container",
"type",
"of",
"a",
"machine",
".",
"tag",
":",
"str",
"Returns",
"-",
">",
"ContainerTypeResult"
] | async def ContainerType(self, tag=None):
if tag is not None and not isinstance(tag, (bytes, str)):
raise Exception("Expected tag to be a str, received: {}".format(type(tag)))
_params = dict()
msg = dict(type='InstanceMutater',
request='ContainerType',
... | [
"async",
"def",
"ContainerType",
"(",
"self",
",",
"tag",
"=",
"None",
")",
":",
"if",
"tag",
"is",
"not",
"None",
"and",
"not",
"isinstance",
"(",
"tag",
",",
"(",
"bytes",
",",
"str",
")",
")",
":",
"raise",
"Exception",
"(",
"\"Expected tag to be a ... | ContainerType returns the container type of a machine. | [
"ContainerType",
"returns",
"the",
"container",
"type",
"of",
"a",
"machine",
"."
] | [
"'''\n ContainerType returns the container type of a machine.\n\n tag : str\n Returns -> ContainerTypeResult\n '''",
"# map input types to rpc msg"
] | [
{
"param": "self",
"type": null
},
{
"param": "tag",
"type": null
}
] | {
"returns": [],
"raises": [],
"params": [
{
"identifier": "self",
"type": null,
"docstring": null,
"docstring_tokens": [],
"default": null,
"is_optional": null
},
{
"identifier": "tag",
"type": null,
"docstring": null,
"docstring_tokens": []... |
f697638db76b9fc35cd762f0cbbb058c9ee6f5b1 | sed-i/python-libjuju | juju/client/_client2.py | [
"Apache-2.0"
] | Python | Life | <not_specific> | async def Life(self, entities=None):
'''
Life returns the life status of every supplied entity, where available.
entities : typing.Sequence[~Entity]
Returns -> LifeResults
'''
if entities is not None and not isinstance(entities, (bytes, str, list)):
raise Exc... |
Life returns the life status of every supplied entity, where available.
entities : typing.Sequence[~Entity]
Returns -> LifeResults
| Life returns the life status of every supplied entity, where available.
entities : typing.Sequence[~Entity]
Returns -> LifeResults | [
"Life",
"returns",
"the",
"life",
"status",
"of",
"every",
"supplied",
"entity",
"where",
"available",
".",
"entities",
":",
"typing",
".",
"Sequence",
"[",
"~Entity",
"]",
"Returns",
"-",
">",
"LifeResults"
] | async def Life(self, entities=None):
if entities is not None and not isinstance(entities, (bytes, str, list)):
raise Exception("Expected entities to be a Sequence, received: {}".format(type(entities)))
_params = dict()
msg = dict(type='InstanceMutater',
request='Li... | [
"async",
"def",
"Life",
"(",
"self",
",",
"entities",
"=",
"None",
")",
":",
"if",
"entities",
"is",
"not",
"None",
"and",
"not",
"isinstance",
"(",
"entities",
",",
"(",
"bytes",
",",
"str",
",",
"list",
")",
")",
":",
"raise",
"Exception",
"(",
"... | Life returns the life status of every supplied entity, where available. | [
"Life",
"returns",
"the",
"life",
"status",
"of",
"every",
"supplied",
"entity",
"where",
"available",
"."
] | [
"'''\n Life returns the life status of every supplied entity, where available.\n\n entities : typing.Sequence[~Entity]\n Returns -> LifeResults\n '''",
"# map input types to rpc msg"
] | [
{
"param": "self",
"type": null
},
{
"param": "entities",
"type": null
}
] | {
"returns": [],
"raises": [],
"params": [
{
"identifier": "self",
"type": null,
"docstring": null,
"docstring_tokens": [],
"default": null,
"is_optional": null
},
{
"identifier": "entities",
"type": null,
"docstring": null,
"docstring_tokens... |
f697638db76b9fc35cd762f0cbbb058c9ee6f5b1 | sed-i/python-libjuju | juju/client/_client2.py | [
"Apache-2.0"
] | Python | SetCharmProfiles | <not_specific> | async def SetCharmProfiles(self, args=None):
'''
SetCharmProfiles records the given slice of charm profile names.
args : typing.Sequence[~SetProfileArg]
Returns -> ErrorResults
'''
if args is not None and not isinstance(args, (bytes, str, list)):
raise Except... |
SetCharmProfiles records the given slice of charm profile names.
args : typing.Sequence[~SetProfileArg]
Returns -> ErrorResults
| SetCharmProfiles records the given slice of charm profile names. | [
"SetCharmProfiles",
"records",
"the",
"given",
"slice",
"of",
"charm",
"profile",
"names",
"."
] | async def SetCharmProfiles(self, args=None):
if args is not None and not isinstance(args, (bytes, str, list)):
raise Exception("Expected args to be a Sequence, received: {}".format(type(args)))
_params = dict()
msg = dict(type='InstanceMutater',
request='SetCharmPr... | [
"async",
"def",
"SetCharmProfiles",
"(",
"self",
",",
"args",
"=",
"None",
")",
":",
"if",
"args",
"is",
"not",
"None",
"and",
"not",
"isinstance",
"(",
"args",
",",
"(",
"bytes",
",",
"str",
",",
"list",
")",
")",
":",
"raise",
"Exception",
"(",
"... | SetCharmProfiles records the given slice of charm profile names. | [
"SetCharmProfiles",
"records",
"the",
"given",
"slice",
"of",
"charm",
"profile",
"names",
"."
] | [
"'''\n SetCharmProfiles records the given slice of charm profile names.\n\n args : typing.Sequence[~SetProfileArg]\n Returns -> ErrorResults\n '''",
"# map input types to rpc msg"
] | [
{
"param": "self",
"type": null
},
{
"param": "args",
"type": null
}
] | {
"returns": [],
"raises": [],
"params": [
{
"identifier": "self",
"type": null,
"docstring": null,
"docstring_tokens": [],
"default": null,
"is_optional": null
},
{
"identifier": "args",
"type": null,
"docstring": null,
"docstring_tokens": [... |
f697638db76b9fc35cd762f0cbbb058c9ee6f5b1 | sed-i/python-libjuju | juju/client/_client2.py | [
"Apache-2.0"
] | Python | SetModificationStatus | <not_specific> | async def SetModificationStatus(self, entities=None):
'''
SetModificationStatus updates the instance whilst changes are occurring. This
is different from SetStatus and SetInstanceStatus, by the fact this holds
information about the ongoing changes that are happening to instances.
... |
SetModificationStatus updates the instance whilst changes are occurring. This
is different from SetStatus and SetInstanceStatus, by the fact this holds
information about the ongoing changes that are happening to instances.
Consider LXD Profile updates that can modify a instance, but may... | SetModificationStatus updates the instance whilst changes are occurring. This
is different from SetStatus and SetInstanceStatus, by the fact this holds
information about the ongoing changes that are happening to instances.
Consider LXD Profile updates that can modify a instance, but may not cause
the instance to be pla... | [
"SetModificationStatus",
"updates",
"the",
"instance",
"whilst",
"changes",
"are",
"occurring",
".",
"This",
"is",
"different",
"from",
"SetStatus",
"and",
"SetInstanceStatus",
"by",
"the",
"fact",
"this",
"holds",
"information",
"about",
"the",
"ongoing",
"changes"... | async def SetModificationStatus(self, entities=None):
if entities is not None and not isinstance(entities, (bytes, str, list)):
raise Exception("Expected entities to be a Sequence, received: {}".format(type(entities)))
_params = dict()
msg = dict(type='InstanceMutater',
... | [
"async",
"def",
"SetModificationStatus",
"(",
"self",
",",
"entities",
"=",
"None",
")",
":",
"if",
"entities",
"is",
"not",
"None",
"and",
"not",
"isinstance",
"(",
"entities",
",",
"(",
"bytes",
",",
"str",
",",
"list",
")",
")",
":",
"raise",
"Excep... | SetModificationStatus updates the instance whilst changes are occurring. | [
"SetModificationStatus",
"updates",
"the",
"instance",
"whilst",
"changes",
"are",
"occurring",
"."
] | [
"'''\n SetModificationStatus updates the instance whilst changes are occurring. This\n is different from SetStatus and SetInstanceStatus, by the fact this holds\n information about the ongoing changes that are happening to instances.\n Consider LXD Profile updates that can modify a insta... | [
{
"param": "self",
"type": null
},
{
"param": "entities",
"type": null
}
] | {
"returns": [],
"raises": [],
"params": [
{
"identifier": "self",
"type": null,
"docstring": null,
"docstring_tokens": [],
"default": null,
"is_optional": null
},
{
"identifier": "entities",
"type": null,
"docstring": null,
"docstring_tokens... |
f697638db76b9fc35cd762f0cbbb058c9ee6f5b1 | sed-i/python-libjuju | juju/client/_client2.py | [
"Apache-2.0"
] | Python | WatchContainers | <not_specific> | async def WatchContainers(self, tag=None):
'''
WatchContainers starts a watcher to track Containers on a given
machine.
tag : str
Returns -> StringsWatchResult
'''
if tag is not None and not isinstance(tag, (bytes, str)):
raise Exception("Expected tag... |
WatchContainers starts a watcher to track Containers on a given
machine.
tag : str
Returns -> StringsWatchResult
| WatchContainers starts a watcher to track Containers on a given
machine.
tag : str
Returns -> StringsWatchResult | [
"WatchContainers",
"starts",
"a",
"watcher",
"to",
"track",
"Containers",
"on",
"a",
"given",
"machine",
".",
"tag",
":",
"str",
"Returns",
"-",
">",
"StringsWatchResult"
] | async def WatchContainers(self, tag=None):
if tag is not None and not isinstance(tag, (bytes, str)):
raise Exception("Expected tag to be a str, received: {}".format(type(tag)))
_params = dict()
msg = dict(type='InstanceMutater',
request='WatchContainers',
... | [
"async",
"def",
"WatchContainers",
"(",
"self",
",",
"tag",
"=",
"None",
")",
":",
"if",
"tag",
"is",
"not",
"None",
"and",
"not",
"isinstance",
"(",
"tag",
",",
"(",
"bytes",
",",
"str",
")",
")",
":",
"raise",
"Exception",
"(",
"\"Expected tag to be ... | WatchContainers starts a watcher to track Containers on a given
machine. | [
"WatchContainers",
"starts",
"a",
"watcher",
"to",
"track",
"Containers",
"on",
"a",
"given",
"machine",
"."
] | [
"'''\n WatchContainers starts a watcher to track Containers on a given\n machine.\n\n tag : str\n Returns -> StringsWatchResult\n '''",
"# map input types to rpc msg"
] | [
{
"param": "self",
"type": null
},
{
"param": "tag",
"type": null
}
] | {
"returns": [],
"raises": [],
"params": [
{
"identifier": "self",
"type": null,
"docstring": null,
"docstring_tokens": [],
"default": null,
"is_optional": null
},
{
"identifier": "tag",
"type": null,
"docstring": null,
"docstring_tokens": []... |
f697638db76b9fc35cd762f0cbbb058c9ee6f5b1 | sed-i/python-libjuju | juju/client/_client2.py | [
"Apache-2.0"
] | Python | WatchLXDProfileVerificationNeeded | <not_specific> | async def WatchLXDProfileVerificationNeeded(self, entities=None):
'''
WatchLXDProfileVerificationNeeded starts a watcher to track Applications with
LXD Profiles.
entities : typing.Sequence[~Entity]
Returns -> NotifyWatchResults
'''
if entities is not None and not... |
WatchLXDProfileVerificationNeeded starts a watcher to track Applications with
LXD Profiles.
entities : typing.Sequence[~Entity]
Returns -> NotifyWatchResults
| WatchLXDProfileVerificationNeeded starts a watcher to track Applications with
LXD Profiles.
entities : typing.Sequence[~Entity]
Returns -> NotifyWatchResults | [
"WatchLXDProfileVerificationNeeded",
"starts",
"a",
"watcher",
"to",
"track",
"Applications",
"with",
"LXD",
"Profiles",
".",
"entities",
":",
"typing",
".",
"Sequence",
"[",
"~Entity",
"]",
"Returns",
"-",
">",
"NotifyWatchResults"
] | async def WatchLXDProfileVerificationNeeded(self, entities=None):
if entities is not None and not isinstance(entities, (bytes, str, list)):
raise Exception("Expected entities to be a Sequence, received: {}".format(type(entities)))
_params = dict()
msg = dict(type='InstanceMutater',
... | [
"async",
"def",
"WatchLXDProfileVerificationNeeded",
"(",
"self",
",",
"entities",
"=",
"None",
")",
":",
"if",
"entities",
"is",
"not",
"None",
"and",
"not",
"isinstance",
"(",
"entities",
",",
"(",
"bytes",
",",
"str",
",",
"list",
")",
")",
":",
"rais... | WatchLXDProfileVerificationNeeded starts a watcher to track Applications with
LXD Profiles. | [
"WatchLXDProfileVerificationNeeded",
"starts",
"a",
"watcher",
"to",
"track",
"Applications",
"with",
"LXD",
"Profiles",
"."
] | [
"'''\n WatchLXDProfileVerificationNeeded starts a watcher to track Applications with\n LXD Profiles.\n\n entities : typing.Sequence[~Entity]\n Returns -> NotifyWatchResults\n '''",
"# map input types to rpc msg"
] | [
{
"param": "self",
"type": null
},
{
"param": "entities",
"type": null
}
] | {
"returns": [],
"raises": [],
"params": [
{
"identifier": "self",
"type": null,
"docstring": null,
"docstring_tokens": [],
"default": null,
"is_optional": null
},
{
"identifier": "entities",
"type": null,
"docstring": null,
"docstring_tokens... |
f697638db76b9fc35cd762f0cbbb058c9ee6f5b1 | sed-i/python-libjuju | juju/client/_client2.py | [
"Apache-2.0"
] | Python | WatchMachines | <not_specific> | async def WatchMachines(self):
'''
WatchMachines starts a watcher to track machines.
WatchMachines does not consume the initial event of the watch response, as
that returns the initial set of machines that are currently available.
Returns -> StringsWatchResult
'''
... |
WatchMachines starts a watcher to track machines.
WatchMachines does not consume the initial event of the watch response, as
that returns the initial set of machines that are currently available.
Returns -> StringsWatchResult
| WatchMachines starts a watcher to track machines.
WatchMachines does not consume the initial event of the watch response, as
that returns the initial set of machines that are currently available.
| [
"WatchMachines",
"starts",
"a",
"watcher",
"to",
"track",
"machines",
".",
"WatchMachines",
"does",
"not",
"consume",
"the",
"initial",
"event",
"of",
"the",
"watch",
"response",
"as",
"that",
"returns",
"the",
"initial",
"set",
"of",
"machines",
"that",
"are"... | async def WatchMachines(self):
_params = dict()
msg = dict(type='InstanceMutater',
request='WatchMachines',
version=2,
params=_params)
reply = await self.rpc(msg)
return reply | [
"async",
"def",
"WatchMachines",
"(",
"self",
")",
":",
"_params",
"=",
"dict",
"(",
")",
"msg",
"=",
"dict",
"(",
"type",
"=",
"'InstanceMutater'",
",",
"request",
"=",
"'WatchMachines'",
",",
"version",
"=",
"2",
",",
"params",
"=",
"_params",
")",
"... | WatchMachines starts a watcher to track machines. | [
"WatchMachines",
"starts",
"a",
"watcher",
"to",
"track",
"machines",
"."
] | [
"'''\n WatchMachines starts a watcher to track machines.\n WatchMachines does not consume the initial event of the watch response, as\n that returns the initial set of machines that are currently available.\n\n\n Returns -> StringsWatchResult\n '''",
"# map input types to rpc ms... | [
{
"param": "self",
"type": null
}
] | {
"returns": [],
"raises": [],
"params": [
{
"identifier": "self",
"type": null,
"docstring": null,
"docstring_tokens": [],
"default": null,
"is_optional": null
}
],
"outlier_params": [],
"others": []
} |
f697638db76b9fc35cd762f0cbbb058c9ee6f5b1 | sed-i/python-libjuju | juju/client/_client2.py | [
"Apache-2.0"
] | Python | BlockUntilLeadershipReleased | <not_specific> | async def BlockUntilLeadershipReleased(self, name=None):
'''
BlockUntilLeadershipReleased blocks the caller until leadership is
released for the given service.
name : str
Returns -> ErrorResult
'''
if name is not None and not isinstance(name, (bytes, str)):
... |
BlockUntilLeadershipReleased blocks the caller until leadership is
released for the given service.
name : str
Returns -> ErrorResult
| BlockUntilLeadershipReleased blocks the caller until leadership is
released for the given service.
name : str
Returns -> ErrorResult | [
"BlockUntilLeadershipReleased",
"blocks",
"the",
"caller",
"until",
"leadership",
"is",
"released",
"for",
"the",
"given",
"service",
".",
"name",
":",
"str",
"Returns",
"-",
">",
"ErrorResult"
] | async def BlockUntilLeadershipReleased(self, name=None):
if name is not None and not isinstance(name, (bytes, str)):
raise Exception("Expected name to be a str, received: {}".format(type(name)))
_params = dict()
msg = dict(type='LeadershipService',
request='BlockUn... | [
"async",
"def",
"BlockUntilLeadershipReleased",
"(",
"self",
",",
"name",
"=",
"None",
")",
":",
"if",
"name",
"is",
"not",
"None",
"and",
"not",
"isinstance",
"(",
"name",
",",
"(",
"bytes",
",",
"str",
")",
")",
":",
"raise",
"Exception",
"(",
"\"Exp... | BlockUntilLeadershipReleased blocks the caller until leadership is
released for the given service. | [
"BlockUntilLeadershipReleased",
"blocks",
"the",
"caller",
"until",
"leadership",
"is",
"released",
"for",
"the",
"given",
"service",
"."
] | [
"'''\n BlockUntilLeadershipReleased blocks the caller until leadership is\n released for the given service.\n\n name : str\n Returns -> ErrorResult\n '''",
"# map input types to rpc msg"
] | [
{
"param": "self",
"type": null
},
{
"param": "name",
"type": null
}
] | {
"returns": [],
"raises": [],
"params": [
{
"identifier": "self",
"type": null,
"docstring": null,
"docstring_tokens": [],
"default": null,
"is_optional": null
},
{
"identifier": "name",
"type": null,
"docstring": null,
"docstring_tokens": [... |
f697638db76b9fc35cd762f0cbbb058c9ee6f5b1 | sed-i/python-libjuju | juju/client/_client2.py | [
"Apache-2.0"
] | Python | ClaimLeadership | <not_specific> | async def ClaimLeadership(self, params=None):
'''
ClaimLeadership makes a leadership claim with the given parameters.
params : typing.Sequence[~ClaimLeadershipParams]
Returns -> ClaimLeadershipBulkResults
'''
if params is not None and not isinstance(params, (bytes, str, ... |
ClaimLeadership makes a leadership claim with the given parameters.
params : typing.Sequence[~ClaimLeadershipParams]
Returns -> ClaimLeadershipBulkResults
| ClaimLeadership makes a leadership claim with the given parameters. | [
"ClaimLeadership",
"makes",
"a",
"leadership",
"claim",
"with",
"the",
"given",
"parameters",
"."
] | async def ClaimLeadership(self, params=None):
if params is not None and not isinstance(params, (bytes, str, list)):
raise Exception("Expected params to be a Sequence, received: {}".format(type(params)))
_params = dict()
msg = dict(type='LeadershipService',
request=... | [
"async",
"def",
"ClaimLeadership",
"(",
"self",
",",
"params",
"=",
"None",
")",
":",
"if",
"params",
"is",
"not",
"None",
"and",
"not",
"isinstance",
"(",
"params",
",",
"(",
"bytes",
",",
"str",
",",
"list",
")",
")",
":",
"raise",
"Exception",
"("... | ClaimLeadership makes a leadership claim with the given parameters. | [
"ClaimLeadership",
"makes",
"a",
"leadership",
"claim",
"with",
"the",
"given",
"parameters",
"."
] | [
"'''\n ClaimLeadership makes a leadership claim with the given parameters.\n\n params : typing.Sequence[~ClaimLeadershipParams]\n Returns -> ClaimLeadershipBulkResults\n '''",
"# map input types to rpc msg"
] | [
{
"param": "self",
"type": null
},
{
"param": "params",
"type": null
}
] | {
"returns": [],
"raises": [],
"params": [
{
"identifier": "self",
"type": null,
"docstring": null,
"docstring_tokens": [],
"default": null,
"is_optional": null
},
{
"identifier": "params",
"type": null,
"docstring": null,
"docstring_tokens":... |
f697638db76b9fc35cd762f0cbbb058c9ee6f5b1 | sed-i/python-libjuju | juju/client/_client2.py | [
"Apache-2.0"
] | Python | GetMeterStatus | <not_specific> | async def GetMeterStatus(self, entities=None):
'''
GetMeterStatus returns meter status information for each unit.
entities : typing.Sequence[~Entity]
Returns -> MeterStatusResults
'''
if entities is not None and not isinstance(entities, (bytes, str, list)):
r... |
GetMeterStatus returns meter status information for each unit.
entities : typing.Sequence[~Entity]
Returns -> MeterStatusResults
| GetMeterStatus returns meter status information for each unit.
entities : typing.Sequence[~Entity]
Returns -> MeterStatusResults | [
"GetMeterStatus",
"returns",
"meter",
"status",
"information",
"for",
"each",
"unit",
".",
"entities",
":",
"typing",
".",
"Sequence",
"[",
"~Entity",
"]",
"Returns",
"-",
">",
"MeterStatusResults"
] | async def GetMeterStatus(self, entities=None):
if entities is not None and not isinstance(entities, (bytes, str, list)):
raise Exception("Expected entities to be a Sequence, received: {}".format(type(entities)))
_params = dict()
msg = dict(type='MeterStatus',
reque... | [
"async",
"def",
"GetMeterStatus",
"(",
"self",
",",
"entities",
"=",
"None",
")",
":",
"if",
"entities",
"is",
"not",
"None",
"and",
"not",
"isinstance",
"(",
"entities",
",",
"(",
"bytes",
",",
"str",
",",
"list",
")",
")",
":",
"raise",
"Exception",
... | GetMeterStatus returns meter status information for each unit. | [
"GetMeterStatus",
"returns",
"meter",
"status",
"information",
"for",
"each",
"unit",
"."
] | [
"'''\n GetMeterStatus returns meter status information for each unit.\n\n entities : typing.Sequence[~Entity]\n Returns -> MeterStatusResults\n '''",
"# map input types to rpc msg"
] | [
{
"param": "self",
"type": null
},
{
"param": "entities",
"type": null
}
] | {
"returns": [],
"raises": [],
"params": [
{
"identifier": "self",
"type": null,
"docstring": null,
"docstring_tokens": [],
"default": null,
"is_optional": null
},
{
"identifier": "entities",
"type": null,
"docstring": null,
"docstring_tokens... |
f697638db76b9fc35cd762f0cbbb058c9ee6f5b1 | sed-i/python-libjuju | juju/client/_client2.py | [
"Apache-2.0"
] | Python | SetState | <not_specific> | async def SetState(self, args=None):
'''
SetState sets the state persisted by the charm running in this unit
and the state internal to the uniter for this unit.
args : typing.Sequence[~SetUnitStateArg]
Returns -> ErrorResults
'''
if args is not None and not isins... |
SetState sets the state persisted by the charm running in this unit
and the state internal to the uniter for this unit.
args : typing.Sequence[~SetUnitStateArg]
Returns -> ErrorResults
| SetState sets the state persisted by the charm running in this unit
and the state internal to the uniter for this unit.
| [
"SetState",
"sets",
"the",
"state",
"persisted",
"by",
"the",
"charm",
"running",
"in",
"this",
"unit",
"and",
"the",
"state",
"internal",
"to",
"the",
"uniter",
"for",
"this",
"unit",
"."
] | async def SetState(self, args=None):
if args is not None and not isinstance(args, (bytes, str, list)):
raise Exception("Expected args to be a Sequence, received: {}".format(type(args)))
_params = dict()
msg = dict(type='MeterStatus',
request='SetState',
... | [
"async",
"def",
"SetState",
"(",
"self",
",",
"args",
"=",
"None",
")",
":",
"if",
"args",
"is",
"not",
"None",
"and",
"not",
"isinstance",
"(",
"args",
",",
"(",
"bytes",
",",
"str",
",",
"list",
")",
")",
":",
"raise",
"Exception",
"(",
"\"Expect... | SetState sets the state persisted by the charm running in this unit
and the state internal to the uniter for this unit. | [
"SetState",
"sets",
"the",
"state",
"persisted",
"by",
"the",
"charm",
"running",
"in",
"this",
"unit",
"and",
"the",
"state",
"internal",
"to",
"the",
"uniter",
"for",
"this",
"unit",
"."
] | [
"'''\n SetState sets the state persisted by the charm running in this unit\n and the state internal to the uniter for this unit.\n\n args : typing.Sequence[~SetUnitStateArg]\n Returns -> ErrorResults\n '''",
"# map input types to rpc msg"
] | [
{
"param": "self",
"type": null
},
{
"param": "args",
"type": null
}
] | {
"returns": [],
"raises": [],
"params": [
{
"identifier": "self",
"type": null,
"docstring": null,
"docstring_tokens": [],
"default": null,
"is_optional": null
},
{
"identifier": "args",
"type": null,
"docstring": null,
"docstring_tokens": [... |
f697638db76b9fc35cd762f0cbbb058c9ee6f5b1 | sed-i/python-libjuju | juju/client/_client2.py | [
"Apache-2.0"
] | Python | State | <not_specific> | async def State(self, entities=None):
'''
State returns the state persisted by the charm running in this unit
and the state internal to the uniter for this unit.
entities : typing.Sequence[~Entity]
Returns -> UnitStateResults
'''
if entities is not None and not i... |
State returns the state persisted by the charm running in this unit
and the state internal to the uniter for this unit.
entities : typing.Sequence[~Entity]
Returns -> UnitStateResults
| State returns the state persisted by the charm running in this unit
and the state internal to the uniter for this unit.
entities : typing.Sequence[~Entity]
Returns -> UnitStateResults | [
"State",
"returns",
"the",
"state",
"persisted",
"by",
"the",
"charm",
"running",
"in",
"this",
"unit",
"and",
"the",
"state",
"internal",
"to",
"the",
"uniter",
"for",
"this",
"unit",
".",
"entities",
":",
"typing",
".",
"Sequence",
"[",
"~Entity",
"]",
... | async def State(self, entities=None):
if entities is not None and not isinstance(entities, (bytes, str, list)):
raise Exception("Expected entities to be a Sequence, received: {}".format(type(entities)))
_params = dict()
msg = dict(type='MeterStatus',
request='State... | [
"async",
"def",
"State",
"(",
"self",
",",
"entities",
"=",
"None",
")",
":",
"if",
"entities",
"is",
"not",
"None",
"and",
"not",
"isinstance",
"(",
"entities",
",",
"(",
"bytes",
",",
"str",
",",
"list",
")",
")",
":",
"raise",
"Exception",
"(",
... | State returns the state persisted by the charm running in this unit
and the state internal to the uniter for this unit. | [
"State",
"returns",
"the",
"state",
"persisted",
"by",
"the",
"charm",
"running",
"in",
"this",
"unit",
"and",
"the",
"state",
"internal",
"to",
"the",
"uniter",
"for",
"this",
"unit",
"."
] | [
"'''\n State returns the state persisted by the charm running in this unit\n and the state internal to the uniter for this unit.\n\n entities : typing.Sequence[~Entity]\n Returns -> UnitStateResults\n '''",
"# map input types to rpc msg"
] | [
{
"param": "self",
"type": null
},
{
"param": "entities",
"type": null
}
] | {
"returns": [],
"raises": [],
"params": [
{
"identifier": "self",
"type": null,
"docstring": null,
"docstring_tokens": [],
"default": null,
"is_optional": null
},
{
"identifier": "entities",
"type": null,
"docstring": null,
"docstring_tokens... |
f697638db76b9fc35cd762f0cbbb058c9ee6f5b1 | sed-i/python-libjuju | juju/client/_client2.py | [
"Apache-2.0"
] | Python | WatchMeterStatus | <not_specific> | async def WatchMeterStatus(self, entities=None):
'''
WatchMeterStatus returns a NotifyWatcher for observing changes
to each unit's meter status.
entities : typing.Sequence[~Entity]
Returns -> NotifyWatchResults
'''
if entities is not None and not isinstance(entit... |
WatchMeterStatus returns a NotifyWatcher for observing changes
to each unit's meter status.
entities : typing.Sequence[~Entity]
Returns -> NotifyWatchResults
| WatchMeterStatus returns a NotifyWatcher for observing changes
to each unit's meter status.
entities : typing.Sequence[~Entity]
Returns -> NotifyWatchResults | [
"WatchMeterStatus",
"returns",
"a",
"NotifyWatcher",
"for",
"observing",
"changes",
"to",
"each",
"unit",
"'",
"s",
"meter",
"status",
".",
"entities",
":",
"typing",
".",
"Sequence",
"[",
"~Entity",
"]",
"Returns",
"-",
">",
"NotifyWatchResults"
] | async def WatchMeterStatus(self, entities=None):
if entities is not None and not isinstance(entities, (bytes, str, list)):
raise Exception("Expected entities to be a Sequence, received: {}".format(type(entities)))
_params = dict()
msg = dict(type='MeterStatus',
req... | [
"async",
"def",
"WatchMeterStatus",
"(",
"self",
",",
"entities",
"=",
"None",
")",
":",
"if",
"entities",
"is",
"not",
"None",
"and",
"not",
"isinstance",
"(",
"entities",
",",
"(",
"bytes",
",",
"str",
",",
"list",
")",
")",
":",
"raise",
"Exception"... | WatchMeterStatus returns a NotifyWatcher for observing changes
to each unit's meter status. | [
"WatchMeterStatus",
"returns",
"a",
"NotifyWatcher",
"for",
"observing",
"changes",
"to",
"each",
"unit",
"'",
"s",
"meter",
"status",
"."
] | [
"'''\n WatchMeterStatus returns a NotifyWatcher for observing changes\n to each unit's meter status.\n\n entities : typing.Sequence[~Entity]\n Returns -> NotifyWatchResults\n '''",
"# map input types to rpc msg"
] | [
{
"param": "self",
"type": null
},
{
"param": "entities",
"type": null
}
] | {
"returns": [],
"raises": [],
"params": [
{
"identifier": "self",
"type": null,
"docstring": null,
"docstring_tokens": [],
"default": null,
"is_optional": null
},
{
"identifier": "entities",
"type": null,
"docstring": null,
"docstring_tokens... |
f697638db76b9fc35cd762f0cbbb058c9ee6f5b1 | sed-i/python-libjuju | juju/client/_client2.py | [
"Apache-2.0"
] | Python | GetMetrics | <not_specific> | async def GetMetrics(self, entities=None):
'''
GetMetrics returns all metrics stored by the state server.
entities : typing.Sequence[~Entity]
Returns -> MetricResults
'''
if entities is not None and not isinstance(entities, (bytes, str, list)):
raise Exceptio... |
GetMetrics returns all metrics stored by the state server.
entities : typing.Sequence[~Entity]
Returns -> MetricResults
| GetMetrics returns all metrics stored by the state server.
entities : typing.Sequence[~Entity]
Returns -> MetricResults | [
"GetMetrics",
"returns",
"all",
"metrics",
"stored",
"by",
"the",
"state",
"server",
".",
"entities",
":",
"typing",
".",
"Sequence",
"[",
"~Entity",
"]",
"Returns",
"-",
">",
"MetricResults"
] | async def GetMetrics(self, entities=None):
if entities is not None and not isinstance(entities, (bytes, str, list)):
raise Exception("Expected entities to be a Sequence, received: {}".format(type(entities)))
_params = dict()
msg = dict(type='MetricsDebug',
request=... | [
"async",
"def",
"GetMetrics",
"(",
"self",
",",
"entities",
"=",
"None",
")",
":",
"if",
"entities",
"is",
"not",
"None",
"and",
"not",
"isinstance",
"(",
"entities",
",",
"(",
"bytes",
",",
"str",
",",
"list",
")",
")",
":",
"raise",
"Exception",
"(... | GetMetrics returns all metrics stored by the state server. | [
"GetMetrics",
"returns",
"all",
"metrics",
"stored",
"by",
"the",
"state",
"server",
"."
] | [
"'''\n GetMetrics returns all metrics stored by the state server.\n\n entities : typing.Sequence[~Entity]\n Returns -> MetricResults\n '''",
"# map input types to rpc msg"
] | [
{
"param": "self",
"type": null
},
{
"param": "entities",
"type": null
}
] | {
"returns": [],
"raises": [],
"params": [
{
"identifier": "self",
"type": null,
"docstring": null,
"docstring_tokens": [],
"default": null,
"is_optional": null
},
{
"identifier": "entities",
"type": null,
"docstring": null,
"docstring_tokens... |
f697638db76b9fc35cd762f0cbbb058c9ee6f5b1 | sed-i/python-libjuju | juju/client/_client2.py | [
"Apache-2.0"
] | Python | SetMeterStatus | <not_specific> | async def SetMeterStatus(self, statues=None):
'''
SetMeterStatus sets meter statuses for entities.
statues : typing.Sequence[~MeterStatusParam]
Returns -> ErrorResults
'''
if statues is not None and not isinstance(statues, (bytes, str, list)):
raise Exception... |
SetMeterStatus sets meter statuses for entities.
statues : typing.Sequence[~MeterStatusParam]
Returns -> ErrorResults
| SetMeterStatus sets meter statuses for entities. | [
"SetMeterStatus",
"sets",
"meter",
"statuses",
"for",
"entities",
"."
] | async def SetMeterStatus(self, statues=None):
if statues is not None and not isinstance(statues, (bytes, str, list)):
raise Exception("Expected statues to be a Sequence, received: {}".format(type(statues)))
_params = dict()
msg = dict(type='MetricsDebug',
request='... | [
"async",
"def",
"SetMeterStatus",
"(",
"self",
",",
"statues",
"=",
"None",
")",
":",
"if",
"statues",
"is",
"not",
"None",
"and",
"not",
"isinstance",
"(",
"statues",
",",
"(",
"bytes",
",",
"str",
",",
"list",
")",
")",
":",
"raise",
"Exception",
"... | SetMeterStatus sets meter statuses for entities. | [
"SetMeterStatus",
"sets",
"meter",
"statuses",
"for",
"entities",
"."
] | [
"'''\n SetMeterStatus sets meter statuses for entities.\n\n statues : typing.Sequence[~MeterStatusParam]\n Returns -> ErrorResults\n '''",
"# map input types to rpc msg"
] | [
{
"param": "self",
"type": null
},
{
"param": "statues",
"type": null
}
] | {
"returns": [],
"raises": [],
"params": [
{
"identifier": "self",
"type": null,
"docstring": null,
"docstring_tokens": [],
"default": null,
"is_optional": null
},
{
"identifier": "statues",
"type": null,
"docstring": null,
"docstring_tokens"... |
f697638db76b9fc35cd762f0cbbb058c9ee6f5b1 | sed-i/python-libjuju | juju/client/_client2.py | [
"Apache-2.0"
] | Python | Export | <not_specific> | async def Export(self):
'''
Export serializes the model associated with the API connection.
Returns -> SerializedModel
'''
# map input types to rpc msg
_params = dict()
msg = dict(type='MigrationMaster',
request='Export',
v... |
Export serializes the model associated with the API connection.
Returns -> SerializedModel
| Export serializes the model associated with the API connection. | [
"Export",
"serializes",
"the",
"model",
"associated",
"with",
"the",
"API",
"connection",
"."
] | async def Export(self):
_params = dict()
msg = dict(type='MigrationMaster',
request='Export',
version=2,
params=_params)
reply = await self.rpc(msg)
return reply | [
"async",
"def",
"Export",
"(",
"self",
")",
":",
"_params",
"=",
"dict",
"(",
")",
"msg",
"=",
"dict",
"(",
"type",
"=",
"'MigrationMaster'",
",",
"request",
"=",
"'Export'",
",",
"version",
"=",
"2",
",",
"params",
"=",
"_params",
")",
"reply",
"=",... | Export serializes the model associated with the API connection. | [
"Export",
"serializes",
"the",
"model",
"associated",
"with",
"the",
"API",
"connection",
"."
] | [
"'''\n Export serializes the model associated with the API connection.\n\n\n Returns -> SerializedModel\n '''",
"# map input types to rpc msg"
] | [
{
"param": "self",
"type": null
}
] | {
"returns": [],
"raises": [],
"params": [
{
"identifier": "self",
"type": null,
"docstring": null,
"docstring_tokens": [],
"default": null,
"is_optional": null
}
],
"outlier_params": [],
"others": []
} |
f697638db76b9fc35cd762f0cbbb058c9ee6f5b1 | sed-i/python-libjuju | juju/client/_client2.py | [
"Apache-2.0"
] | Python | MigrationStatus | <not_specific> | async def MigrationStatus(self):
'''
MigrationStatus returns the details and progress of the latest
model migration.
Returns -> MasterMigrationStatus
'''
# map input types to rpc msg
_params = dict()
msg = dict(type='MigrationMaster',
... |
MigrationStatus returns the details and progress of the latest
model migration.
Returns -> MasterMigrationStatus
| MigrationStatus returns the details and progress of the latest
model migration.
| [
"MigrationStatus",
"returns",
"the",
"details",
"and",
"progress",
"of",
"the",
"latest",
"model",
"migration",
"."
] | async def MigrationStatus(self):
_params = dict()
msg = dict(type='MigrationMaster',
request='MigrationStatus',
version=2,
params=_params)
reply = await self.rpc(msg)
return reply | [
"async",
"def",
"MigrationStatus",
"(",
"self",
")",
":",
"_params",
"=",
"dict",
"(",
")",
"msg",
"=",
"dict",
"(",
"type",
"=",
"'MigrationMaster'",
",",
"request",
"=",
"'MigrationStatus'",
",",
"version",
"=",
"2",
",",
"params",
"=",
"_params",
")",... | MigrationStatus returns the details and progress of the latest
model migration. | [
"MigrationStatus",
"returns",
"the",
"details",
"and",
"progress",
"of",
"the",
"latest",
"model",
"migration",
"."
] | [
"'''\n MigrationStatus returns the details and progress of the latest\n model migration.\n\n\n Returns -> MasterMigrationStatus\n '''",
"# map input types to rpc msg"
] | [
{
"param": "self",
"type": null
}
] | {
"returns": [],
"raises": [],
"params": [
{
"identifier": "self",
"type": null,
"docstring": null,
"docstring_tokens": [],
"default": null,
"is_optional": null
}
],
"outlier_params": [],
"others": []
} |
f697638db76b9fc35cd762f0cbbb058c9ee6f5b1 | sed-i/python-libjuju | juju/client/_client2.py | [
"Apache-2.0"
] | Python | MinionReports | <not_specific> | async def MinionReports(self):
'''
MinionReports returns details of the reports made by migration
minions to the controller for the current migration phase.
Returns -> MinionReports
'''
# map input types to rpc msg
_params = dict()
msg = dict(type='Migr... |
MinionReports returns details of the reports made by migration
minions to the controller for the current migration phase.
Returns -> MinionReports
| MinionReports returns details of the reports made by migration
minions to the controller for the current migration phase.
| [
"MinionReports",
"returns",
"details",
"of",
"the",
"reports",
"made",
"by",
"migration",
"minions",
"to",
"the",
"controller",
"for",
"the",
"current",
"migration",
"phase",
"."
] | async def MinionReports(self):
_params = dict()
msg = dict(type='MigrationMaster',
request='MinionReports',
version=2,
params=_params)
reply = await self.rpc(msg)
return reply | [
"async",
"def",
"MinionReports",
"(",
"self",
")",
":",
"_params",
"=",
"dict",
"(",
")",
"msg",
"=",
"dict",
"(",
"type",
"=",
"'MigrationMaster'",
",",
"request",
"=",
"'MinionReports'",
",",
"version",
"=",
"2",
",",
"params",
"=",
"_params",
")",
"... | MinionReports returns details of the reports made by migration
minions to the controller for the current migration phase. | [
"MinionReports",
"returns",
"details",
"of",
"the",
"reports",
"made",
"by",
"migration",
"minions",
"to",
"the",
"controller",
"for",
"the",
"current",
"migration",
"phase",
"."
] | [
"'''\n MinionReports returns details of the reports made by migration\n minions to the controller for the current migration phase.\n\n\n Returns -> MinionReports\n '''",
"# map input types to rpc msg"
] | [
{
"param": "self",
"type": null
}
] | {
"returns": [],
"raises": [],
"params": [
{
"identifier": "self",
"type": null,
"docstring": null,
"docstring_tokens": [],
"default": null,
"is_optional": null
}
],
"outlier_params": [],
"others": []
} |
f697638db76b9fc35cd762f0cbbb058c9ee6f5b1 | sed-i/python-libjuju | juju/client/_client2.py | [
"Apache-2.0"
] | Python | ModelInfo | <not_specific> | async def ModelInfo(self):
'''
ModelInfo returns essential information about the model to be
migrated.
Returns -> MigrationModelInfo
'''
# map input types to rpc msg
_params = dict()
msg = dict(type='MigrationMaster',
request='ModelIn... |
ModelInfo returns essential information about the model to be
migrated.
Returns -> MigrationModelInfo
| ModelInfo returns essential information about the model to be
migrated.
| [
"ModelInfo",
"returns",
"essential",
"information",
"about",
"the",
"model",
"to",
"be",
"migrated",
"."
] | async def ModelInfo(self):
_params = dict()
msg = dict(type='MigrationMaster',
request='ModelInfo',
version=2,
params=_params)
reply = await self.rpc(msg)
return reply | [
"async",
"def",
"ModelInfo",
"(",
"self",
")",
":",
"_params",
"=",
"dict",
"(",
")",
"msg",
"=",
"dict",
"(",
"type",
"=",
"'MigrationMaster'",
",",
"request",
"=",
"'ModelInfo'",
",",
"version",
"=",
"2",
",",
"params",
"=",
"_params",
")",
"reply",
... | ModelInfo returns essential information about the model to be
migrated. | [
"ModelInfo",
"returns",
"essential",
"information",
"about",
"the",
"model",
"to",
"be",
"migrated",
"."
] | [
"'''\n ModelInfo returns essential information about the model to be\n migrated.\n\n\n Returns -> MigrationModelInfo\n '''",
"# map input types to rpc msg"
] | [
{
"param": "self",
"type": null
}
] | {
"returns": [],
"raises": [],
"params": [
{
"identifier": "self",
"type": null,
"docstring": null,
"docstring_tokens": [],
"default": null,
"is_optional": null
}
],
"outlier_params": [],
"others": []
} |
f697638db76b9fc35cd762f0cbbb058c9ee6f5b1 | sed-i/python-libjuju | juju/client/_client2.py | [
"Apache-2.0"
] | Python | ProcessRelations | <not_specific> | async def ProcessRelations(self, controller_alias=None):
'''
ProcessRelations processes any relations that need updating after an export.
This should help fix any remoteApplications that have been migrated.
controller_alias : str
Returns -> None
'''
if controller... |
ProcessRelations processes any relations that need updating after an export.
This should help fix any remoteApplications that have been migrated.
controller_alias : str
Returns -> None
| ProcessRelations processes any relations that need updating after an export.
This should help fix any remoteApplications that have been migrated.
controller_alias : str
Returns -> None | [
"ProcessRelations",
"processes",
"any",
"relations",
"that",
"need",
"updating",
"after",
"an",
"export",
".",
"This",
"should",
"help",
"fix",
"any",
"remoteApplications",
"that",
"have",
"been",
"migrated",
".",
"controller_alias",
":",
"str",
"Returns",
"-",
... | async def ProcessRelations(self, controller_alias=None):
if controller_alias is not None and not isinstance(controller_alias, (bytes, str)):
raise Exception("Expected controller_alias to be a str, received: {}".format(type(controller_alias)))
_params = dict()
msg = dict(type='Migrati... | [
"async",
"def",
"ProcessRelations",
"(",
"self",
",",
"controller_alias",
"=",
"None",
")",
":",
"if",
"controller_alias",
"is",
"not",
"None",
"and",
"not",
"isinstance",
"(",
"controller_alias",
",",
"(",
"bytes",
",",
"str",
")",
")",
":",
"raise",
"Exc... | ProcessRelations processes any relations that need updating after an export. | [
"ProcessRelations",
"processes",
"any",
"relations",
"that",
"need",
"updating",
"after",
"an",
"export",
"."
] | [
"'''\n ProcessRelations processes any relations that need updating after an export.\n This should help fix any remoteApplications that have been migrated.\n\n controller_alias : str\n Returns -> None\n '''",
"# map input types to rpc msg"
] | [
{
"param": "self",
"type": null
},
{
"param": "controller_alias",
"type": null
}
] | {
"returns": [],
"raises": [],
"params": [
{
"identifier": "self",
"type": null,
"docstring": null,
"docstring_tokens": [],
"default": null,
"is_optional": null
},
{
"identifier": "controller_alias",
"type": null,
"docstring": null,
"docstrin... |
f697638db76b9fc35cd762f0cbbb058c9ee6f5b1 | sed-i/python-libjuju | juju/client/_client2.py | [
"Apache-2.0"
] | Python | Reap | <not_specific> | async def Reap(self):
'''
Reap removes all documents for the model associated with the API
connection.
Returns -> None
'''
# map input types to rpc msg
_params = dict()
msg = dict(type='MigrationMaster',
request='Reap',
... |
Reap removes all documents for the model associated with the API
connection.
Returns -> None
| Reap removes all documents for the model associated with the API
connection.
> None | [
"Reap",
"removes",
"all",
"documents",
"for",
"the",
"model",
"associated",
"with",
"the",
"API",
"connection",
".",
">",
"None"
] | async def Reap(self):
_params = dict()
msg = dict(type='MigrationMaster',
request='Reap',
version=2,
params=_params)
reply = await self.rpc(msg)
return reply | [
"async",
"def",
"Reap",
"(",
"self",
")",
":",
"_params",
"=",
"dict",
"(",
")",
"msg",
"=",
"dict",
"(",
"type",
"=",
"'MigrationMaster'",
",",
"request",
"=",
"'Reap'",
",",
"version",
"=",
"2",
",",
"params",
"=",
"_params",
")",
"reply",
"=",
"... | Reap removes all documents for the model associated with the API
connection. | [
"Reap",
"removes",
"all",
"documents",
"for",
"the",
"model",
"associated",
"with",
"the",
"API",
"connection",
"."
] | [
"'''\n Reap removes all documents for the model associated with the API\n connection.\n\n\n Returns -> None\n '''",
"# map input types to rpc msg"
] | [
{
"param": "self",
"type": null
}
] | {
"returns": [],
"raises": [],
"params": [
{
"identifier": "self",
"type": null,
"docstring": null,
"docstring_tokens": [],
"default": null,
"is_optional": null
}
],
"outlier_params": [],
"others": []
} |
f697638db76b9fc35cd762f0cbbb058c9ee6f5b1 | sed-i/python-libjuju | juju/client/_client2.py | [
"Apache-2.0"
] | Python | SetPhase | <not_specific> | async def SetPhase(self, phase=None):
'''
SetPhase sets the phase of the active model migration. The provided
phase must be a valid phase value, for example QUIESCE" or
"ABORT". See the core/migration package for the complete list.
phase : str
Returns -> None
'''... |
SetPhase sets the phase of the active model migration. The provided
phase must be a valid phase value, for example QUIESCE" or
"ABORT". See the core/migration package for the complete list.
phase : str
Returns -> None
| SetPhase sets the phase of the active model migration. The provided
phase must be a valid phase value, for example QUIESCE" or
"ABORT". See the core/migration package for the complete list.
phase : str
Returns -> None | [
"SetPhase",
"sets",
"the",
"phase",
"of",
"the",
"active",
"model",
"migration",
".",
"The",
"provided",
"phase",
"must",
"be",
"a",
"valid",
"phase",
"value",
"for",
"example",
"QUIESCE",
"\"",
"or",
"\"",
"ABORT",
"\"",
".",
"See",
"the",
"core",
"/",
... | async def SetPhase(self, phase=None):
if phase is not None and not isinstance(phase, (bytes, str)):
raise Exception("Expected phase to be a str, received: {}".format(type(phase)))
_params = dict()
msg = dict(type='MigrationMaster',
request='SetPhase',
... | [
"async",
"def",
"SetPhase",
"(",
"self",
",",
"phase",
"=",
"None",
")",
":",
"if",
"phase",
"is",
"not",
"None",
"and",
"not",
"isinstance",
"(",
"phase",
",",
"(",
"bytes",
",",
"str",
")",
")",
":",
"raise",
"Exception",
"(",
"\"Expected phase to be... | SetPhase sets the phase of the active model migration. | [
"SetPhase",
"sets",
"the",
"phase",
"of",
"the",
"active",
"model",
"migration",
"."
] | [
"'''\n SetPhase sets the phase of the active model migration. The provided\n phase must be a valid phase value, for example QUIESCE\" or\n \"ABORT\". See the core/migration package for the complete list.\n\n phase : str\n Returns -> None\n '''",
"# map input types to rpc ... | [
{
"param": "self",
"type": null
},
{
"param": "phase",
"type": null
}
] | {
"returns": [],
"raises": [],
"params": [
{
"identifier": "self",
"type": null,
"docstring": null,
"docstring_tokens": [],
"default": null,
"is_optional": null
},
{
"identifier": "phase",
"type": null,
"docstring": null,
"docstring_tokens": ... |
f697638db76b9fc35cd762f0cbbb058c9ee6f5b1 | sed-i/python-libjuju | juju/client/_client2.py | [
"Apache-2.0"
] | Python | SetStatusMessage | <not_specific> | async def SetStatusMessage(self, message=None):
'''
SetStatusMessage sets a human readable status message containing
information about the migration's progress. This will be shown in
status output shown to the end user.
message : str
Returns -> None
'''
i... |
SetStatusMessage sets a human readable status message containing
information about the migration's progress. This will be shown in
status output shown to the end user.
message : str
Returns -> None
| SetStatusMessage sets a human readable status message containing
information about the migration's progress. This will be shown in
status output shown to the end user.
message : str
Returns -> None | [
"SetStatusMessage",
"sets",
"a",
"human",
"readable",
"status",
"message",
"containing",
"information",
"about",
"the",
"migration",
"'",
"s",
"progress",
".",
"This",
"will",
"be",
"shown",
"in",
"status",
"output",
"shown",
"to",
"the",
"end",
"user",
".",
... | async def SetStatusMessage(self, message=None):
if message is not None and not isinstance(message, (bytes, str)):
raise Exception("Expected message to be a str, received: {}".format(type(message)))
_params = dict()
msg = dict(type='MigrationMaster',
request='SetSta... | [
"async",
"def",
"SetStatusMessage",
"(",
"self",
",",
"message",
"=",
"None",
")",
":",
"if",
"message",
"is",
"not",
"None",
"and",
"not",
"isinstance",
"(",
"message",
",",
"(",
"bytes",
",",
"str",
")",
")",
":",
"raise",
"Exception",
"(",
"\"Expect... | SetStatusMessage sets a human readable status message containing
information about the migration's progress. | [
"SetStatusMessage",
"sets",
"a",
"human",
"readable",
"status",
"message",
"containing",
"information",
"about",
"the",
"migration",
"'",
"s",
"progress",
"."
] | [
"'''\n SetStatusMessage sets a human readable status message containing\n information about the migration's progress. This will be shown in\n status output shown to the end user.\n\n message : str\n Returns -> None\n '''",
"# map input types to rpc msg"
] | [
{
"param": "self",
"type": null
},
{
"param": "message",
"type": null
}
] | {
"returns": [],
"raises": [],
"params": [
{
"identifier": "self",
"type": null,
"docstring": null,
"docstring_tokens": [],
"default": null,
"is_optional": null
},
{
"identifier": "message",
"type": null,
"docstring": null,
"docstring_tokens"... |
f697638db76b9fc35cd762f0cbbb058c9ee6f5b1 | sed-i/python-libjuju | juju/client/_client2.py | [
"Apache-2.0"
] | Python | Watch | <not_specific> | async def Watch(self):
'''
Watch starts watching for an active migration for the model
associated with the API connection. The returned id should be used
with the NotifyWatcher facade to receive events.
Returns -> NotifyWatchResult
'''
# map input types to rpc ... |
Watch starts watching for an active migration for the model
associated with the API connection. The returned id should be used
with the NotifyWatcher facade to receive events.
Returns -> NotifyWatchResult
| Watch starts watching for an active migration for the model
associated with the API connection. The returned id should be used
with the NotifyWatcher facade to receive events.
| [
"Watch",
"starts",
"watching",
"for",
"an",
"active",
"migration",
"for",
"the",
"model",
"associated",
"with",
"the",
"API",
"connection",
".",
"The",
"returned",
"id",
"should",
"be",
"used",
"with",
"the",
"NotifyWatcher",
"facade",
"to",
"receive",
"events... | async def Watch(self):
_params = dict()
msg = dict(type='MigrationMaster',
request='Watch',
version=2,
params=_params)
reply = await self.rpc(msg)
return reply | [
"async",
"def",
"Watch",
"(",
"self",
")",
":",
"_params",
"=",
"dict",
"(",
")",
"msg",
"=",
"dict",
"(",
"type",
"=",
"'MigrationMaster'",
",",
"request",
"=",
"'Watch'",
",",
"version",
"=",
"2",
",",
"params",
"=",
"_params",
")",
"reply",
"=",
... | Watch starts watching for an active migration for the model
associated with the API connection. | [
"Watch",
"starts",
"watching",
"for",
"an",
"active",
"migration",
"for",
"the",
"model",
"associated",
"with",
"the",
"API",
"connection",
"."
] | [
"'''\n Watch starts watching for an active migration for the model\n associated with the API connection. The returned id should be used\n with the NotifyWatcher facade to receive events.\n\n\n Returns -> NotifyWatchResult\n '''",
"# map input types to rpc msg"
] | [
{
"param": "self",
"type": null
}
] | {
"returns": [],
"raises": [],
"params": [
{
"identifier": "self",
"type": null,
"docstring": null,
"docstring_tokens": [],
"default": null,
"is_optional": null
}
],
"outlier_params": [],
"others": []
} |
f697638db76b9fc35cd762f0cbbb058c9ee6f5b1 | sed-i/python-libjuju | juju/client/_client2.py | [
"Apache-2.0"
] | Python | WatchMinionReports | <not_specific> | async def WatchMinionReports(self):
'''
WatchMinionReports sets up a watcher which reports when a report
for a migration minion has arrived.
Returns -> NotifyWatchResult
'''
# map input types to rpc msg
_params = dict()
msg = dict(type='MigrationMaster'... |
WatchMinionReports sets up a watcher which reports when a report
for a migration minion has arrived.
Returns -> NotifyWatchResult
| WatchMinionReports sets up a watcher which reports when a report
for a migration minion has arrived.
| [
"WatchMinionReports",
"sets",
"up",
"a",
"watcher",
"which",
"reports",
"when",
"a",
"report",
"for",
"a",
"migration",
"minion",
"has",
"arrived",
"."
] | async def WatchMinionReports(self):
_params = dict()
msg = dict(type='MigrationMaster',
request='WatchMinionReports',
version=2,
params=_params)
reply = await self.rpc(msg)
return reply | [
"async",
"def",
"WatchMinionReports",
"(",
"self",
")",
":",
"_params",
"=",
"dict",
"(",
")",
"msg",
"=",
"dict",
"(",
"type",
"=",
"'MigrationMaster'",
",",
"request",
"=",
"'WatchMinionReports'",
",",
"version",
"=",
"2",
",",
"params",
"=",
"_params",
... | WatchMinionReports sets up a watcher which reports when a report
for a migration minion has arrived. | [
"WatchMinionReports",
"sets",
"up",
"a",
"watcher",
"which",
"reports",
"when",
"a",
"report",
"for",
"a",
"migration",
"minion",
"has",
"arrived",
"."
] | [
"'''\n WatchMinionReports sets up a watcher which reports when a report\n for a migration minion has arrived.\n\n\n Returns -> NotifyWatchResult\n '''",
"# map input types to rpc msg"
] | [
{
"param": "self",
"type": null
}
] | {
"returns": [],
"raises": [],
"params": [
{
"identifier": "self",
"type": null,
"docstring": null,
"docstring_tokens": [],
"default": null,
"is_optional": null
}
],
"outlier_params": [],
"others": []
} |
f697638db76b9fc35cd762f0cbbb058c9ee6f5b1 | sed-i/python-libjuju | juju/client/_client2.py | [
"Apache-2.0"
] | Python | ModelGet | <not_specific> | async def ModelGet(self):
'''
ModelGet implements the server-side part of the
model-config CLI command.
Returns -> ModelConfigResults
'''
# map input types to rpc msg
_params = dict()
msg = dict(type='ModelConfig',
request='ModelGet',... |
ModelGet implements the server-side part of the
model-config CLI command.
Returns -> ModelConfigResults
| ModelGet implements the server-side part of the
model-config CLI command.
| [
"ModelGet",
"implements",
"the",
"server",
"-",
"side",
"part",
"of",
"the",
"model",
"-",
"config",
"CLI",
"command",
"."
] | async def ModelGet(self):
_params = dict()
msg = dict(type='ModelConfig',
request='ModelGet',
version=2,
params=_params)
reply = await self.rpc(msg)
return reply | [
"async",
"def",
"ModelGet",
"(",
"self",
")",
":",
"_params",
"=",
"dict",
"(",
")",
"msg",
"=",
"dict",
"(",
"type",
"=",
"'ModelConfig'",
",",
"request",
"=",
"'ModelGet'",
",",
"version",
"=",
"2",
",",
"params",
"=",
"_params",
")",
"reply",
"=",... | ModelGet implements the server-side part of the
model-config CLI command. | [
"ModelGet",
"implements",
"the",
"server",
"-",
"side",
"part",
"of",
"the",
"model",
"-",
"config",
"CLI",
"command",
"."
] | [
"'''\n ModelGet implements the server-side part of the\n model-config CLI command.\n\n\n Returns -> ModelConfigResults\n '''",
"# map input types to rpc msg"
] | [
{
"param": "self",
"type": null
}
] | {
"returns": [],
"raises": [],
"params": [
{
"identifier": "self",
"type": null,
"docstring": null,
"docstring_tokens": [],
"default": null,
"is_optional": null
}
],
"outlier_params": [],
"others": []
} |
f697638db76b9fc35cd762f0cbbb058c9ee6f5b1 | sed-i/python-libjuju | juju/client/_client2.py | [
"Apache-2.0"
] | Python | ModelSet | <not_specific> | async def ModelSet(self, config=None):
'''
ModelSet implements the server-side part of the
set-model-config CLI command.
config : typing.Mapping[str, typing.Any]
Returns -> None
'''
if config is not None and not isinstance(config, dict):
raise Excepti... |
ModelSet implements the server-side part of the
set-model-config CLI command.
config : typing.Mapping[str, typing.Any]
Returns -> None
| ModelSet implements the server-side part of the
set-model-config CLI command.
| [
"ModelSet",
"implements",
"the",
"server",
"-",
"side",
"part",
"of",
"the",
"set",
"-",
"model",
"-",
"config",
"CLI",
"command",
"."
] | async def ModelSet(self, config=None):
if config is not None and not isinstance(config, dict):
raise Exception("Expected config to be a Mapping, received: {}".format(type(config)))
_params = dict()
msg = dict(type='ModelConfig',
request='ModelSet',
... | [
"async",
"def",
"ModelSet",
"(",
"self",
",",
"config",
"=",
"None",
")",
":",
"if",
"config",
"is",
"not",
"None",
"and",
"not",
"isinstance",
"(",
"config",
",",
"dict",
")",
":",
"raise",
"Exception",
"(",
"\"Expected config to be a Mapping, received: {}\""... | ModelSet implements the server-side part of the
set-model-config CLI command. | [
"ModelSet",
"implements",
"the",
"server",
"-",
"side",
"part",
"of",
"the",
"set",
"-",
"model",
"-",
"config",
"CLI",
"command",
"."
] | [
"'''\n ModelSet implements the server-side part of the\n set-model-config CLI command.\n\n config : typing.Mapping[str, typing.Any]\n Returns -> None\n '''",
"# map input types to rpc msg"
] | [
{
"param": "self",
"type": null
},
{
"param": "config",
"type": null
}
] | {
"returns": [],
"raises": [],
"params": [
{
"identifier": "self",
"type": null,
"docstring": null,
"docstring_tokens": [],
"default": null,
"is_optional": null
},
{
"identifier": "config",
"type": null,
"docstring": null,
"docstring_tokens":... |
f697638db76b9fc35cd762f0cbbb058c9ee6f5b1 | sed-i/python-libjuju | juju/client/_client2.py | [
"Apache-2.0"
] | Python | SLALevel | <not_specific> | async def SLALevel(self):
'''
SLALevel returns the current sla level for the model.
Returns -> StringResult
'''
# map input types to rpc msg
_params = dict()
msg = dict(type='ModelConfig',
request='SLALevel',
version=2,
... |
SLALevel returns the current sla level for the model.
Returns -> StringResult
| SLALevel returns the current sla level for the model. | [
"SLALevel",
"returns",
"the",
"current",
"sla",
"level",
"for",
"the",
"model",
"."
] | async def SLALevel(self):
_params = dict()
msg = dict(type='ModelConfig',
request='SLALevel',
version=2,
params=_params)
reply = await self.rpc(msg)
return reply | [
"async",
"def",
"SLALevel",
"(",
"self",
")",
":",
"_params",
"=",
"dict",
"(",
")",
"msg",
"=",
"dict",
"(",
"type",
"=",
"'ModelConfig'",
",",
"request",
"=",
"'SLALevel'",
",",
"version",
"=",
"2",
",",
"params",
"=",
"_params",
")",
"reply",
"=",... | SLALevel returns the current sla level for the model. | [
"SLALevel",
"returns",
"the",
"current",
"sla",
"level",
"for",
"the",
"model",
"."
] | [
"'''\n SLALevel returns the current sla level for the model.\n\n\n Returns -> StringResult\n '''",
"# map input types to rpc msg"
] | [
{
"param": "self",
"type": null
}
] | {
"returns": [],
"raises": [],
"params": [
{
"identifier": "self",
"type": null,
"docstring": null,
"docstring_tokens": [],
"default": null,
"is_optional": null
}
],
"outlier_params": [],
"others": []
} |
f697638db76b9fc35cd762f0cbbb058c9ee6f5b1 | sed-i/python-libjuju | juju/client/_client2.py | [
"Apache-2.0"
] | Python | Sequences | <not_specific> | async def Sequences(self):
'''
Sequences returns the model's sequence names and next values.
Returns -> ModelSequencesResult
'''
# map input types to rpc msg
_params = dict()
msg = dict(type='ModelConfig',
request='Sequences',
... |
Sequences returns the model's sequence names and next values.
Returns -> ModelSequencesResult
| Sequences returns the model's sequence names and next values. | [
"Sequences",
"returns",
"the",
"model",
"'",
"s",
"sequence",
"names",
"and",
"next",
"values",
"."
] | async def Sequences(self):
_params = dict()
msg = dict(type='ModelConfig',
request='Sequences',
version=2,
params=_params)
reply = await self.rpc(msg)
return reply | [
"async",
"def",
"Sequences",
"(",
"self",
")",
":",
"_params",
"=",
"dict",
"(",
")",
"msg",
"=",
"dict",
"(",
"type",
"=",
"'ModelConfig'",
",",
"request",
"=",
"'Sequences'",
",",
"version",
"=",
"2",
",",
"params",
"=",
"_params",
")",
"reply",
"=... | Sequences returns the model's sequence names and next values. | [
"Sequences",
"returns",
"the",
"model",
"'",
"s",
"sequence",
"names",
"and",
"next",
"values",
"."
] | [
"'''\n Sequences returns the model's sequence names and next values.\n\n\n Returns -> ModelSequencesResult\n '''",
"# map input types to rpc msg"
] | [
{
"param": "self",
"type": null
}
] | {
"returns": [],
"raises": [],
"params": [
{
"identifier": "self",
"type": null,
"docstring": null,
"docstring_tokens": [],
"default": null,
"is_optional": null
}
],
"outlier_params": [],
"others": []
} |
f697638db76b9fc35cd762f0cbbb058c9ee6f5b1 | sed-i/python-libjuju | juju/client/_client2.py | [
"Apache-2.0"
] | Python | ProxyConfig | <not_specific> | async def ProxyConfig(self, entities=None):
'''
ProxyConfig returns the proxy settings for the current model.
entities : typing.Sequence[~Entity]
Returns -> ProxyConfigResults
'''
if entities is not None and not isinstance(entities, (bytes, str, list)):
raise... |
ProxyConfig returns the proxy settings for the current model.
entities : typing.Sequence[~Entity]
Returns -> ProxyConfigResults
| ProxyConfig returns the proxy settings for the current model.
entities : typing.Sequence[~Entity]
Returns -> ProxyConfigResults | [
"ProxyConfig",
"returns",
"the",
"proxy",
"settings",
"for",
"the",
"current",
"model",
".",
"entities",
":",
"typing",
".",
"Sequence",
"[",
"~Entity",
"]",
"Returns",
"-",
">",
"ProxyConfigResults"
] | async def ProxyConfig(self, entities=None):
if entities is not None and not isinstance(entities, (bytes, str, list)):
raise Exception("Expected entities to be a Sequence, received: {}".format(type(entities)))
_params = dict()
msg = dict(type='ProxyUpdater',
request... | [
"async",
"def",
"ProxyConfig",
"(",
"self",
",",
"entities",
"=",
"None",
")",
":",
"if",
"entities",
"is",
"not",
"None",
"and",
"not",
"isinstance",
"(",
"entities",
",",
"(",
"bytes",
",",
"str",
",",
"list",
")",
")",
":",
"raise",
"Exception",
"... | ProxyConfig returns the proxy settings for the current model. | [
"ProxyConfig",
"returns",
"the",
"proxy",
"settings",
"for",
"the",
"current",
"model",
"."
] | [
"'''\n ProxyConfig returns the proxy settings for the current model.\n\n entities : typing.Sequence[~Entity]\n Returns -> ProxyConfigResults\n '''",
"# map input types to rpc msg"
] | [
{
"param": "self",
"type": null
},
{
"param": "entities",
"type": null
}
] | {
"returns": [],
"raises": [],
"params": [
{
"identifier": "self",
"type": null,
"docstring": null,
"docstring_tokens": [],
"default": null,
"is_optional": null
},
{
"identifier": "entities",
"type": null,
"docstring": null,
"docstring_tokens... |
f697638db76b9fc35cd762f0cbbb058c9ee6f5b1 | sed-i/python-libjuju | juju/client/_client2.py | [
"Apache-2.0"
] | Python | WatchForProxyConfigAndAPIHostPortChanges | <not_specific> | async def WatchForProxyConfigAndAPIHostPortChanges(self, entities=None):
'''
WatchForProxyConfigAndAPIHostPortChanges watches for cleanups to be perfomed in state
entities : typing.Sequence[~Entity]
Returns -> NotifyWatchResults
'''
if entities is not None and not isinst... |
WatchForProxyConfigAndAPIHostPortChanges watches for cleanups to be perfomed in state
entities : typing.Sequence[~Entity]
Returns -> NotifyWatchResults
| WatchForProxyConfigAndAPIHostPortChanges watches for cleanups to be perfomed in state
entities : typing.Sequence[~Entity]
Returns -> NotifyWatchResults | [
"WatchForProxyConfigAndAPIHostPortChanges",
"watches",
"for",
"cleanups",
"to",
"be",
"perfomed",
"in",
"state",
"entities",
":",
"typing",
".",
"Sequence",
"[",
"~Entity",
"]",
"Returns",
"-",
">",
"NotifyWatchResults"
] | async def WatchForProxyConfigAndAPIHostPortChanges(self, entities=None):
if entities is not None and not isinstance(entities, (bytes, str, list)):
raise Exception("Expected entities to be a Sequence, received: {}".format(type(entities)))
_params = dict()
msg = dict(type='ProxyUpdater... | [
"async",
"def",
"WatchForProxyConfigAndAPIHostPortChanges",
"(",
"self",
",",
"entities",
"=",
"None",
")",
":",
"if",
"entities",
"is",
"not",
"None",
"and",
"not",
"isinstance",
"(",
"entities",
",",
"(",
"bytes",
",",
"str",
",",
"list",
")",
")",
":",
... | WatchForProxyConfigAndAPIHostPortChanges watches for cleanups to be perfomed in state
entities : typing.Sequence[~Entity]
Returns -> NotifyWatchResults | [
"WatchForProxyConfigAndAPIHostPortChanges",
"watches",
"for",
"cleanups",
"to",
"be",
"perfomed",
"in",
"state",
"entities",
":",
"typing",
".",
"Sequence",
"[",
"~Entity",
"]",
"Returns",
"-",
">",
"NotifyWatchResults"
] | [
"'''\n WatchForProxyConfigAndAPIHostPortChanges watches for cleanups to be perfomed in state\n\n entities : typing.Sequence[~Entity]\n Returns -> NotifyWatchResults\n '''",
"# map input types to rpc msg"
] | [
{
"param": "self",
"type": null
},
{
"param": "entities",
"type": null
}
] | {
"returns": [],
"raises": [],
"params": [
{
"identifier": "self",
"type": null,
"docstring": null,
"docstring_tokens": [],
"default": null,
"is_optional": null
},
{
"identifier": "entities",
"type": null,
"docstring": null,
"docstring_tokens... |
f697638db76b9fc35cd762f0cbbb058c9ee6f5b1 | sed-i/python-libjuju | juju/client/_client2.py | [
"Apache-2.0"
] | Python | ClearReboot | <not_specific> | async def ClearReboot(self, entities=None):
'''
ClearReboot will clear the reboot flag on provided machines, if it exists.
entities : typing.Sequence[~Entity]
Returns -> ErrorResults
'''
if entities is not None and not isinstance(entities, (bytes, str, list)):
... |
ClearReboot will clear the reboot flag on provided machines, if it exists.
entities : typing.Sequence[~Entity]
Returns -> ErrorResults
| ClearReboot will clear the reboot flag on provided machines, if it exists.
entities : typing.Sequence[~Entity]
Returns -> ErrorResults | [
"ClearReboot",
"will",
"clear",
"the",
"reboot",
"flag",
"on",
"provided",
"machines",
"if",
"it",
"exists",
".",
"entities",
":",
"typing",
".",
"Sequence",
"[",
"~Entity",
"]",
"Returns",
"-",
">",
"ErrorResults"
] | async def ClearReboot(self, entities=None):
if entities is not None and not isinstance(entities, (bytes, str, list)):
raise Exception("Expected entities to be a Sequence, received: {}".format(type(entities)))
_params = dict()
msg = dict(type='Reboot',
request='Clea... | [
"async",
"def",
"ClearReboot",
"(",
"self",
",",
"entities",
"=",
"None",
")",
":",
"if",
"entities",
"is",
"not",
"None",
"and",
"not",
"isinstance",
"(",
"entities",
",",
"(",
"bytes",
",",
"str",
",",
"list",
")",
")",
":",
"raise",
"Exception",
"... | ClearReboot will clear the reboot flag on provided machines, if it exists. | [
"ClearReboot",
"will",
"clear",
"the",
"reboot",
"flag",
"on",
"provided",
"machines",
"if",
"it",
"exists",
"."
] | [
"'''\n ClearReboot will clear the reboot flag on provided machines, if it exists.\n\n entities : typing.Sequence[~Entity]\n Returns -> ErrorResults\n '''",
"# map input types to rpc msg"
] | [
{
"param": "self",
"type": null
},
{
"param": "entities",
"type": null
}
] | {
"returns": [],
"raises": [],
"params": [
{
"identifier": "self",
"type": null,
"docstring": null,
"docstring_tokens": [],
"default": null,
"is_optional": null
},
{
"identifier": "entities",
"type": null,
"docstring": null,
"docstring_tokens... |
f697638db76b9fc35cd762f0cbbb058c9ee6f5b1 | sed-i/python-libjuju | juju/client/_client2.py | [
"Apache-2.0"
] | Python | GetRebootAction | <not_specific> | async def GetRebootAction(self, entities=None):
'''
GetRebootAction returns the action a machine agent should take.
If a reboot flag is set on the machine, then that machine is
expected to reboot (params.ShouldReboot).
a reboot flag set on the machine parent or grandparent, will
... |
GetRebootAction returns the action a machine agent should take.
If a reboot flag is set on the machine, then that machine is
expected to reboot (params.ShouldReboot).
a reboot flag set on the machine parent or grandparent, will
cause the machine to shutdown (params.ShouldShutdow... | GetRebootAction returns the action a machine agent should take.
If a reboot flag is set on the machine, then that machine is
expected to reboot (params.ShouldReboot).
a reboot flag set on the machine parent or grandparent, will
cause the machine to shutdown (params.ShouldShutdown).
If no reboot flag is set, the machine... | [
"GetRebootAction",
"returns",
"the",
"action",
"a",
"machine",
"agent",
"should",
"take",
".",
"If",
"a",
"reboot",
"flag",
"is",
"set",
"on",
"the",
"machine",
"then",
"that",
"machine",
"is",
"expected",
"to",
"reboot",
"(",
"params",
".",
"ShouldReboot",
... | async def GetRebootAction(self, entities=None):
if entities is not None and not isinstance(entities, (bytes, str, list)):
raise Exception("Expected entities to be a Sequence, received: {}".format(type(entities)))
_params = dict()
msg = dict(type='Reboot',
request='... | [
"async",
"def",
"GetRebootAction",
"(",
"self",
",",
"entities",
"=",
"None",
")",
":",
"if",
"entities",
"is",
"not",
"None",
"and",
"not",
"isinstance",
"(",
"entities",
",",
"(",
"bytes",
",",
"str",
",",
"list",
")",
")",
":",
"raise",
"Exception",... | GetRebootAction returns the action a machine agent should take. | [
"GetRebootAction",
"returns",
"the",
"action",
"a",
"machine",
"agent",
"should",
"take",
"."
] | [
"'''\n GetRebootAction returns the action a machine agent should take.\n If a reboot flag is set on the machine, then that machine is\n expected to reboot (params.ShouldReboot).\n a reboot flag set on the machine parent or grandparent, will\n cause the machine to shutdown (params.... | [
{
"param": "self",
"type": null
},
{
"param": "entities",
"type": null
}
] | {
"returns": [],
"raises": [],
"params": [
{
"identifier": "self",
"type": null,
"docstring": null,
"docstring_tokens": [],
"default": null,
"is_optional": null
},
{
"identifier": "entities",
"type": null,
"docstring": null,
"docstring_tokens... |
f697638db76b9fc35cd762f0cbbb058c9ee6f5b1 | sed-i/python-libjuju | juju/client/_client2.py | [
"Apache-2.0"
] | Python | RequestReboot | <not_specific> | async def RequestReboot(self, entities=None):
'''
RequestReboot sets the reboot flag on the provided machines
entities : typing.Sequence[~Entity]
Returns -> ErrorResults
'''
if entities is not None and not isinstance(entities, (bytes, str, list)):
raise Excep... |
RequestReboot sets the reboot flag on the provided machines
entities : typing.Sequence[~Entity]
Returns -> ErrorResults
| RequestReboot sets the reboot flag on the provided machines
entities : typing.Sequence[~Entity]
Returns -> ErrorResults | [
"RequestReboot",
"sets",
"the",
"reboot",
"flag",
"on",
"the",
"provided",
"machines",
"entities",
":",
"typing",
".",
"Sequence",
"[",
"~Entity",
"]",
"Returns",
"-",
">",
"ErrorResults"
] | async def RequestReboot(self, entities=None):
if entities is not None and not isinstance(entities, (bytes, str, list)):
raise Exception("Expected entities to be a Sequence, received: {}".format(type(entities)))
_params = dict()
msg = dict(type='Reboot',
request='Re... | [
"async",
"def",
"RequestReboot",
"(",
"self",
",",
"entities",
"=",
"None",
")",
":",
"if",
"entities",
"is",
"not",
"None",
"and",
"not",
"isinstance",
"(",
"entities",
",",
"(",
"bytes",
",",
"str",
",",
"list",
")",
")",
":",
"raise",
"Exception",
... | RequestReboot sets the reboot flag on the provided machines
entities : typing.Sequence[~Entity]
Returns -> ErrorResults | [
"RequestReboot",
"sets",
"the",
"reboot",
"flag",
"on",
"the",
"provided",
"machines",
"entities",
":",
"typing",
".",
"Sequence",
"[",
"~Entity",
"]",
"Returns",
"-",
">",
"ErrorResults"
] | [
"'''\n RequestReboot sets the reboot flag on the provided machines\n\n entities : typing.Sequence[~Entity]\n Returns -> ErrorResults\n '''",
"# map input types to rpc msg"
] | [
{
"param": "self",
"type": null
},
{
"param": "entities",
"type": null
}
] | {
"returns": [],
"raises": [],
"params": [
{
"identifier": "self",
"type": null,
"docstring": null,
"docstring_tokens": [],
"default": null,
"is_optional": null
},
{
"identifier": "entities",
"type": null,
"docstring": null,
"docstring_tokens... |
f697638db76b9fc35cd762f0cbbb058c9ee6f5b1 | sed-i/python-libjuju | juju/client/_client2.py | [
"Apache-2.0"
] | Python | WatchForRebootEvent | <not_specific> | async def WatchForRebootEvent(self):
'''
WatchForRebootEvent starts a watcher to track if there is a new
reboot request on the machines ID or any of its parents (in case we are a container).
Returns -> NotifyWatchResult
'''
# map input types to rpc msg
_params ... |
WatchForRebootEvent starts a watcher to track if there is a new
reboot request on the machines ID or any of its parents (in case we are a container).
Returns -> NotifyWatchResult
| WatchForRebootEvent starts a watcher to track if there is a new
reboot request on the machines ID or any of its parents (in case we are a container).
| [
"WatchForRebootEvent",
"starts",
"a",
"watcher",
"to",
"track",
"if",
"there",
"is",
"a",
"new",
"reboot",
"request",
"on",
"the",
"machines",
"ID",
"or",
"any",
"of",
"its",
"parents",
"(",
"in",
"case",
"we",
"are",
"a",
"container",
")",
"."
] | async def WatchForRebootEvent(self):
_params = dict()
msg = dict(type='Reboot',
request='WatchForRebootEvent',
version=2,
params=_params)
reply = await self.rpc(msg)
return reply | [
"async",
"def",
"WatchForRebootEvent",
"(",
"self",
")",
":",
"_params",
"=",
"dict",
"(",
")",
"msg",
"=",
"dict",
"(",
"type",
"=",
"'Reboot'",
",",
"request",
"=",
"'WatchForRebootEvent'",
",",
"version",
"=",
"2",
",",
"params",
"=",
"_params",
")",
... | WatchForRebootEvent starts a watcher to track if there is a new
reboot request on the machines ID or any of its parents (in case we are a container). | [
"WatchForRebootEvent",
"starts",
"a",
"watcher",
"to",
"track",
"if",
"there",
"is",
"a",
"new",
"reboot",
"request",
"on",
"the",
"machines",
"ID",
"or",
"any",
"of",
"its",
"parents",
"(",
"in",
"case",
"we",
"are",
"a",
"container",
")",
"."
] | [
"'''\n WatchForRebootEvent starts a watcher to track if there is a new\n reboot request on the machines ID or any of its parents (in case we are a container).\n\n\n Returns -> NotifyWatchResult\n '''",
"# map input types to rpc msg"
] | [
{
"param": "self",
"type": null
}
] | {
"returns": [],
"raises": [],
"params": [
{
"identifier": "self",
"type": null,
"docstring": null,
"docstring_tokens": [],
"default": null,
"is_optional": null
}
],
"outlier_params": [],
"others": []
} |
f697638db76b9fc35cd762f0cbbb058c9ee6f5b1 | sed-i/python-libjuju | juju/client/_client2.py | [
"Apache-2.0"
] | Python | ConsumeRemoteRelationChanges | <not_specific> | async def ConsumeRemoteRelationChanges(self, changes=None):
'''
ConsumeRemoteRelationChanges consumes changes to settings originating
from the remote/offering side of relations.
changes : typing.Sequence[~RemoteRelationChangeEvent]
Returns -> ErrorResults
'''
if ... |
ConsumeRemoteRelationChanges consumes changes to settings originating
from the remote/offering side of relations.
changes : typing.Sequence[~RemoteRelationChangeEvent]
Returns -> ErrorResults
| ConsumeRemoteRelationChanges consumes changes to settings originating
from the remote/offering side of relations.
| [
"ConsumeRemoteRelationChanges",
"consumes",
"changes",
"to",
"settings",
"originating",
"from",
"the",
"remote",
"/",
"offering",
"side",
"of",
"relations",
"."
] | async def ConsumeRemoteRelationChanges(self, changes=None):
if changes is not None and not isinstance(changes, (bytes, str, list)):
raise Exception("Expected changes to be a Sequence, received: {}".format(type(changes)))
_params = dict()
msg = dict(type='RemoteRelations',
... | [
"async",
"def",
"ConsumeRemoteRelationChanges",
"(",
"self",
",",
"changes",
"=",
"None",
")",
":",
"if",
"changes",
"is",
"not",
"None",
"and",
"not",
"isinstance",
"(",
"changes",
",",
"(",
"bytes",
",",
"str",
",",
"list",
")",
")",
":",
"raise",
"E... | ConsumeRemoteRelationChanges consumes changes to settings originating
from the remote/offering side of relations. | [
"ConsumeRemoteRelationChanges",
"consumes",
"changes",
"to",
"settings",
"originating",
"from",
"the",
"remote",
"/",
"offering",
"side",
"of",
"relations",
"."
] | [
"'''\n ConsumeRemoteRelationChanges consumes changes to settings originating\n from the remote/offering side of relations.\n\n changes : typing.Sequence[~RemoteRelationChangeEvent]\n Returns -> ErrorResults\n '''",
"# map input types to rpc msg"
] | [
{
"param": "self",
"type": null
},
{
"param": "changes",
"type": null
}
] | {
"returns": [],
"raises": [],
"params": [
{
"identifier": "self",
"type": null,
"docstring": null,
"docstring_tokens": [],
"default": null,
"is_optional": null
},
{
"identifier": "changes",
"type": null,
"docstring": null,
"docstring_tokens"... |
f697638db76b9fc35cd762f0cbbb058c9ee6f5b1 | sed-i/python-libjuju | juju/client/_client2.py | [
"Apache-2.0"
] | Python | ControllerAPIInfoForModels | <not_specific> | async def ControllerAPIInfoForModels(self, entities=None):
'''
ControllerAPIInfoForModels returns the controller api connection details for the specified models.
entities : typing.Sequence[~Entity]
Returns -> ControllerAPIInfoResults
'''
if entities is not None and not i... |
ControllerAPIInfoForModels returns the controller api connection details for the specified models.
entities : typing.Sequence[~Entity]
Returns -> ControllerAPIInfoResults
| ControllerAPIInfoForModels returns the controller api connection details for the specified models.
entities : typing.Sequence[~Entity]
Returns -> ControllerAPIInfoResults | [
"ControllerAPIInfoForModels",
"returns",
"the",
"controller",
"api",
"connection",
"details",
"for",
"the",
"specified",
"models",
".",
"entities",
":",
"typing",
".",
"Sequence",
"[",
"~Entity",
"]",
"Returns",
"-",
">",
"ControllerAPIInfoResults"
] | async def ControllerAPIInfoForModels(self, entities=None):
if entities is not None and not isinstance(entities, (bytes, str, list)):
raise Exception("Expected entities to be a Sequence, received: {}".format(type(entities)))
_params = dict()
msg = dict(type='RemoteRelations',
... | [
"async",
"def",
"ControllerAPIInfoForModels",
"(",
"self",
",",
"entities",
"=",
"None",
")",
":",
"if",
"entities",
"is",
"not",
"None",
"and",
"not",
"isinstance",
"(",
"entities",
",",
"(",
"bytes",
",",
"str",
",",
"list",
")",
")",
":",
"raise",
"... | ControllerAPIInfoForModels returns the controller api connection details for the specified models. | [
"ControllerAPIInfoForModels",
"returns",
"the",
"controller",
"api",
"connection",
"details",
"for",
"the",
"specified",
"models",
"."
] | [
"'''\n ControllerAPIInfoForModels returns the controller api connection details for the specified models.\n\n entities : typing.Sequence[~Entity]\n Returns -> ControllerAPIInfoResults\n '''",
"# map input types to rpc msg"
] | [
{
"param": "self",
"type": null
},
{
"param": "entities",
"type": null
}
] | {
"returns": [],
"raises": [],
"params": [
{
"identifier": "self",
"type": null,
"docstring": null,
"docstring_tokens": [],
"default": null,
"is_optional": null
},
{
"identifier": "entities",
"type": null,
"docstring": null,
"docstring_tokens... |
f697638db76b9fc35cd762f0cbbb058c9ee6f5b1 | sed-i/python-libjuju | juju/client/_client2.py | [
"Apache-2.0"
] | Python | ControllerConfig | <not_specific> | async def ControllerConfig(self):
'''
ControllerConfig returns the controller's configuration.
Returns -> ControllerConfigResult
'''
# map input types to rpc msg
_params = dict()
msg = dict(type='RemoteRelations',
request='ControllerConfig',
... |
ControllerConfig returns the controller's configuration.
Returns -> ControllerConfigResult
| ControllerConfig returns the controller's configuration. | [
"ControllerConfig",
"returns",
"the",
"controller",
"'",
"s",
"configuration",
"."
] | async def ControllerConfig(self):
_params = dict()
msg = dict(type='RemoteRelations',
request='ControllerConfig',
version=2,
params=_params)
reply = await self.rpc(msg)
return reply | [
"async",
"def",
"ControllerConfig",
"(",
"self",
")",
":",
"_params",
"=",
"dict",
"(",
")",
"msg",
"=",
"dict",
"(",
"type",
"=",
"'RemoteRelations'",
",",
"request",
"=",
"'ControllerConfig'",
",",
"version",
"=",
"2",
",",
"params",
"=",
"_params",
")... | ControllerConfig returns the controller's configuration. | [
"ControllerConfig",
"returns",
"the",
"controller",
"'",
"s",
"configuration",
"."
] | [
"'''\n ControllerConfig returns the controller's configuration.\n\n\n Returns -> ControllerConfigResult\n '''",
"# map input types to rpc msg"
] | [
{
"param": "self",
"type": null
}
] | {
"returns": [],
"raises": [],
"params": [
{
"identifier": "self",
"type": null,
"docstring": null,
"docstring_tokens": [],
"default": null,
"is_optional": null
}
],
"outlier_params": [],
"others": []
} |
f697638db76b9fc35cd762f0cbbb058c9ee6f5b1 | sed-i/python-libjuju | juju/client/_client2.py | [
"Apache-2.0"
] | Python | ExportEntities | <not_specific> | async def ExportEntities(self, entities=None):
'''
ExportEntities allocates unique, remote entity IDs for the given entities in the local model.
entities : typing.Sequence[~Entity]
Returns -> TokenResults
'''
if entities is not None and not isinstance(entities, (bytes, s... |
ExportEntities allocates unique, remote entity IDs for the given entities in the local model.
entities : typing.Sequence[~Entity]
Returns -> TokenResults
| ExportEntities allocates unique, remote entity IDs for the given entities in the local model.
entities : typing.Sequence[~Entity]
Returns -> TokenResults | [
"ExportEntities",
"allocates",
"unique",
"remote",
"entity",
"IDs",
"for",
"the",
"given",
"entities",
"in",
"the",
"local",
"model",
".",
"entities",
":",
"typing",
".",
"Sequence",
"[",
"~Entity",
"]",
"Returns",
"-",
">",
"TokenResults"
] | async def ExportEntities(self, entities=None):
if entities is not None and not isinstance(entities, (bytes, str, list)):
raise Exception("Expected entities to be a Sequence, received: {}".format(type(entities)))
_params = dict()
msg = dict(type='RemoteRelations',
r... | [
"async",
"def",
"ExportEntities",
"(",
"self",
",",
"entities",
"=",
"None",
")",
":",
"if",
"entities",
"is",
"not",
"None",
"and",
"not",
"isinstance",
"(",
"entities",
",",
"(",
"bytes",
",",
"str",
",",
"list",
")",
")",
":",
"raise",
"Exception",
... | ExportEntities allocates unique, remote entity IDs for the given entities in the local model. | [
"ExportEntities",
"allocates",
"unique",
"remote",
"entity",
"IDs",
"for",
"the",
"given",
"entities",
"in",
"the",
"local",
"model",
"."
] | [
"'''\n ExportEntities allocates unique, remote entity IDs for the given entities in the local model.\n\n entities : typing.Sequence[~Entity]\n Returns -> TokenResults\n '''",
"# map input types to rpc msg"
] | [
{
"param": "self",
"type": null
},
{
"param": "entities",
"type": null
}
] | {
"returns": [],
"raises": [],
"params": [
{
"identifier": "self",
"type": null,
"docstring": null,
"docstring_tokens": [],
"default": null,
"is_optional": null
},
{
"identifier": "entities",
"type": null,
"docstring": null,
"docstring_tokens... |
f697638db76b9fc35cd762f0cbbb058c9ee6f5b1 | sed-i/python-libjuju | juju/client/_client2.py | [
"Apache-2.0"
] | Python | GetTokens | <not_specific> | async def GetTokens(self, args=None):
'''
GetTokens returns the token associated with the entities with the given tags for the given models.
args : typing.Sequence[~GetTokenArg]
Returns -> StringResults
'''
if args is not None and not isinstance(args, (bytes, str, list))... |
GetTokens returns the token associated with the entities with the given tags for the given models.
args : typing.Sequence[~GetTokenArg]
Returns -> StringResults
| GetTokens returns the token associated with the entities with the given tags for the given models. | [
"GetTokens",
"returns",
"the",
"token",
"associated",
"with",
"the",
"entities",
"with",
"the",
"given",
"tags",
"for",
"the",
"given",
"models",
"."
] | async def GetTokens(self, args=None):
if args is not None and not isinstance(args, (bytes, str, list)):
raise Exception("Expected args to be a Sequence, received: {}".format(type(args)))
_params = dict()
msg = dict(type='RemoteRelations',
request='GetTokens',
... | [
"async",
"def",
"GetTokens",
"(",
"self",
",",
"args",
"=",
"None",
")",
":",
"if",
"args",
"is",
"not",
"None",
"and",
"not",
"isinstance",
"(",
"args",
",",
"(",
"bytes",
",",
"str",
",",
"list",
")",
")",
":",
"raise",
"Exception",
"(",
"\"Expec... | GetTokens returns the token associated with the entities with the given tags for the given models. | [
"GetTokens",
"returns",
"the",
"token",
"associated",
"with",
"the",
"entities",
"with",
"the",
"given",
"tags",
"for",
"the",
"given",
"models",
"."
] | [
"'''\n GetTokens returns the token associated with the entities with the given tags for the given models.\n\n args : typing.Sequence[~GetTokenArg]\n Returns -> StringResults\n '''",
"# map input types to rpc msg"
] | [
{
"param": "self",
"type": null
},
{
"param": "args",
"type": null
}
] | {
"returns": [],
"raises": [],
"params": [
{
"identifier": "self",
"type": null,
"docstring": null,
"docstring_tokens": [],
"default": null,
"is_optional": null
},
{
"identifier": "args",
"type": null,
"docstring": null,
"docstring_tokens": [... |
f697638db76b9fc35cd762f0cbbb058c9ee6f5b1 | sed-i/python-libjuju | juju/client/_client2.py | [
"Apache-2.0"
] | Python | ImportRemoteEntities | <not_specific> | async def ImportRemoteEntities(self, args=None):
'''
ImportRemoteEntities adds entities to the remote entities collection with the specified opaque tokens.
args : typing.Sequence[~RemoteEntityTokenArg]
Returns -> ErrorResults
'''
if args is not None and not isinstance(ar... |
ImportRemoteEntities adds entities to the remote entities collection with the specified opaque tokens.
args : typing.Sequence[~RemoteEntityTokenArg]
Returns -> ErrorResults
| ImportRemoteEntities adds entities to the remote entities collection with the specified opaque tokens. | [
"ImportRemoteEntities",
"adds",
"entities",
"to",
"the",
"remote",
"entities",
"collection",
"with",
"the",
"specified",
"opaque",
"tokens",
"."
] | async def ImportRemoteEntities(self, args=None):
if args is not None and not isinstance(args, (bytes, str, list)):
raise Exception("Expected args to be a Sequence, received: {}".format(type(args)))
_params = dict()
msg = dict(type='RemoteRelations',
request='Import... | [
"async",
"def",
"ImportRemoteEntities",
"(",
"self",
",",
"args",
"=",
"None",
")",
":",
"if",
"args",
"is",
"not",
"None",
"and",
"not",
"isinstance",
"(",
"args",
",",
"(",
"bytes",
",",
"str",
",",
"list",
")",
")",
":",
"raise",
"Exception",
"(",... | ImportRemoteEntities adds entities to the remote entities collection with the specified opaque tokens. | [
"ImportRemoteEntities",
"adds",
"entities",
"to",
"the",
"remote",
"entities",
"collection",
"with",
"the",
"specified",
"opaque",
"tokens",
"."
] | [
"'''\n ImportRemoteEntities adds entities to the remote entities collection with the specified opaque tokens.\n\n args : typing.Sequence[~RemoteEntityTokenArg]\n Returns -> ErrorResults\n '''",
"# map input types to rpc msg"
] | [
{
"param": "self",
"type": null
},
{
"param": "args",
"type": null
}
] | {
"returns": [],
"raises": [],
"params": [
{
"identifier": "self",
"type": null,
"docstring": null,
"docstring_tokens": [],
"default": null,
"is_optional": null
},
{
"identifier": "args",
"type": null,
"docstring": null,
"docstring_tokens": [... |
f697638db76b9fc35cd762f0cbbb058c9ee6f5b1 | sed-i/python-libjuju | juju/client/_client2.py | [
"Apache-2.0"
] | Python | Relations | <not_specific> | async def Relations(self, entities=None):
'''
Relations returns information about the cross-model relations with the specified keys
in the local model.
entities : typing.Sequence[~Entity]
Returns -> RemoteRelationResults
'''
if entities is not None and not isinst... |
Relations returns information about the cross-model relations with the specified keys
in the local model.
entities : typing.Sequence[~Entity]
Returns -> RemoteRelationResults
| Relations returns information about the cross-model relations with the specified keys
in the local model.
entities : typing.Sequence[~Entity]
Returns -> RemoteRelationResults | [
"Relations",
"returns",
"information",
"about",
"the",
"cross",
"-",
"model",
"relations",
"with",
"the",
"specified",
"keys",
"in",
"the",
"local",
"model",
".",
"entities",
":",
"typing",
".",
"Sequence",
"[",
"~Entity",
"]",
"Returns",
"-",
">",
"RemoteRe... | async def Relations(self, entities=None):
if entities is not None and not isinstance(entities, (bytes, str, list)):
raise Exception("Expected entities to be a Sequence, received: {}".format(type(entities)))
_params = dict()
msg = dict(type='RemoteRelations',
reques... | [
"async",
"def",
"Relations",
"(",
"self",
",",
"entities",
"=",
"None",
")",
":",
"if",
"entities",
"is",
"not",
"None",
"and",
"not",
"isinstance",
"(",
"entities",
",",
"(",
"bytes",
",",
"str",
",",
"list",
")",
")",
":",
"raise",
"Exception",
"("... | Relations returns information about the cross-model relations with the specified keys
in the local model. | [
"Relations",
"returns",
"information",
"about",
"the",
"cross",
"-",
"model",
"relations",
"with",
"the",
"specified",
"keys",
"in",
"the",
"local",
"model",
"."
] | [
"'''\n Relations returns information about the cross-model relations with the specified keys\n in the local model.\n\n entities : typing.Sequence[~Entity]\n Returns -> RemoteRelationResults\n '''",
"# map input types to rpc msg"
] | [
{
"param": "self",
"type": null
},
{
"param": "entities",
"type": null
}
] | {
"returns": [],
"raises": [],
"params": [
{
"identifier": "self",
"type": null,
"docstring": null,
"docstring_tokens": [],
"default": null,
"is_optional": null
},
{
"identifier": "entities",
"type": null,
"docstring": null,
"docstring_tokens... |
f697638db76b9fc35cd762f0cbbb058c9ee6f5b1 | sed-i/python-libjuju | juju/client/_client2.py | [
"Apache-2.0"
] | Python | RemoteApplications | <not_specific> | async def RemoteApplications(self, entities=None):
'''
RemoteApplications returns the current state of the remote applications with
the specified names in the local model.
entities : typing.Sequence[~Entity]
Returns -> RemoteApplicationResults
'''
if entities is ... |
RemoteApplications returns the current state of the remote applications with
the specified names in the local model.
entities : typing.Sequence[~Entity]
Returns -> RemoteApplicationResults
| RemoteApplications returns the current state of the remote applications with
the specified names in the local model.
entities : typing.Sequence[~Entity]
Returns -> RemoteApplicationResults | [
"RemoteApplications",
"returns",
"the",
"current",
"state",
"of",
"the",
"remote",
"applications",
"with",
"the",
"specified",
"names",
"in",
"the",
"local",
"model",
".",
"entities",
":",
"typing",
".",
"Sequence",
"[",
"~Entity",
"]",
"Returns",
"-",
">",
... | async def RemoteApplications(self, entities=None):
if entities is not None and not isinstance(entities, (bytes, str, list)):
raise Exception("Expected entities to be a Sequence, received: {}".format(type(entities)))
_params = dict()
msg = dict(type='RemoteRelations',
... | [
"async",
"def",
"RemoteApplications",
"(",
"self",
",",
"entities",
"=",
"None",
")",
":",
"if",
"entities",
"is",
"not",
"None",
"and",
"not",
"isinstance",
"(",
"entities",
",",
"(",
"bytes",
",",
"str",
",",
"list",
")",
")",
":",
"raise",
"Exceptio... | RemoteApplications returns the current state of the remote applications with
the specified names in the local model. | [
"RemoteApplications",
"returns",
"the",
"current",
"state",
"of",
"the",
"remote",
"applications",
"with",
"the",
"specified",
"names",
"in",
"the",
"local",
"model",
"."
] | [
"'''\n RemoteApplications returns the current state of the remote applications with\n the specified names in the local model.\n\n entities : typing.Sequence[~Entity]\n Returns -> RemoteApplicationResults\n '''",
"# map input types to rpc msg"
] | [
{
"param": "self",
"type": null
},
{
"param": "entities",
"type": null
}
] | {
"returns": [],
"raises": [],
"params": [
{
"identifier": "self",
"type": null,
"docstring": null,
"docstring_tokens": [],
"default": null,
"is_optional": null
},
{
"identifier": "entities",
"type": null,
"docstring": null,
"docstring_tokens... |
f697638db76b9fc35cd762f0cbbb058c9ee6f5b1 | sed-i/python-libjuju | juju/client/_client2.py | [
"Apache-2.0"
] | Python | SaveMacaroons | <not_specific> | async def SaveMacaroons(self, args=None):
'''
SaveMacaroons saves the macaroons for the given entities.
args : typing.Sequence[~EntityMacaroonArg]
Returns -> ErrorResults
'''
if args is not None and not isinstance(args, (bytes, str, list)):
raise Exception("E... |
SaveMacaroons saves the macaroons for the given entities.
args : typing.Sequence[~EntityMacaroonArg]
Returns -> ErrorResults
| SaveMacaroons saves the macaroons for the given entities. | [
"SaveMacaroons",
"saves",
"the",
"macaroons",
"for",
"the",
"given",
"entities",
"."
] | async def SaveMacaroons(self, args=None):
if args is not None and not isinstance(args, (bytes, str, list)):
raise Exception("Expected args to be a Sequence, received: {}".format(type(args)))
_params = dict()
msg = dict(type='RemoteRelations',
request='SaveMacaroons... | [
"async",
"def",
"SaveMacaroons",
"(",
"self",
",",
"args",
"=",
"None",
")",
":",
"if",
"args",
"is",
"not",
"None",
"and",
"not",
"isinstance",
"(",
"args",
",",
"(",
"bytes",
",",
"str",
",",
"list",
")",
")",
":",
"raise",
"Exception",
"(",
"\"E... | SaveMacaroons saves the macaroons for the given entities. | [
"SaveMacaroons",
"saves",
"the",
"macaroons",
"for",
"the",
"given",
"entities",
"."
] | [
"'''\n SaveMacaroons saves the macaroons for the given entities.\n\n args : typing.Sequence[~EntityMacaroonArg]\n Returns -> ErrorResults\n '''",
"# map input types to rpc msg"
] | [
{
"param": "self",
"type": null
},
{
"param": "args",
"type": null
}
] | {
"returns": [],
"raises": [],
"params": [
{
"identifier": "self",
"type": null,
"docstring": null,
"docstring_tokens": [],
"default": null,
"is_optional": null
},
{
"identifier": "args",
"type": null,
"docstring": null,
"docstring_tokens": [... |
f697638db76b9fc35cd762f0cbbb058c9ee6f5b1 | sed-i/python-libjuju | juju/client/_client2.py | [
"Apache-2.0"
] | Python | SetRemoteApplicationsStatus | <not_specific> | async def SetRemoteApplicationsStatus(self, entities=None):
'''
SetRemoteApplicationsStatus sets the status for the specified remote applications.
entities : typing.Sequence[~EntityStatusArgs]
Returns -> ErrorResults
'''
if entities is not None and not isinstance(entitie... |
SetRemoteApplicationsStatus sets the status for the specified remote applications.
entities : typing.Sequence[~EntityStatusArgs]
Returns -> ErrorResults
| SetRemoteApplicationsStatus sets the status for the specified remote applications. | [
"SetRemoteApplicationsStatus",
"sets",
"the",
"status",
"for",
"the",
"specified",
"remote",
"applications",
"."
] | async def SetRemoteApplicationsStatus(self, entities=None):
if entities is not None and not isinstance(entities, (bytes, str, list)):
raise Exception("Expected entities to be a Sequence, received: {}".format(type(entities)))
_params = dict()
msg = dict(type='RemoteRelations',
... | [
"async",
"def",
"SetRemoteApplicationsStatus",
"(",
"self",
",",
"entities",
"=",
"None",
")",
":",
"if",
"entities",
"is",
"not",
"None",
"and",
"not",
"isinstance",
"(",
"entities",
",",
"(",
"bytes",
",",
"str",
",",
"list",
")",
")",
":",
"raise",
... | SetRemoteApplicationsStatus sets the status for the specified remote applications. | [
"SetRemoteApplicationsStatus",
"sets",
"the",
"status",
"for",
"the",
"specified",
"remote",
"applications",
"."
] | [
"'''\n SetRemoteApplicationsStatus sets the status for the specified remote applications.\n\n entities : typing.Sequence[~EntityStatusArgs]\n Returns -> ErrorResults\n '''",
"# map input types to rpc msg"
] | [
{
"param": "self",
"type": null
},
{
"param": "entities",
"type": null
}
] | {
"returns": [],
"raises": [],
"params": [
{
"identifier": "self",
"type": null,
"docstring": null,
"docstring_tokens": [],
"default": null,
"is_optional": null
},
{
"identifier": "entities",
"type": null,
"docstring": null,
"docstring_tokens... |
f697638db76b9fc35cd762f0cbbb058c9ee6f5b1 | sed-i/python-libjuju | juju/client/_client2.py | [
"Apache-2.0"
] | Python | UpdateControllersForModels | <not_specific> | async def UpdateControllersForModels(self, changes=None):
'''
UpdateControllersForModels changes the external controller records for the
associated model entities. This is used when the remote relations worker gets
redirected following migration of an offering model.
changes : t... |
UpdateControllersForModels changes the external controller records for the
associated model entities. This is used when the remote relations worker gets
redirected following migration of an offering model.
changes : typing.Sequence[~UpdateControllerForModel]
Returns -> ErrorRes... | UpdateControllersForModels changes the external controller records for the
associated model entities. This is used when the remote relations worker gets
redirected following migration of an offering model.
| [
"UpdateControllersForModels",
"changes",
"the",
"external",
"controller",
"records",
"for",
"the",
"associated",
"model",
"entities",
".",
"This",
"is",
"used",
"when",
"the",
"remote",
"relations",
"worker",
"gets",
"redirected",
"following",
"migration",
"of",
"an... | async def UpdateControllersForModels(self, changes=None):
if changes is not None and not isinstance(changes, (bytes, str, list)):
raise Exception("Expected changes to be a Sequence, received: {}".format(type(changes)))
_params = dict()
msg = dict(type='RemoteRelations',
... | [
"async",
"def",
"UpdateControllersForModels",
"(",
"self",
",",
"changes",
"=",
"None",
")",
":",
"if",
"changes",
"is",
"not",
"None",
"and",
"not",
"isinstance",
"(",
"changes",
",",
"(",
"bytes",
",",
"str",
",",
"list",
")",
")",
":",
"raise",
"Exc... | UpdateControllersForModels changes the external controller records for the
associated model entities. | [
"UpdateControllersForModels",
"changes",
"the",
"external",
"controller",
"records",
"for",
"the",
"associated",
"model",
"entities",
"."
] | [
"'''\n UpdateControllersForModels changes the external controller records for the\n associated model entities. This is used when the remote relations worker gets\n redirected following migration of an offering model.\n\n changes : typing.Sequence[~UpdateControllerForModel]\n Retur... | [
{
"param": "self",
"type": null
},
{
"param": "changes",
"type": null
}
] | {
"returns": [],
"raises": [],
"params": [
{
"identifier": "self",
"type": null,
"docstring": null,
"docstring_tokens": [],
"default": null,
"is_optional": null
},
{
"identifier": "changes",
"type": null,
"docstring": null,
"docstring_tokens"... |
f697638db76b9fc35cd762f0cbbb058c9ee6f5b1 | sed-i/python-libjuju | juju/client/_client2.py | [
"Apache-2.0"
] | Python | WatchLocalRelationChanges | <not_specific> | async def WatchLocalRelationChanges(self, entities=None):
'''
WatchLocalRelationChanges starts a RemoteRelationWatcher for each
specified relation, returning the watcher IDs and initial values,
or an error if the remote relations couldn't be watched.
entities : typing.Sequence[~... |
WatchLocalRelationChanges starts a RemoteRelationWatcher for each
specified relation, returning the watcher IDs and initial values,
or an error if the remote relations couldn't be watched.
entities : typing.Sequence[~Entity]
Returns -> RemoteRelationWatchResults
| WatchLocalRelationChanges starts a RemoteRelationWatcher for each
specified relation, returning the watcher IDs and initial values,
or an error if the remote relations couldn't be watched.
entities : typing.Sequence[~Entity]
Returns -> RemoteRelationWatchResults | [
"WatchLocalRelationChanges",
"starts",
"a",
"RemoteRelationWatcher",
"for",
"each",
"specified",
"relation",
"returning",
"the",
"watcher",
"IDs",
"and",
"initial",
"values",
"or",
"an",
"error",
"if",
"the",
"remote",
"relations",
"couldn",
"'",
"t",
"be",
"watch... | async def WatchLocalRelationChanges(self, entities=None):
if entities is not None and not isinstance(entities, (bytes, str, list)):
raise Exception("Expected entities to be a Sequence, received: {}".format(type(entities)))
_params = dict()
msg = dict(type='RemoteRelations',
... | [
"async",
"def",
"WatchLocalRelationChanges",
"(",
"self",
",",
"entities",
"=",
"None",
")",
":",
"if",
"entities",
"is",
"not",
"None",
"and",
"not",
"isinstance",
"(",
"entities",
",",
"(",
"bytes",
",",
"str",
",",
"list",
")",
")",
":",
"raise",
"E... | WatchLocalRelationChanges starts a RemoteRelationWatcher for each
specified relation, returning the watcher IDs and initial values,
or an error if the remote relations couldn't be watched. | [
"WatchLocalRelationChanges",
"starts",
"a",
"RemoteRelationWatcher",
"for",
"each",
"specified",
"relation",
"returning",
"the",
"watcher",
"IDs",
"and",
"initial",
"values",
"or",
"an",
"error",
"if",
"the",
"remote",
"relations",
"couldn",
"'",
"t",
"be",
"watch... | [
"'''\n WatchLocalRelationChanges starts a RemoteRelationWatcher for each\n specified relation, returning the watcher IDs and initial values,\n or an error if the remote relations couldn't be watched.\n\n entities : typing.Sequence[~Entity]\n Returns -> RemoteRelationWatchResults\n... | [
{
"param": "self",
"type": null
},
{
"param": "entities",
"type": null
}
] | {
"returns": [],
"raises": [],
"params": [
{
"identifier": "self",
"type": null,
"docstring": null,
"docstring_tokens": [],
"default": null,
"is_optional": null
},
{
"identifier": "entities",
"type": null,
"docstring": null,
"docstring_tokens... |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.