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 |
|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
201cf4683d7f5f6f3b76fe38fbb37c25a7e14749 | sed-i/python-libjuju | juju/client/_client1.py | [
"Apache-2.0"
] | Python | Delete | <not_specific> | async def Delete(self, image_ids=None):
'''
Delete deletes cloud image metadata for given image ids.
It supports bulk calls.
image_ids : typing.Sequence[str]
Returns -> ErrorResults
'''
if image_ids is not None and not isinstance(image_ids, (bytes, str, list)):
... |
Delete deletes cloud image metadata for given image ids.
It supports bulk calls.
image_ids : typing.Sequence[str]
Returns -> ErrorResults
| Delete deletes cloud image metadata for given image ids.
It supports bulk calls.
| [
"Delete",
"deletes",
"cloud",
"image",
"metadata",
"for",
"given",
"image",
"ids",
".",
"It",
"supports",
"bulk",
"calls",
"."
] | async def Delete(self, image_ids=None):
if image_ids is not None and not isinstance(image_ids, (bytes, str, list)):
raise Exception("Expected image_ids to be a Sequence, received: {}".format(type(image_ids)))
_params = dict()
msg = dict(type='ImageMetadataManager',
... | [
"async",
"def",
"Delete",
"(",
"self",
",",
"image_ids",
"=",
"None",
")",
":",
"if",
"image_ids",
"is",
"not",
"None",
"and",
"not",
"isinstance",
"(",
"image_ids",
",",
"(",
"bytes",
",",
"str",
",",
"list",
")",
")",
":",
"raise",
"Exception",
"("... | Delete deletes cloud image metadata for given image ids. | [
"Delete",
"deletes",
"cloud",
"image",
"metadata",
"for",
"given",
"image",
"ids",
"."
] | [
"'''\n Delete deletes cloud image metadata for given image ids.\n It supports bulk calls.\n\n image_ids : typing.Sequence[str]\n Returns -> ErrorResults\n '''",
"# map input types to rpc msg"
] | [
{
"param": "self",
"type": null
},
{
"param": "image_ids",
"type": null
}
] | {
"returns": [],
"raises": [],
"params": [
{
"identifier": "self",
"type": null,
"docstring": null,
"docstring_tokens": [],
"default": null,
"is_optional": null
},
{
"identifier": "image_ids",
"type": null,
"docstring": null,
"docstring_token... |
201cf4683d7f5f6f3b76fe38fbb37c25a7e14749 | sed-i/python-libjuju | juju/client/_client1.py | [
"Apache-2.0"
] | Python | List | <not_specific> | async def List(self, arches=None, region=None, root_storage_type=None, series=None, stream=None, virt_type=None):
'''
List returns all found cloud image metadata that satisfy
given filter.
Returned list contains metadata ordered by priority.
arches : typing.Sequence[str]
... |
List returns all found cloud image metadata that satisfy
given filter.
Returned list contains metadata ordered by priority.
arches : typing.Sequence[str]
region : str
root_storage_type : str
series : typing.Sequence[str]
stream : str
virt_type : ... | List returns all found cloud image metadata that satisfy
given filter.
Returned list contains metadata ordered by priority.
| [
"List",
"returns",
"all",
"found",
"cloud",
"image",
"metadata",
"that",
"satisfy",
"given",
"filter",
".",
"Returned",
"list",
"contains",
"metadata",
"ordered",
"by",
"priority",
"."
] | async def List(self, arches=None, region=None, root_storage_type=None, series=None, stream=None, virt_type=None):
if arches is not None and not isinstance(arches, (bytes, str, list)):
raise Exception("Expected arches to be a Sequence, received: {}".format(type(arches)))
if region is not None... | [
"async",
"def",
"List",
"(",
"self",
",",
"arches",
"=",
"None",
",",
"region",
"=",
"None",
",",
"root_storage_type",
"=",
"None",
",",
"series",
"=",
"None",
",",
"stream",
"=",
"None",
",",
"virt_type",
"=",
"None",
")",
":",
"if",
"arches",
"is",... | List returns all found cloud image metadata that satisfy
given filter. | [
"List",
"returns",
"all",
"found",
"cloud",
"image",
"metadata",
"that",
"satisfy",
"given",
"filter",
"."
] | [
"'''\n List returns all found cloud image metadata that satisfy\n given filter.\n Returned list contains metadata ordered by priority.\n\n arches : typing.Sequence[str]\n region : str\n root_storage_type : str\n series : typing.Sequence[str]\n stream : str\n ... | [
{
"param": "self",
"type": null
},
{
"param": "arches",
"type": null
},
{
"param": "region",
"type": null
},
{
"param": "root_storage_type",
"type": null
},
{
"param": "series",
"type": null
},
{
"param": "stream",
"type": null
},
{
"param"... | {
"returns": [],
"raises": [],
"params": [
{
"identifier": "self",
"type": null,
"docstring": null,
"docstring_tokens": [],
"default": null,
"is_optional": null
},
{
"identifier": "arches",
"type": null,
"docstring": null,
"docstring_tokens":... |
201cf4683d7f5f6f3b76fe38fbb37c25a7e14749 | sed-i/python-libjuju | juju/client/_client1.py | [
"Apache-2.0"
] | Python | Save | <not_specific> | async def Save(self, metadata=None):
'''
Save stores given cloud image metadata.
It supports bulk calls.
metadata : typing.Sequence[~CloudImageMetadataList]
Returns -> ErrorResults
'''
if metadata is not None and not isinstance(metadata, (bytes, str, list)):
... |
Save stores given cloud image metadata.
It supports bulk calls.
metadata : typing.Sequence[~CloudImageMetadataList]
Returns -> ErrorResults
| Save stores given cloud image metadata.
It supports bulk calls.
| [
"Save",
"stores",
"given",
"cloud",
"image",
"metadata",
".",
"It",
"supports",
"bulk",
"calls",
"."
] | async def Save(self, metadata=None):
if metadata is not None and not isinstance(metadata, (bytes, str, list)):
raise Exception("Expected metadata to be a Sequence, received: {}".format(type(metadata)))
_params = dict()
msg = dict(type='ImageMetadataManager',
reques... | [
"async",
"def",
"Save",
"(",
"self",
",",
"metadata",
"=",
"None",
")",
":",
"if",
"metadata",
"is",
"not",
"None",
"and",
"not",
"isinstance",
"(",
"metadata",
",",
"(",
"bytes",
",",
"str",
",",
"list",
")",
")",
":",
"raise",
"Exception",
"(",
"... | Save stores given cloud image metadata. | [
"Save",
"stores",
"given",
"cloud",
"image",
"metadata",
"."
] | [
"'''\n Save stores given cloud image metadata.\n It supports bulk calls.\n\n metadata : typing.Sequence[~CloudImageMetadataList]\n Returns -> ErrorResults\n '''",
"# map input types to rpc msg"
] | [
{
"param": "self",
"type": null
},
{
"param": "metadata",
"type": null
}
] | {
"returns": [],
"raises": [],
"params": [
{
"identifier": "self",
"type": null,
"docstring": null,
"docstring_tokens": [],
"default": null,
"is_optional": null
},
{
"identifier": "metadata",
"type": null,
"docstring": null,
"docstring_tokens... |
201cf4683d7f5f6f3b76fe38fbb37c25a7e14749 | sed-i/python-libjuju | juju/client/_client1.py | [
"Apache-2.0"
] | Python | ImportKeys | <not_specific> | async def ImportKeys(self, ssh_keys=None, user=None):
'''
ImportKeys imports new authorised ssh keys from the specified key ids for the specified user.
ssh_keys : typing.Sequence[str]
user : str
Returns -> ErrorResults
'''
if ssh_keys is not None and not isinstan... |
ImportKeys imports new authorised ssh keys from the specified key ids for the specified user.
ssh_keys : typing.Sequence[str]
user : str
Returns -> ErrorResults
| ImportKeys imports new authorised ssh keys from the specified key ids for the specified user.
ssh_keys : typing.Sequence[str]
user : str
Returns -> ErrorResults | [
"ImportKeys",
"imports",
"new",
"authorised",
"ssh",
"keys",
"from",
"the",
"specified",
"key",
"ids",
"for",
"the",
"specified",
"user",
".",
"ssh_keys",
":",
"typing",
".",
"Sequence",
"[",
"str",
"]",
"user",
":",
"str",
"Returns",
"-",
">",
"ErrorResul... | async def ImportKeys(self, ssh_keys=None, user=None):
if ssh_keys is not None and not isinstance(ssh_keys, (bytes, str, list)):
raise Exception("Expected ssh_keys to be a Sequence, received: {}".format(type(ssh_keys)))
if user is not None and not isinstance(user, (bytes, str)):
r... | [
"async",
"def",
"ImportKeys",
"(",
"self",
",",
"ssh_keys",
"=",
"None",
",",
"user",
"=",
"None",
")",
":",
"if",
"ssh_keys",
"is",
"not",
"None",
"and",
"not",
"isinstance",
"(",
"ssh_keys",
",",
"(",
"bytes",
",",
"str",
",",
"list",
")",
")",
"... | ImportKeys imports new authorised ssh keys from the specified key ids for the specified user. | [
"ImportKeys",
"imports",
"new",
"authorised",
"ssh",
"keys",
"from",
"the",
"specified",
"key",
"ids",
"for",
"the",
"specified",
"user",
"."
] | [
"'''\n ImportKeys imports new authorised ssh keys from the specified key ids for the specified user.\n\n ssh_keys : typing.Sequence[str]\n user : str\n Returns -> ErrorResults\n '''",
"# map input types to rpc msg"
] | [
{
"param": "self",
"type": null
},
{
"param": "ssh_keys",
"type": null
},
{
"param": "user",
"type": null
}
] | {
"returns": [],
"raises": [],
"params": [
{
"identifier": "self",
"type": null,
"docstring": null,
"docstring_tokens": [],
"default": null,
"is_optional": null
},
{
"identifier": "ssh_keys",
"type": null,
"docstring": null,
"docstring_tokens... |
201cf4683d7f5f6f3b76fe38fbb37c25a7e14749 | sed-i/python-libjuju | juju/client/_client1.py | [
"Apache-2.0"
] | Python | ListKeys | <not_specific> | async def ListKeys(self, entities=None, mode=None):
'''
ListKeys returns the authorised ssh keys for the specified users.
entities : Entities
mode : bool
Returns -> StringsResults
'''
if entities is not None and not isinstance(entities, (dict, Entities)):
... |
ListKeys returns the authorised ssh keys for the specified users.
entities : Entities
mode : bool
Returns -> StringsResults
| ListKeys returns the authorised ssh keys for the specified users.
entities : Entities
mode : bool
Returns -> StringsResults | [
"ListKeys",
"returns",
"the",
"authorised",
"ssh",
"keys",
"for",
"the",
"specified",
"users",
".",
"entities",
":",
"Entities",
"mode",
":",
"bool",
"Returns",
"-",
">",
"StringsResults"
] | async def ListKeys(self, entities=None, mode=None):
if entities is not None and not isinstance(entities, (dict, Entities)):
raise Exception("Expected entities to be a Entities, received: {}".format(type(entities)))
if mode is not None and not isinstance(mode, bool):
raise Excepti... | [
"async",
"def",
"ListKeys",
"(",
"self",
",",
"entities",
"=",
"None",
",",
"mode",
"=",
"None",
")",
":",
"if",
"entities",
"is",
"not",
"None",
"and",
"not",
"isinstance",
"(",
"entities",
",",
"(",
"dict",
",",
"Entities",
")",
")",
":",
"raise",
... | ListKeys returns the authorised ssh keys for the specified users. | [
"ListKeys",
"returns",
"the",
"authorised",
"ssh",
"keys",
"for",
"the",
"specified",
"users",
"."
] | [
"'''\n ListKeys returns the authorised ssh keys for the specified users.\n\n entities : Entities\n mode : bool\n Returns -> StringsResults\n '''",
"# map input types to rpc msg"
] | [
{
"param": "self",
"type": null
},
{
"param": "entities",
"type": null
},
{
"param": "mode",
"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... |
201cf4683d7f5f6f3b76fe38fbb37c25a7e14749 | sed-i/python-libjuju | juju/client/_client1.py | [
"Apache-2.0"
] | Python | AuthorisedKeys | <not_specific> | async def AuthorisedKeys(self, entities=None):
'''
AuthorisedKeys reports the authorised ssh keys for the specified machines.
The current implementation relies on global authorised keys being stored in the model config.
This will change as new user management and authorisation functional... |
AuthorisedKeys reports the authorised ssh keys for the specified machines.
The current implementation relies on global authorised keys being stored in the model config.
This will change as new user management and authorisation functionality is added.
entities : typing.Sequence[~Entity]... | AuthorisedKeys reports the authorised ssh keys for the specified machines.
The current implementation relies on global authorised keys being stored in the model config.
This will change as new user management and authorisation functionality is added.
entities : typing.Sequence[~Entity]
Returns -> StringsResults | [
"AuthorisedKeys",
"reports",
"the",
"authorised",
"ssh",
"keys",
"for",
"the",
"specified",
"machines",
".",
"The",
"current",
"implementation",
"relies",
"on",
"global",
"authorised",
"keys",
"being",
"stored",
"in",
"the",
"model",
"config",
".",
"This",
"will... | async def AuthorisedKeys(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='KeyUpdater',
reques... | [
"async",
"def",
"AuthorisedKeys",
"(",
"self",
",",
"entities",
"=",
"None",
")",
":",
"if",
"entities",
"is",
"not",
"None",
"and",
"not",
"isinstance",
"(",
"entities",
",",
"(",
"bytes",
",",
"str",
",",
"list",
")",
")",
":",
"raise",
"Exception",
... | AuthorisedKeys reports the authorised ssh keys for the specified machines. | [
"AuthorisedKeys",
"reports",
"the",
"authorised",
"ssh",
"keys",
"for",
"the",
"specified",
"machines",
"."
] | [
"'''\n AuthorisedKeys reports the authorised ssh keys for the specified machines.\n The current implementation relies on global authorised keys being stored in the model config.\n This will change as new user management and authorisation functionality is added.\n\n entities : typing.Sequ... | [
{
"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... |
201cf4683d7f5f6f3b76fe38fbb37c25a7e14749 | sed-i/python-libjuju | juju/client/_client1.py | [
"Apache-2.0"
] | Python | WatchAuthorisedKeys | <not_specific> | async def WatchAuthorisedKeys(self, entities=None):
'''
WatchAuthorisedKeys starts a watcher to track changes to the authorised ssh keys
for the specified machines.
The current implementation relies on global authorised keys being stored in the model config.
This will change as n... |
WatchAuthorisedKeys starts a watcher to track changes to the authorised ssh keys
for the specified machines.
The current implementation relies on global authorised keys being stored in the model config.
This will change as new user management and authorisation functionality is added.
... | WatchAuthorisedKeys starts a watcher to track changes to the authorised ssh keys
for the specified machines.
The current implementation relies on global authorised keys being stored in the model config.
This will change as new user management and authorisation functionality is added.
entities : typing.Sequence[~Entity... | [
"WatchAuthorisedKeys",
"starts",
"a",
"watcher",
"to",
"track",
"changes",
"to",
"the",
"authorised",
"ssh",
"keys",
"for",
"the",
"specified",
"machines",
".",
"The",
"current",
"implementation",
"relies",
"on",
"global",
"authorised",
"keys",
"being",
"stored",
... | async def WatchAuthorisedKeys(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='KeyUpdater',
r... | [
"async",
"def",
"WatchAuthorisedKeys",
"(",
"self",
",",
"entities",
"=",
"None",
")",
":",
"if",
"entities",
"is",
"not",
"None",
"and",
"not",
"isinstance",
"(",
"entities",
",",
"(",
"bytes",
",",
"str",
",",
"list",
")",
")",
":",
"raise",
"Excepti... | WatchAuthorisedKeys starts a watcher to track changes to the authorised ssh keys
for the specified machines. | [
"WatchAuthorisedKeys",
"starts",
"a",
"watcher",
"to",
"track",
"changes",
"to",
"the",
"authorised",
"ssh",
"keys",
"for",
"the",
"specified",
"machines",
"."
] | [
"'''\n WatchAuthorisedKeys starts a watcher to track changes to the authorised ssh keys\n for the specified machines.\n The current implementation relies on global authorised keys being stored in the model config.\n This will change as new user management and authorisation functionality ... | [
{
"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... |
201cf4683d7f5f6f3b76fe38fbb37c25a7e14749 | sed-i/python-libjuju | juju/client/_client1.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='LifeFlag',
request='Life',
... | [
"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... |
201cf4683d7f5f6f3b76fe38fbb37c25a7e14749 | sed-i/python-libjuju | juju/client/_client1.py | [
"Apache-2.0"
] | Python | Watch | <not_specific> | async def Watch(self, entities=None):
'''
Watch starts an NotifyWatcher for each given entity.
entities : typing.Sequence[~Entity]
Returns -> NotifyWatchResults
'''
if entities is not None and not isinstance(entities, (bytes, str, list)):
raise Exception("Exp... |
Watch starts an NotifyWatcher for each given entity.
entities : typing.Sequence[~Entity]
Returns -> NotifyWatchResults
| Watch starts an NotifyWatcher for each given entity.
entities : typing.Sequence[~Entity]
Returns -> NotifyWatchResults | [
"Watch",
"starts",
"an",
"NotifyWatcher",
"for",
"each",
"given",
"entity",
".",
"entities",
":",
"typing",
".",
"Sequence",
"[",
"~Entity",
"]",
"Returns",
"-",
">",
"NotifyWatchResults"
] | async def Watch(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='LifeFlag',
request='Watch',
... | [
"async",
"def",
"Watch",
"(",
"self",
",",
"entities",
"=",
"None",
")",
":",
"if",
"entities",
"is",
"not",
"None",
"and",
"not",
"isinstance",
"(",
"entities",
",",
"(",
"bytes",
",",
"str",
",",
"list",
")",
")",
":",
"raise",
"Exception",
"(",
... | Watch starts an NotifyWatcher for each given entity. | [
"Watch",
"starts",
"an",
"NotifyWatcher",
"for",
"each",
"given",
"entity",
"."
] | [
"'''\n Watch starts an NotifyWatcher for each given entity.\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... |
201cf4683d7f5f6f3b76fe38fbb37c25a7e14749 | sed-i/python-libjuju | juju/client/_client1.py | [
"Apache-2.0"
] | Python | GetLastSent | <not_specific> | async def GetLastSent(self, ids=None):
'''
GetLastSent is a bulk call that gets the log forwarding "last sent"
record ID for each requested target.
ids : typing.Sequence[~LogForwardingID]
Returns -> LogForwardingGetLastSentResults
'''
if ids is not None and not i... |
GetLastSent is a bulk call that gets the log forwarding "last sent"
record ID for each requested target.
ids : typing.Sequence[~LogForwardingID]
Returns -> LogForwardingGetLastSentResults
| GetLastSent is a bulk call that gets the log forwarding "last sent"
record ID for each requested target.
| [
"GetLastSent",
"is",
"a",
"bulk",
"call",
"that",
"gets",
"the",
"log",
"forwarding",
"\"",
"last",
"sent",
"\"",
"record",
"ID",
"for",
"each",
"requested",
"target",
"."
] | async def GetLastSent(self, ids=None):
if ids is not None and not isinstance(ids, (bytes, str, list)):
raise Exception("Expected ids to be a Sequence, received: {}".format(type(ids)))
_params = dict()
msg = dict(type='LogForwarding',
request='GetLastSent',
... | [
"async",
"def",
"GetLastSent",
"(",
"self",
",",
"ids",
"=",
"None",
")",
":",
"if",
"ids",
"is",
"not",
"None",
"and",
"not",
"isinstance",
"(",
"ids",
",",
"(",
"bytes",
",",
"str",
",",
"list",
")",
")",
":",
"raise",
"Exception",
"(",
"\"Expect... | GetLastSent is a bulk call that gets the log forwarding "last sent"
record ID for each requested target. | [
"GetLastSent",
"is",
"a",
"bulk",
"call",
"that",
"gets",
"the",
"log",
"forwarding",
"\"",
"last",
"sent",
"\"",
"record",
"ID",
"for",
"each",
"requested",
"target",
"."
] | [
"'''\n GetLastSent is a bulk call that gets the log forwarding \"last sent\"\n record ID for each requested target.\n\n ids : typing.Sequence[~LogForwardingID]\n Returns -> LogForwardingGetLastSentResults\n '''",
"# map input types to rpc msg"
] | [
{
"param": "self",
"type": null
},
{
"param": "ids",
"type": null
}
] | {
"returns": [],
"raises": [],
"params": [
{
"identifier": "self",
"type": null,
"docstring": null,
"docstring_tokens": [],
"default": null,
"is_optional": null
},
{
"identifier": "ids",
"type": null,
"docstring": null,
"docstring_tokens": []... |
201cf4683d7f5f6f3b76fe38fbb37c25a7e14749 | sed-i/python-libjuju | juju/client/_client1.py | [
"Apache-2.0"
] | Python | SetLastSent | <not_specific> | async def SetLastSent(self, params=None):
'''
SetLastSent is a bulk call that sets the log forwarding "last sent"
record ID for each requested target.
params : typing.Sequence[~LogForwardingSetLastSentParam]
Returns -> ErrorResults
'''
if params is not None and n... |
SetLastSent is a bulk call that sets the log forwarding "last sent"
record ID for each requested target.
params : typing.Sequence[~LogForwardingSetLastSentParam]
Returns -> ErrorResults
| SetLastSent is a bulk call that sets the log forwarding "last sent"
record ID for each requested target.
| [
"SetLastSent",
"is",
"a",
"bulk",
"call",
"that",
"sets",
"the",
"log",
"forwarding",
"\"",
"last",
"sent",
"\"",
"record",
"ID",
"for",
"each",
"requested",
"target",
"."
] | async def SetLastSent(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='LogForwarding',
request='SetLast... | [
"async",
"def",
"SetLastSent",
"(",
"self",
",",
"params",
"=",
"None",
")",
":",
"if",
"params",
"is",
"not",
"None",
"and",
"not",
"isinstance",
"(",
"params",
",",
"(",
"bytes",
",",
"str",
",",
"list",
")",
")",
":",
"raise",
"Exception",
"(",
... | SetLastSent is a bulk call that sets the log forwarding "last sent"
record ID for each requested target. | [
"SetLastSent",
"is",
"a",
"bulk",
"call",
"that",
"sets",
"the",
"log",
"forwarding",
"\"",
"last",
"sent",
"\"",
"record",
"ID",
"for",
"each",
"requested",
"target",
"."
] | [
"'''\n SetLastSent is a bulk call that sets the log forwarding \"last sent\"\n record ID for each requested target.\n\n params : typing.Sequence[~LogForwardingSetLastSentParam]\n Returns -> ErrorResults\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":... |
201cf4683d7f5f6f3b76fe38fbb37c25a7e14749 | sed-i/python-libjuju | juju/client/_client1.py | [
"Apache-2.0"
] | Python | LoggingConfig | <not_specific> | async def LoggingConfig(self, entities=None):
'''
LoggingConfig reports the logging configuration for the agents specified.
entities : typing.Sequence[~Entity]
Returns -> StringResults
'''
if entities is not None and not isinstance(entities, (bytes, str, list)):
... |
LoggingConfig reports the logging configuration for the agents specified.
entities : typing.Sequence[~Entity]
Returns -> StringResults
| LoggingConfig reports the logging configuration for the agents specified.
entities : typing.Sequence[~Entity]
Returns -> StringResults | [
"LoggingConfig",
"reports",
"the",
"logging",
"configuration",
"for",
"the",
"agents",
"specified",
".",
"entities",
":",
"typing",
".",
"Sequence",
"[",
"~Entity",
"]",
"Returns",
"-",
">",
"StringResults"
] | async def LoggingConfig(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='Logger',
request='Lo... | [
"async",
"def",
"LoggingConfig",
"(",
"self",
",",
"entities",
"=",
"None",
")",
":",
"if",
"entities",
"is",
"not",
"None",
"and",
"not",
"isinstance",
"(",
"entities",
",",
"(",
"bytes",
",",
"str",
",",
"list",
")",
")",
":",
"raise",
"Exception",
... | LoggingConfig reports the logging configuration for the agents specified. | [
"LoggingConfig",
"reports",
"the",
"logging",
"configuration",
"for",
"the",
"agents",
"specified",
"."
] | [
"'''\n LoggingConfig reports the logging configuration for the agents specified.\n\n entities : typing.Sequence[~Entity]\n Returns -> StringResults\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... |
201cf4683d7f5f6f3b76fe38fbb37c25a7e14749 | sed-i/python-libjuju | juju/client/_client1.py | [
"Apache-2.0"
] | Python | WatchLoggingConfig | <not_specific> | async def WatchLoggingConfig(self, entities=None):
'''
WatchLoggingConfig starts a watcher to track changes to the logging config
for the agents specified.. Unfortunately the current infrastructure makes
watching parts of the config non-trivial, so currently any change to the
co... |
WatchLoggingConfig starts a watcher to track changes to the logging config
for the agents specified.. Unfortunately the current infrastructure makes
watching parts of the config non-trivial, so currently any change to the
config will cause the watcher to notify the client.
ent... | WatchLoggingConfig starts a watcher to track changes to the logging config
for the agents specified.. Unfortunately the current infrastructure makes
watching parts of the config non-trivial, so currently any change to the
config will cause the watcher to notify the client.
entities : typing.Sequence[~Entity]
Returns ... | [
"WatchLoggingConfig",
"starts",
"a",
"watcher",
"to",
"track",
"changes",
"to",
"the",
"logging",
"config",
"for",
"the",
"agents",
"specified",
"..",
"Unfortunately",
"the",
"current",
"infrastructure",
"makes",
"watching",
"parts",
"of",
"the",
"config",
"non",
... | async def WatchLoggingConfig(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='Logger',
reques... | [
"async",
"def",
"WatchLoggingConfig",
"(",
"self",
",",
"entities",
"=",
"None",
")",
":",
"if",
"entities",
"is",
"not",
"None",
"and",
"not",
"isinstance",
"(",
"entities",
",",
"(",
"bytes",
",",
"str",
",",
"list",
")",
")",
":",
"raise",
"Exceptio... | WatchLoggingConfig starts a watcher to track changes to the logging config
for the agents specified.. | [
"WatchLoggingConfig",
"starts",
"a",
"watcher",
"to",
"track",
"changes",
"to",
"the",
"logging",
"config",
"for",
"the",
"agents",
"specified",
".."
] | [
"'''\n WatchLoggingConfig starts a watcher to track changes to the logging config\n for the agents specified.. Unfortunately the current infrastructure makes\n watching parts of the config non-trivial, so currently any change to the\n config will cause the watcher to notify the client.\... | [
{
"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... |
201cf4683d7f5f6f3b76fe38fbb37c25a7e14749 | sed-i/python-libjuju | juju/client/_client1.py | [
"Apache-2.0"
] | Python | Actions | <not_specific> | async def Actions(self, entities=None):
'''
Actions returns the Actions by Tags passed and ensures that the machine asking
for them is the machine that has the actions
entities : typing.Sequence[~Entity]
Returns -> ActionResults
'''
if entities is not None and no... |
Actions returns the Actions by Tags passed and ensures that the machine asking
for them is the machine that has the actions
entities : typing.Sequence[~Entity]
Returns -> ActionResults
| Actions returns the Actions by Tags passed and ensures that the machine asking
for them is the machine that has the actions
entities : typing.Sequence[~Entity]
Returns -> ActionResults | [
"Actions",
"returns",
"the",
"Actions",
"by",
"Tags",
"passed",
"and",
"ensures",
"that",
"the",
"machine",
"asking",
"for",
"them",
"is",
"the",
"machine",
"that",
"has",
"the",
"actions",
"entities",
":",
"typing",
".",
"Sequence",
"[",
"~Entity",
"]",
"... | async def Actions(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='MachineActions',
request='... | [
"async",
"def",
"Actions",
"(",
"self",
",",
"entities",
"=",
"None",
")",
":",
"if",
"entities",
"is",
"not",
"None",
"and",
"not",
"isinstance",
"(",
"entities",
",",
"(",
"bytes",
",",
"str",
",",
"list",
")",
")",
":",
"raise",
"Exception",
"(",
... | Actions returns the Actions by Tags passed and ensures that the machine asking
for them is the machine that has the actions | [
"Actions",
"returns",
"the",
"Actions",
"by",
"Tags",
"passed",
"and",
"ensures",
"that",
"the",
"machine",
"asking",
"for",
"them",
"is",
"the",
"machine",
"that",
"has",
"the",
"actions"
] | [
"'''\n Actions returns the Actions by Tags passed and ensures that the machine asking\n for them is the machine that has the actions\n\n entities : typing.Sequence[~Entity]\n Returns -> ActionResults\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... |
201cf4683d7f5f6f3b76fe38fbb37c25a7e14749 | sed-i/python-libjuju | juju/client/_client1.py | [
"Apache-2.0"
] | Python | BeginActions | <not_specific> | async def BeginActions(self, entities=None):
'''
BeginActions marks the actions represented by the passed in Tags as running.
entities : typing.Sequence[~Entity]
Returns -> ErrorResults
'''
if entities is not None and not isinstance(entities, (bytes, str, list)):
... |
BeginActions marks the actions represented by the passed in Tags as running.
entities : typing.Sequence[~Entity]
Returns -> ErrorResults
| BeginActions marks the actions represented by the passed in Tags as running.
entities : typing.Sequence[~Entity]
Returns -> ErrorResults | [
"BeginActions",
"marks",
"the",
"actions",
"represented",
"by",
"the",
"passed",
"in",
"Tags",
"as",
"running",
".",
"entities",
":",
"typing",
".",
"Sequence",
"[",
"~Entity",
"]",
"Returns",
"-",
">",
"ErrorResults"
] | async def BeginActions(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='MachineActions',
requ... | [
"async",
"def",
"BeginActions",
"(",
"self",
",",
"entities",
"=",
"None",
")",
":",
"if",
"entities",
"is",
"not",
"None",
"and",
"not",
"isinstance",
"(",
"entities",
",",
"(",
"bytes",
",",
"str",
",",
"list",
")",
")",
":",
"raise",
"Exception",
... | BeginActions marks the actions represented by the passed in Tags as running. | [
"BeginActions",
"marks",
"the",
"actions",
"represented",
"by",
"the",
"passed",
"in",
"Tags",
"as",
"running",
"."
] | [
"'''\n BeginActions marks the actions represented by the passed in Tags as running.\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... |
201cf4683d7f5f6f3b76fe38fbb37c25a7e14749 | sed-i/python-libjuju | juju/client/_client1.py | [
"Apache-2.0"
] | Python | FinishActions | <not_specific> | async def FinishActions(self, results=None):
'''
FinishActions saves the result of a completed Action
results : typing.Sequence[~ActionExecutionResult]
Returns -> ErrorResults
'''
if results is not None and not isinstance(results, (bytes, str, list)):
raise E... |
FinishActions saves the result of a completed Action
results : typing.Sequence[~ActionExecutionResult]
Returns -> ErrorResults
| FinishActions saves the result of a completed Action
results : typing.Sequence[~ActionExecutionResult]
Returns -> ErrorResults | [
"FinishActions",
"saves",
"the",
"result",
"of",
"a",
"completed",
"Action",
"results",
":",
"typing",
".",
"Sequence",
"[",
"~ActionExecutionResult",
"]",
"Returns",
"-",
">",
"ErrorResults"
] | async def FinishActions(self, results=None):
if results is not None and not isinstance(results, (bytes, str, list)):
raise Exception("Expected results to be a Sequence, received: {}".format(type(results)))
_params = dict()
msg = dict(type='MachineActions',
request=... | [
"async",
"def",
"FinishActions",
"(",
"self",
",",
"results",
"=",
"None",
")",
":",
"if",
"results",
"is",
"not",
"None",
"and",
"not",
"isinstance",
"(",
"results",
",",
"(",
"bytes",
",",
"str",
",",
"list",
")",
")",
":",
"raise",
"Exception",
"(... | FinishActions saves the result of a completed Action
results : typing.Sequence[~ActionExecutionResult]
Returns -> ErrorResults | [
"FinishActions",
"saves",
"the",
"result",
"of",
"a",
"completed",
"Action",
"results",
":",
"typing",
".",
"Sequence",
"[",
"~ActionExecutionResult",
"]",
"Returns",
"-",
">",
"ErrorResults"
] | [
"'''\n FinishActions saves the result of a completed Action\n\n results : typing.Sequence[~ActionExecutionResult]\n Returns -> ErrorResults\n '''",
"# map input types to rpc msg"
] | [
{
"param": "self",
"type": null
},
{
"param": "results",
"type": null
}
] | {
"returns": [],
"raises": [],
"params": [
{
"identifier": "self",
"type": null,
"docstring": null,
"docstring_tokens": [],
"default": null,
"is_optional": null
},
{
"identifier": "results",
"type": null,
"docstring": null,
"docstring_tokens"... |
201cf4683d7f5f6f3b76fe38fbb37c25a7e14749 | sed-i/python-libjuju | juju/client/_client1.py | [
"Apache-2.0"
] | Python | RunningActions | <not_specific> | async def RunningActions(self, entities=None):
'''
RunningActions lists the actions running for the entities passed in.
If we end up needing more than ListRunning at some point we could follow/abstract
what's done in the client actions package.
entities : typing.Sequence[~Entity... |
RunningActions lists the actions running for the entities passed in.
If we end up needing more than ListRunning at some point we could follow/abstract
what's done in the client actions package.
entities : typing.Sequence[~Entity]
Returns -> ActionsByReceivers
| RunningActions lists the actions running for the entities passed in.
If we end up needing more than ListRunning at some point we could follow/abstract
what's done in the client actions package.
entities : typing.Sequence[~Entity]
Returns -> ActionsByReceivers | [
"RunningActions",
"lists",
"the",
"actions",
"running",
"for",
"the",
"entities",
"passed",
"in",
".",
"If",
"we",
"end",
"up",
"needing",
"more",
"than",
"ListRunning",
"at",
"some",
"point",
"we",
"could",
"follow",
"/",
"abstract",
"what",
"'",
"s",
"do... | async def RunningActions(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='MachineActions',
re... | [
"async",
"def",
"RunningActions",
"(",
"self",
",",
"entities",
"=",
"None",
")",
":",
"if",
"entities",
"is",
"not",
"None",
"and",
"not",
"isinstance",
"(",
"entities",
",",
"(",
"bytes",
",",
"str",
",",
"list",
")",
")",
":",
"raise",
"Exception",
... | RunningActions lists the actions running for the entities passed in. | [
"RunningActions",
"lists",
"the",
"actions",
"running",
"for",
"the",
"entities",
"passed",
"in",
"."
] | [
"'''\n RunningActions lists the actions running for the entities passed in.\n If we end up needing more than ListRunning at some point we could follow/abstract\n what's done in the client actions package.\n\n entities : typing.Sequence[~Entity]\n Returns -> ActionsByReceivers\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... |
201cf4683d7f5f6f3b76fe38fbb37c25a7e14749 | sed-i/python-libjuju | juju/client/_client1.py | [
"Apache-2.0"
] | Python | WatchActionNotifications | <not_specific> | async def WatchActionNotifications(self, entities=None):
'''
WatchActionNotifications returns a StringsWatcher for observing
incoming action calls to a machine.
entities : typing.Sequence[~Entity]
Returns -> StringsWatchResults
'''
if entities is not None and not... |
WatchActionNotifications returns a StringsWatcher for observing
incoming action calls to a machine.
entities : typing.Sequence[~Entity]
Returns -> StringsWatchResults
| WatchActionNotifications returns a StringsWatcher for observing
incoming action calls to a machine.
entities : typing.Sequence[~Entity]
Returns -> StringsWatchResults | [
"WatchActionNotifications",
"returns",
"a",
"StringsWatcher",
"for",
"observing",
"incoming",
"action",
"calls",
"to",
"a",
"machine",
".",
"entities",
":",
"typing",
".",
"Sequence",
"[",
"~Entity",
"]",
"Returns",
"-",
">",
"StringsWatchResults"
] | async def WatchActionNotifications(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='MachineActions',
... | [
"async",
"def",
"WatchActionNotifications",
"(",
"self",
",",
"entities",
"=",
"None",
")",
":",
"if",
"entities",
"is",
"not",
"None",
"and",
"not",
"isinstance",
"(",
"entities",
",",
"(",
"bytes",
",",
"str",
",",
"list",
")",
")",
":",
"raise",
"Ex... | WatchActionNotifications returns a StringsWatcher for observing
incoming action calls to a machine. | [
"WatchActionNotifications",
"returns",
"a",
"StringsWatcher",
"for",
"observing",
"incoming",
"action",
"calls",
"to",
"a",
"machine",
"."
] | [
"'''\n WatchActionNotifications returns a StringsWatcher for observing\n incoming action calls to a machine.\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... |
201cf4683d7f5f6f3b76fe38fbb37c25a7e14749 | sed-i/python-libjuju | juju/client/_client1.py | [
"Apache-2.0"
] | Python | AllMachineRemovals | <not_specific> | async def AllMachineRemovals(self, entities=None):
'''
AllMachineRemovals returns tags for all of the machines that have
been marked for removal in the requested model.
entities : typing.Sequence[~Entity]
Returns -> EntitiesResults
'''
if entities is not None and... |
AllMachineRemovals returns tags for all of the machines that have
been marked for removal in the requested model.
entities : typing.Sequence[~Entity]
Returns -> EntitiesResults
| AllMachineRemovals returns tags for all of the machines that have
been marked for removal in the requested model.
entities : typing.Sequence[~Entity]
Returns -> EntitiesResults | [
"AllMachineRemovals",
"returns",
"tags",
"for",
"all",
"of",
"the",
"machines",
"that",
"have",
"been",
"marked",
"for",
"removal",
"in",
"the",
"requested",
"model",
".",
"entities",
":",
"typing",
".",
"Sequence",
"[",
"~Entity",
"]",
"Returns",
"-",
">",
... | async def AllMachineRemovals(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='MachineUndertaker',
... | [
"async",
"def",
"AllMachineRemovals",
"(",
"self",
",",
"entities",
"=",
"None",
")",
":",
"if",
"entities",
"is",
"not",
"None",
"and",
"not",
"isinstance",
"(",
"entities",
",",
"(",
"bytes",
",",
"str",
",",
"list",
")",
")",
":",
"raise",
"Exceptio... | AllMachineRemovals returns tags for all of the machines that have
been marked for removal in the requested model. | [
"AllMachineRemovals",
"returns",
"tags",
"for",
"all",
"of",
"the",
"machines",
"that",
"have",
"been",
"marked",
"for",
"removal",
"in",
"the",
"requested",
"model",
"."
] | [
"'''\n AllMachineRemovals returns tags for all of the machines that have\n been marked for removal in the requested model.\n\n entities : typing.Sequence[~Entity]\n Returns -> EntitiesResults\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... |
201cf4683d7f5f6f3b76fe38fbb37c25a7e14749 | sed-i/python-libjuju | juju/client/_client1.py | [
"Apache-2.0"
] | Python | CompleteMachineRemovals | <not_specific> | async def CompleteMachineRemovals(self, entities=None):
'''
CompleteMachineRemovals removes the specified machines from the
model database. It should only be called once any provider-level
cleanup has been done for those machines.
entities : typing.Sequence[~Entity]
Retu... |
CompleteMachineRemovals removes the specified machines from the
model database. It should only be called once any provider-level
cleanup has been done for those machines.
entities : typing.Sequence[~Entity]
Returns -> None
| CompleteMachineRemovals removes the specified machines from the
model database. It should only be called once any provider-level
cleanup has been done for those machines.
entities : typing.Sequence[~Entity]
Returns -> None | [
"CompleteMachineRemovals",
"removes",
"the",
"specified",
"machines",
"from",
"the",
"model",
"database",
".",
"It",
"should",
"only",
"be",
"called",
"once",
"any",
"provider",
"-",
"level",
"cleanup",
"has",
"been",
"done",
"for",
"those",
"machines",
".",
"... | async def CompleteMachineRemovals(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='MachineUndertaker',
... | [
"async",
"def",
"CompleteMachineRemovals",
"(",
"self",
",",
"entities",
"=",
"None",
")",
":",
"if",
"entities",
"is",
"not",
"None",
"and",
"not",
"isinstance",
"(",
"entities",
",",
"(",
"bytes",
",",
"str",
",",
"list",
")",
")",
":",
"raise",
"Exc... | CompleteMachineRemovals removes the specified machines from the
model database. | [
"CompleteMachineRemovals",
"removes",
"the",
"specified",
"machines",
"from",
"the",
"model",
"database",
"."
] | [
"'''\n CompleteMachineRemovals removes the specified machines from the\n model database. It should only be called once any provider-level\n cleanup has been done for those machines.\n\n entities : typing.Sequence[~Entity]\n Returns -> None\n '''",
"# map input types to rp... | [
{
"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... |
201cf4683d7f5f6f3b76fe38fbb37c25a7e14749 | sed-i/python-libjuju | juju/client/_client1.py | [
"Apache-2.0"
] | Python | GetMachineProviderInterfaceInfo | <not_specific> | async def GetMachineProviderInterfaceInfo(self, entities=None):
'''
GetMachineProviderInterfaceInfo returns the provider details for
all network interfaces attached to the machines requested.
entities : typing.Sequence[~Entity]
Returns -> ProviderInterfaceInfoResults
'''... |
GetMachineProviderInterfaceInfo returns the provider details for
all network interfaces attached to the machines requested.
entities : typing.Sequence[~Entity]
Returns -> ProviderInterfaceInfoResults
| GetMachineProviderInterfaceInfo returns the provider details for
all network interfaces attached to the machines requested.
entities : typing.Sequence[~Entity]
Returns -> ProviderInterfaceInfoResults | [
"GetMachineProviderInterfaceInfo",
"returns",
"the",
"provider",
"details",
"for",
"all",
"network",
"interfaces",
"attached",
"to",
"the",
"machines",
"requested",
".",
"entities",
":",
"typing",
".",
"Sequence",
"[",
"~Entity",
"]",
"Returns",
"-",
">",
"Provide... | async def GetMachineProviderInterfaceInfo(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='MachineUndertaker',
... | [
"async",
"def",
"GetMachineProviderInterfaceInfo",
"(",
"self",
",",
"entities",
"=",
"None",
")",
":",
"if",
"entities",
"is",
"not",
"None",
"and",
"not",
"isinstance",
"(",
"entities",
",",
"(",
"bytes",
",",
"str",
",",
"list",
")",
")",
":",
"raise"... | GetMachineProviderInterfaceInfo returns the provider details for
all network interfaces attached to the machines requested. | [
"GetMachineProviderInterfaceInfo",
"returns",
"the",
"provider",
"details",
"for",
"all",
"network",
"interfaces",
"attached",
"to",
"the",
"machines",
"requested",
"."
] | [
"'''\n GetMachineProviderInterfaceInfo returns the provider details for\n all network interfaces attached to the machines requested.\n\n entities : typing.Sequence[~Entity]\n Returns -> ProviderInterfaceInfoResults\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... |
201cf4683d7f5f6f3b76fe38fbb37c25a7e14749 | sed-i/python-libjuju | juju/client/_client1.py | [
"Apache-2.0"
] | Python | WatchMachineRemovals | <not_specific> | async def WatchMachineRemovals(self, entities=None):
'''
WatchMachineRemovals returns a watcher that will signal each time a
machine is marked for removal.
entities : typing.Sequence[~Entity]
Returns -> NotifyWatchResults
'''
if entities is not None and not isins... |
WatchMachineRemovals returns a watcher that will signal each time a
machine is marked for removal.
entities : typing.Sequence[~Entity]
Returns -> NotifyWatchResults
| WatchMachineRemovals returns a watcher that will signal each time a
machine is marked for removal.
entities : typing.Sequence[~Entity]
Returns -> NotifyWatchResults | [
"WatchMachineRemovals",
"returns",
"a",
"watcher",
"that",
"will",
"signal",
"each",
"time",
"a",
"machine",
"is",
"marked",
"for",
"removal",
".",
"entities",
":",
"typing",
".",
"Sequence",
"[",
"~Entity",
"]",
"Returns",
"-",
">",
"NotifyWatchResults"
] | async def WatchMachineRemovals(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='MachineUndertaker',
... | [
"async",
"def",
"WatchMachineRemovals",
"(",
"self",
",",
"entities",
"=",
"None",
")",
":",
"if",
"entities",
"is",
"not",
"None",
"and",
"not",
"isinstance",
"(",
"entities",
",",
"(",
"bytes",
",",
"str",
",",
"list",
")",
")",
":",
"raise",
"Except... | WatchMachineRemovals returns a watcher that will signal each time a
machine is marked for removal. | [
"WatchMachineRemovals",
"returns",
"a",
"watcher",
"that",
"will",
"signal",
"each",
"time",
"a",
"machine",
"is",
"marked",
"for",
"removal",
"."
] | [
"'''\n WatchMachineRemovals returns a watcher that will signal each time a\n machine is marked for removal.\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... |
201cf4683d7f5f6f3b76fe38fbb37c25a7e14749 | sed-i/python-libjuju | juju/client/_client1.py | [
"Apache-2.0"
] | Python | AddJujuMachineMetrics | <not_specific> | async def AddJujuMachineMetrics(self):
'''
AddJujuMachineMetrics adds a metric that counts the number of
non-container machines in the current model.
Returns -> None
'''
# map input types to rpc msg
_params = dict()
msg = dict(type='MetricsManager',
... |
AddJujuMachineMetrics adds a metric that counts the number of
non-container machines in the current model.
Returns -> None
| AddJujuMachineMetrics adds a metric that counts the number of
non-container machines in the current model.
> None | [
"AddJujuMachineMetrics",
"adds",
"a",
"metric",
"that",
"counts",
"the",
"number",
"of",
"non",
"-",
"container",
"machines",
"in",
"the",
"current",
"model",
".",
">",
"None"
] | async def AddJujuMachineMetrics(self):
_params = dict()
msg = dict(type='MetricsManager',
request='AddJujuMachineMetrics',
version=1,
params=_params)
reply = await self.rpc(msg)
return reply | [
"async",
"def",
"AddJujuMachineMetrics",
"(",
"self",
")",
":",
"_params",
"=",
"dict",
"(",
")",
"msg",
"=",
"dict",
"(",
"type",
"=",
"'MetricsManager'",
",",
"request",
"=",
"'AddJujuMachineMetrics'",
",",
"version",
"=",
"1",
",",
"params",
"=",
"_para... | AddJujuMachineMetrics adds a metric that counts the number of
non-container machines in the current model. | [
"AddJujuMachineMetrics",
"adds",
"a",
"metric",
"that",
"counts",
"the",
"number",
"of",
"non",
"-",
"container",
"machines",
"in",
"the",
"current",
"model",
"."
] | [
"'''\n AddJujuMachineMetrics adds a metric that counts the number of\n non-container machines in the current model.\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": []
} |
201cf4683d7f5f6f3b76fe38fbb37c25a7e14749 | sed-i/python-libjuju | juju/client/_client1.py | [
"Apache-2.0"
] | Python | CleanupOldMetrics | <not_specific> | async def CleanupOldMetrics(self, entities=None):
'''
CleanupOldMetrics removes old metrics from the collection.
The single arg params is expected to contain and model uuid.
Even though the call will delete all metrics across models
it serves to validate that the connection has a... |
CleanupOldMetrics removes old metrics from the collection.
The single arg params is expected to contain and model uuid.
Even though the call will delete all metrics across models
it serves to validate that the connection has access to at least one model.
entities : typing.Seque... | CleanupOldMetrics removes old metrics from the collection.
The single arg params is expected to contain and model uuid.
Even though the call will delete all metrics across models
it serves to validate that the connection has access to at least one model.
entities : typing.Sequence[~Entity]
Returns -> ErrorResults | [
"CleanupOldMetrics",
"removes",
"old",
"metrics",
"from",
"the",
"collection",
".",
"The",
"single",
"arg",
"params",
"is",
"expected",
"to",
"contain",
"and",
"model",
"uuid",
".",
"Even",
"though",
"the",
"call",
"will",
"delete",
"all",
"metrics",
"across",... | async def CleanupOldMetrics(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='MetricsManager',
... | [
"async",
"def",
"CleanupOldMetrics",
"(",
"self",
",",
"entities",
"=",
"None",
")",
":",
"if",
"entities",
"is",
"not",
"None",
"and",
"not",
"isinstance",
"(",
"entities",
",",
"(",
"bytes",
",",
"str",
",",
"list",
")",
")",
":",
"raise",
"Exception... | CleanupOldMetrics removes old metrics from the collection. | [
"CleanupOldMetrics",
"removes",
"old",
"metrics",
"from",
"the",
"collection",
"."
] | [
"'''\n CleanupOldMetrics removes old metrics from the collection.\n The single arg params is expected to contain and model uuid.\n Even though the call will delete all metrics across models\n it serves to validate that the connection has access to at least one model.\n\n entities ... | [
{
"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... |
201cf4683d7f5f6f3b76fe38fbb37c25a7e14749 | sed-i/python-libjuju | juju/client/_client1.py | [
"Apache-2.0"
] | Python | SendMetrics | <not_specific> | async def SendMetrics(self, entities=None):
'''
SendMetrics will send any unsent metrics onto the metric collection service.
entities : typing.Sequence[~Entity]
Returns -> ErrorResults
'''
if entities is not None and not isinstance(entities, (bytes, str, list)):
... |
SendMetrics will send any unsent metrics onto the metric collection service.
entities : typing.Sequence[~Entity]
Returns -> ErrorResults
| SendMetrics will send any unsent metrics onto the metric collection service.
entities : typing.Sequence[~Entity]
Returns -> ErrorResults | [
"SendMetrics",
"will",
"send",
"any",
"unsent",
"metrics",
"onto",
"the",
"metric",
"collection",
"service",
".",
"entities",
":",
"typing",
".",
"Sequence",
"[",
"~Entity",
"]",
"Returns",
"-",
">",
"ErrorResults"
] | async def SendMetrics(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='MetricsManager',
reque... | [
"async",
"def",
"SendMetrics",
"(",
"self",
",",
"entities",
"=",
"None",
")",
":",
"if",
"entities",
"is",
"not",
"None",
"and",
"not",
"isinstance",
"(",
"entities",
",",
"(",
"bytes",
",",
"str",
",",
"list",
")",
")",
":",
"raise",
"Exception",
"... | SendMetrics will send any unsent metrics onto the metric collection service. | [
"SendMetrics",
"will",
"send",
"any",
"unsent",
"metrics",
"onto",
"the",
"metric",
"collection",
"service",
"."
] | [
"'''\n SendMetrics will send any unsent metrics onto the metric collection service.\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... |
201cf4683d7f5f6f3b76fe38fbb37c25a7e14749 | sed-i/python-libjuju | juju/client/_client1.py | [
"Apache-2.0"
] | Python | Phase | <not_specific> | async def Phase(self, entities=None):
'''
Phase returns the current migration phase or an error for every
supplied entity.
entities : typing.Sequence[~Entity]
Returns -> PhaseResults
'''
if entities is not None and not isinstance(entities, (bytes, str, list)):
... |
Phase returns the current migration phase or an error for every
supplied entity.
entities : typing.Sequence[~Entity]
Returns -> PhaseResults
| Phase returns the current migration phase or an error for every
supplied entity.
entities : typing.Sequence[~Entity]
Returns -> PhaseResults | [
"Phase",
"returns",
"the",
"current",
"migration",
"phase",
"or",
"an",
"error",
"for",
"every",
"supplied",
"entity",
".",
"entities",
":",
"typing",
".",
"Sequence",
"[",
"~Entity",
"]",
"Returns",
"-",
">",
"PhaseResults"
] | async def Phase(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='MigrationFlag',
request='Pha... | [
"async",
"def",
"Phase",
"(",
"self",
",",
"entities",
"=",
"None",
")",
":",
"if",
"entities",
"is",
"not",
"None",
"and",
"not",
"isinstance",
"(",
"entities",
",",
"(",
"bytes",
",",
"str",
",",
"list",
")",
")",
":",
"raise",
"Exception",
"(",
... | Phase returns the current migration phase or an error for every
supplied entity. | [
"Phase",
"returns",
"the",
"current",
"migration",
"phase",
"or",
"an",
"error",
"for",
"every",
"supplied",
"entity",
"."
] | [
"'''\n Phase returns the current migration phase or an error for every\n supplied entity.\n\n entities : typing.Sequence[~Entity]\n Returns -> PhaseResults\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... |
201cf4683d7f5f6f3b76fe38fbb37c25a7e14749 | sed-i/python-libjuju | juju/client/_client1.py | [
"Apache-2.0"
] | Python | Watch | <not_specific> | async def Watch(self, entities=None):
'''
Watch returns an id for use with the NotifyWatcher facade, or an
error, for every supplied entity.
entities : typing.Sequence[~Entity]
Returns -> NotifyWatchResults
'''
if entities is not None and not isinstance(entities,... |
Watch returns an id for use with the NotifyWatcher facade, or an
error, for every supplied entity.
entities : typing.Sequence[~Entity]
Returns -> NotifyWatchResults
| Watch returns an id for use with the NotifyWatcher facade, or an
error, for every supplied entity.
entities : typing.Sequence[~Entity]
Returns -> NotifyWatchResults | [
"Watch",
"returns",
"an",
"id",
"for",
"use",
"with",
"the",
"NotifyWatcher",
"facade",
"or",
"an",
"error",
"for",
"every",
"supplied",
"entity",
".",
"entities",
":",
"typing",
".",
"Sequence",
"[",
"~Entity",
"]",
"Returns",
"-",
">",
"NotifyWatchResults"... | async def Watch(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='MigrationFlag',
request='Wat... | [
"async",
"def",
"Watch",
"(",
"self",
",",
"entities",
"=",
"None",
")",
":",
"if",
"entities",
"is",
"not",
"None",
"and",
"not",
"isinstance",
"(",
"entities",
",",
"(",
"bytes",
",",
"str",
",",
"list",
")",
")",
":",
"raise",
"Exception",
"(",
... | Watch returns an id for use with the NotifyWatcher facade, or an
error, for every supplied entity. | [
"Watch",
"returns",
"an",
"id",
"for",
"use",
"with",
"the",
"NotifyWatcher",
"facade",
"or",
"an",
"error",
"for",
"every",
"supplied",
"entity",
"."
] | [
"'''\n Watch returns an id for use with the NotifyWatcher facade, or an\n error, for every supplied entity.\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... |
201cf4683d7f5f6f3b76fe38fbb37c25a7e14749 | sed-i/python-libjuju | juju/client/_client1.py | [
"Apache-2.0"
] | Python | Report | <not_specific> | async def Report(self, migration_id=None, phase=None, success=None):
'''
Report allows a migration minion to submit whether it succeeded or
failed for a specific migration phase.
migration_id : str
phase : str
success : bool
Returns -> None
'''
if... |
Report allows a migration minion to submit whether it succeeded or
failed for a specific migration phase.
migration_id : str
phase : str
success : bool
Returns -> None
| Report allows a migration minion to submit whether it succeeded or
failed for a specific migration phase.
migration_id : str
phase : str
success : bool
Returns -> None | [
"Report",
"allows",
"a",
"migration",
"minion",
"to",
"submit",
"whether",
"it",
"succeeded",
"or",
"failed",
"for",
"a",
"specific",
"migration",
"phase",
".",
"migration_id",
":",
"str",
"phase",
":",
"str",
"success",
":",
"bool",
"Returns",
"-",
">",
"... | async def Report(self, migration_id=None, phase=None, success=None):
if migration_id is not None and not isinstance(migration_id, (bytes, str)):
raise Exception("Expected migration_id to be a str, received: {}".format(type(migration_id)))
if phase is not None and not isinstance(phase, (bytes... | [
"async",
"def",
"Report",
"(",
"self",
",",
"migration_id",
"=",
"None",
",",
"phase",
"=",
"None",
",",
"success",
"=",
"None",
")",
":",
"if",
"migration_id",
"is",
"not",
"None",
"and",
"not",
"isinstance",
"(",
"migration_id",
",",
"(",
"bytes",
",... | Report allows a migration minion to submit whether it succeeded or
failed for a specific migration phase. | [
"Report",
"allows",
"a",
"migration",
"minion",
"to",
"submit",
"whether",
"it",
"succeeded",
"or",
"failed",
"for",
"a",
"specific",
"migration",
"phase",
"."
] | [
"'''\n Report allows a migration minion to submit whether it succeeded or\n failed for a specific migration phase.\n\n migration_id : str\n phase : str\n success : bool\n Returns -> None\n '''",
"# map input types to rpc msg"
] | [
{
"param": "self",
"type": null
},
{
"param": "migration_id",
"type": null
},
{
"param": "phase",
"type": null
},
{
"param": "success",
"type": null
}
] | {
"returns": [],
"raises": [],
"params": [
{
"identifier": "self",
"type": null,
"docstring": null,
"docstring_tokens": [],
"default": null,
"is_optional": null
},
{
"identifier": "migration_id",
"type": null,
"docstring": null,
"docstring_to... |
201cf4683d7f5f6f3b76fe38fbb37c25a7e14749 | sed-i/python-libjuju | juju/client/_client1.py | [
"Apache-2.0"
] | Python | Watch | <not_specific> | async def Watch(self):
'''
Watch starts watching for status updates for a migration attempt
for the model. It will report when a migration starts and when its
status changes (including when it finishes). An initial event will
be fired if there has ever been a migration attempt fo... |
Watch starts watching for status updates for a migration attempt
for the model. It will report when a migration starts and when its
status changes (including when it finishes). An initial event will
be fired if there has ever been a migration attempt for the model.
The Migratio... | Watch starts watching for status updates for a migration attempt
for the model. It will report when a migration starts and when its
status changes (including when it finishes). An initial event will
be fired if there has ever been a migration attempt for the model.
The MigrationStatusWatcher facade must be used to rec... | [
"Watch",
"starts",
"watching",
"for",
"status",
"updates",
"for",
"a",
"migration",
"attempt",
"for",
"the",
"model",
".",
"It",
"will",
"report",
"when",
"a",
"migration",
"starts",
"and",
"when",
"its",
"status",
"changes",
"(",
"including",
"when",
"it",
... | async def Watch(self):
_params = dict()
msg = dict(type='MigrationMinion',
request='Watch',
version=1,
params=_params)
reply = await self.rpc(msg)
return reply | [
"async",
"def",
"Watch",
"(",
"self",
")",
":",
"_params",
"=",
"dict",
"(",
")",
"msg",
"=",
"dict",
"(",
"type",
"=",
"'MigrationMinion'",
",",
"request",
"=",
"'Watch'",
",",
"version",
"=",
"1",
",",
"params",
"=",
"_params",
")",
"reply",
"=",
... | Watch starts watching for status updates for a migration attempt
for the model. | [
"Watch",
"starts",
"watching",
"for",
"status",
"updates",
"for",
"a",
"migration",
"attempt",
"for",
"the",
"model",
"."
] | [
"'''\n Watch starts watching for status updates for a migration attempt\n for the model. It will report when a migration starts and when its\n status changes (including when it finishes). An initial event will\n be fired if there has ever been a migration attempt for the model.\n\n ... | [
{
"param": "self",
"type": null
}
] | {
"returns": [],
"raises": [],
"params": [
{
"identifier": "self",
"type": null,
"docstring": null,
"docstring_tokens": [],
"default": null,
"is_optional": null
}
],
"outlier_params": [],
"others": []
} |
201cf4683d7f5f6f3b76fe38fbb37c25a7e14749 | sed-i/python-libjuju | juju/client/_client1.py | [
"Apache-2.0"
] | Python | Next | <not_specific> | async def Next(self):
'''
Next returns when the status for a model migration for the
associated model changes. The current details for the active
migration are returned.
Returns -> MigrationStatus
'''
# map input types to rpc msg
_params = dict()
... |
Next returns when the status for a model migration for the
associated model changes. The current details for the active
migration are returned.
Returns -> MigrationStatus
| Next returns when the status for a model migration for the
associated model changes. The current details for the active
migration are returned.
| [
"Next",
"returns",
"when",
"the",
"status",
"for",
"a",
"model",
"migration",
"for",
"the",
"associated",
"model",
"changes",
".",
"The",
"current",
"details",
"for",
"the",
"active",
"migration",
"are",
"returned",
"."
] | async def Next(self):
_params = dict()
msg = dict(type='MigrationStatusWatcher',
request='Next',
version=1,
params=_params)
reply = await self.rpc(msg)
return reply | [
"async",
"def",
"Next",
"(",
"self",
")",
":",
"_params",
"=",
"dict",
"(",
")",
"msg",
"=",
"dict",
"(",
"type",
"=",
"'MigrationStatusWatcher'",
",",
"request",
"=",
"'Next'",
",",
"version",
"=",
"1",
",",
"params",
"=",
"_params",
")",
"reply",
"... | Next returns when the status for a model migration for the
associated model changes. | [
"Next",
"returns",
"when",
"the",
"status",
"for",
"a",
"model",
"migration",
"for",
"the",
"associated",
"model",
"changes",
"."
] | [
"'''\n Next returns when the status for a model migration for the\n associated model changes. The current details for the active\n migration are returned.\n\n\n Returns -> MigrationStatus\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": []
} |
201cf4683d7f5f6f3b76fe38fbb37c25a7e14749 | sed-i/python-libjuju | juju/client/_client1.py | [
"Apache-2.0"
] | Python | Abort | <not_specific> | async def Abort(self, model_tag=None):
'''
Abort removes the specified model from the database. It is an error to
attempt to Abort a model that has a migration mode other than importing.
model_tag : str
Returns -> None
'''
if model_tag is not None and not isinsta... |
Abort removes the specified model from the database. It is an error to
attempt to Abort a model that has a migration mode other than importing.
model_tag : str
Returns -> None
| Abort removes the specified model from the database. It is an error to
attempt to Abort a model that has a migration mode other than importing.
model_tag : str
Returns -> None | [
"Abort",
"removes",
"the",
"specified",
"model",
"from",
"the",
"database",
".",
"It",
"is",
"an",
"error",
"to",
"attempt",
"to",
"Abort",
"a",
"model",
"that",
"has",
"a",
"migration",
"mode",
"other",
"than",
"importing",
".",
"model_tag",
":",
"str",
... | async def Abort(self, model_tag=None):
if model_tag is not None and not isinstance(model_tag, (bytes, str)):
raise Exception("Expected model_tag to be a str, received: {}".format(type(model_tag)))
_params = dict()
msg = dict(type='MigrationTarget',
request='Abort',... | [
"async",
"def",
"Abort",
"(",
"self",
",",
"model_tag",
"=",
"None",
")",
":",
"if",
"model_tag",
"is",
"not",
"None",
"and",
"not",
"isinstance",
"(",
"model_tag",
",",
"(",
"bytes",
",",
"str",
")",
")",
":",
"raise",
"Exception",
"(",
"\"Expected mo... | Abort removes the specified model from the database. | [
"Abort",
"removes",
"the",
"specified",
"model",
"from",
"the",
"database",
"."
] | [
"'''\n Abort removes the specified model from the database. It is an error to\n attempt to Abort a model that has a migration mode other than importing.\n\n model_tag : str\n Returns -> None\n '''",
"# map input types to rpc msg"
] | [
{
"param": "self",
"type": null
},
{
"param": "model_tag",
"type": null
}
] | {
"returns": [],
"raises": [],
"params": [
{
"identifier": "self",
"type": null,
"docstring": null,
"docstring_tokens": [],
"default": null,
"is_optional": null
},
{
"identifier": "model_tag",
"type": null,
"docstring": null,
"docstring_token... |
201cf4683d7f5f6f3b76fe38fbb37c25a7e14749 | sed-i/python-libjuju | juju/client/_client1.py | [
"Apache-2.0"
] | Python | Activate | <not_specific> | async def Activate(self, model_tag=None):
'''
Activate sets the migration mode of the model to "none", meaning it
is ready for use. It is an error to attempt to Abort a model that
has a migration mode other than importing.
model_tag : str
Returns -> None
'''
... |
Activate sets the migration mode of the model to "none", meaning it
is ready for use. It is an error to attempt to Abort a model that
has a migration mode other than importing.
model_tag : str
Returns -> None
| Activate sets the migration mode of the model to "none", meaning it
is ready for use. It is an error to attempt to Abort a model that
has a migration mode other than importing.
model_tag : str
Returns -> None | [
"Activate",
"sets",
"the",
"migration",
"mode",
"of",
"the",
"model",
"to",
"\"",
"none",
"\"",
"meaning",
"it",
"is",
"ready",
"for",
"use",
".",
"It",
"is",
"an",
"error",
"to",
"attempt",
"to",
"Abort",
"a",
"model",
"that",
"has",
"a",
"migration",... | async def Activate(self, model_tag=None):
if model_tag is not None and not isinstance(model_tag, (bytes, str)):
raise Exception("Expected model_tag to be a str, received: {}".format(type(model_tag)))
_params = dict()
msg = dict(type='MigrationTarget',
request='Acti... | [
"async",
"def",
"Activate",
"(",
"self",
",",
"model_tag",
"=",
"None",
")",
":",
"if",
"model_tag",
"is",
"not",
"None",
"and",
"not",
"isinstance",
"(",
"model_tag",
",",
"(",
"bytes",
",",
"str",
")",
")",
":",
"raise",
"Exception",
"(",
"\"Expected... | Activate sets the migration mode of the model to "none", meaning it
is ready for use. | [
"Activate",
"sets",
"the",
"migration",
"mode",
"of",
"the",
"model",
"to",
"\"",
"none",
"\"",
"meaning",
"it",
"is",
"ready",
"for",
"use",
"."
] | [
"'''\n Activate sets the migration mode of the model to \"none\", meaning it\n is ready for use. It is an error to attempt to Abort a model that\n has a migration mode other than importing.\n\n model_tag : str\n Returns -> None\n '''",
"# map input types to rpc msg"
] | [
{
"param": "self",
"type": null
},
{
"param": "model_tag",
"type": null
}
] | {
"returns": [],
"raises": [],
"params": [
{
"identifier": "self",
"type": null,
"docstring": null,
"docstring_tokens": [],
"default": null,
"is_optional": null
},
{
"identifier": "model_tag",
"type": null,
"docstring": null,
"docstring_token... |
201cf4683d7f5f6f3b76fe38fbb37c25a7e14749 | sed-i/python-libjuju | juju/client/_client1.py | [
"Apache-2.0"
] | Python | AdoptResources | <not_specific> | async def AdoptResources(self, model_tag=None, source_controller_version=None):
'''
AdoptResources asks the cloud provider to update the controller
tags for a model's resources. This prevents the resources from
being destroyed if the source controller is destroyed after the
model... |
AdoptResources asks the cloud provider to update the controller
tags for a model's resources. This prevents the resources from
being destroyed if the source controller is destroyed after the
model is migrated away.
model_tag : str
source_controller_version : Number
... | AdoptResources asks the cloud provider to update the controller
tags for a model's resources. This prevents the resources from
being destroyed if the source controller is destroyed after the
model is migrated away.
model_tag : str
source_controller_version : Number
Returns -> None | [
"AdoptResources",
"asks",
"the",
"cloud",
"provider",
"to",
"update",
"the",
"controller",
"tags",
"for",
"a",
"model",
"'",
"s",
"resources",
".",
"This",
"prevents",
"the",
"resources",
"from",
"being",
"destroyed",
"if",
"the",
"source",
"controller",
"is",... | async def AdoptResources(self, model_tag=None, source_controller_version=None):
if model_tag is not None and not isinstance(model_tag, (bytes, str)):
raise Exception("Expected model_tag to be a str, received: {}".format(type(model_tag)))
if source_controller_version is not None and not isins... | [
"async",
"def",
"AdoptResources",
"(",
"self",
",",
"model_tag",
"=",
"None",
",",
"source_controller_version",
"=",
"None",
")",
":",
"if",
"model_tag",
"is",
"not",
"None",
"and",
"not",
"isinstance",
"(",
"model_tag",
",",
"(",
"bytes",
",",
"str",
")",... | AdoptResources asks the cloud provider to update the controller
tags for a model's resources. | [
"AdoptResources",
"asks",
"the",
"cloud",
"provider",
"to",
"update",
"the",
"controller",
"tags",
"for",
"a",
"model",
"'",
"s",
"resources",
"."
] | [
"'''\n AdoptResources asks the cloud provider to update the controller\n tags for a model's resources. This prevents the resources from\n being destroyed if the source controller is destroyed after the\n model is migrated away.\n\n model_tag : str\n source_controller_versio... | [
{
"param": "self",
"type": null
},
{
"param": "model_tag",
"type": null
},
{
"param": "source_controller_version",
"type": null
}
] | {
"returns": [],
"raises": [],
"params": [
{
"identifier": "self",
"type": null,
"docstring": null,
"docstring_tokens": [],
"default": null,
"is_optional": null
},
{
"identifier": "model_tag",
"type": null,
"docstring": null,
"docstring_token... |
201cf4683d7f5f6f3b76fe38fbb37c25a7e14749 | sed-i/python-libjuju | juju/client/_client1.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='MigrationTarget',
request='CACert',
... |
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='MigrationTarget',
request='CACert',
version=1,
params=_params)
reply = await self.rpc(msg)
return reply | [
"async",
"def",
"CACert",
"(",
"self",
")",
":",
"_params",
"=",
"dict",
"(",
")",
"msg",
"=",
"dict",
"(",
"type",
"=",
"'MigrationTarget'",
",",
"request",
"=",
"'CACert'",
",",
"version",
"=",
"1",
",",
"params",
"=",
"_params",
")",
"reply",
"=",... | 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": []
} |
201cf4683d7f5f6f3b76fe38fbb37c25a7e14749 | sed-i/python-libjuju | juju/client/_client1.py | [
"Apache-2.0"
] | Python | CheckMachines | <not_specific> | async def CheckMachines(self, model_tag=None):
'''
CheckMachines compares the machines in state with the ones reported
by the provider and reports any discrepancies.
model_tag : str
Returns -> ErrorResults
'''
if model_tag is not None and not isinstance(model_tag... |
CheckMachines compares the machines in state with the ones reported
by the provider and reports any discrepancies.
model_tag : str
Returns -> ErrorResults
| CheckMachines compares the machines in state with the ones reported
by the provider and reports any discrepancies.
| [
"CheckMachines",
"compares",
"the",
"machines",
"in",
"state",
"with",
"the",
"ones",
"reported",
"by",
"the",
"provider",
"and",
"reports",
"any",
"discrepancies",
"."
] | async def CheckMachines(self, model_tag=None):
if model_tag is not None and not isinstance(model_tag, (bytes, str)):
raise Exception("Expected model_tag to be a str, received: {}".format(type(model_tag)))
_params = dict()
msg = dict(type='MigrationTarget',
request=... | [
"async",
"def",
"CheckMachines",
"(",
"self",
",",
"model_tag",
"=",
"None",
")",
":",
"if",
"model_tag",
"is",
"not",
"None",
"and",
"not",
"isinstance",
"(",
"model_tag",
",",
"(",
"bytes",
",",
"str",
")",
")",
":",
"raise",
"Exception",
"(",
"\"Exp... | CheckMachines compares the machines in state with the ones reported
by the provider and reports any discrepancies. | [
"CheckMachines",
"compares",
"the",
"machines",
"in",
"state",
"with",
"the",
"ones",
"reported",
"by",
"the",
"provider",
"and",
"reports",
"any",
"discrepancies",
"."
] | [
"'''\n CheckMachines compares the machines in state with the ones reported\n by the provider and reports any discrepancies.\n\n model_tag : str\n Returns -> ErrorResults\n '''",
"# map input types to rpc msg"
] | [
{
"param": "self",
"type": null
},
{
"param": "model_tag",
"type": null
}
] | {
"returns": [],
"raises": [],
"params": [
{
"identifier": "self",
"type": null,
"docstring": null,
"docstring_tokens": [],
"default": null,
"is_optional": null
},
{
"identifier": "model_tag",
"type": null,
"docstring": null,
"docstring_token... |
201cf4683d7f5f6f3b76fe38fbb37c25a7e14749 | sed-i/python-libjuju | juju/client/_client1.py | [
"Apache-2.0"
] | Python | Import | <not_specific> | async def Import(self, bytes_=None, charms=None, resources=None, tools=None):
'''
Import takes a serialized Juju model, deserializes it, and
recreates it in the receiving controller.
bytes_ : typing.Sequence[int]
charms : typing.Sequence[str]
resources : typing.Sequence[... |
Import takes a serialized Juju model, deserializes it, and
recreates it in the receiving controller.
bytes_ : typing.Sequence[int]
charms : typing.Sequence[str]
resources : typing.Sequence[~SerializedModelResource]
tools : typing.Sequence[~SerializedModelTools]
... | Import takes a serialized Juju model, deserializes it, and
recreates it in the receiving controller.
| [
"Import",
"takes",
"a",
"serialized",
"Juju",
"model",
"deserializes",
"it",
"and",
"recreates",
"it",
"in",
"the",
"receiving",
"controller",
"."
] | async def Import(self, bytes_=None, charms=None, resources=None, tools=None):
if bytes_ is not None and not isinstance(bytes_, (bytes, str, list)):
raise Exception("Expected bytes_ to be a Sequence, received: {}".format(type(bytes_)))
if charms is not None and not isinstance(charms, (bytes, ... | [
"async",
"def",
"Import",
"(",
"self",
",",
"bytes_",
"=",
"None",
",",
"charms",
"=",
"None",
",",
"resources",
"=",
"None",
",",
"tools",
"=",
"None",
")",
":",
"if",
"bytes_",
"is",
"not",
"None",
"and",
"not",
"isinstance",
"(",
"bytes_",
",",
... | Import takes a serialized Juju model, deserializes it, and
recreates it in the receiving controller. | [
"Import",
"takes",
"a",
"serialized",
"Juju",
"model",
"deserializes",
"it",
"and",
"recreates",
"it",
"in",
"the",
"receiving",
"controller",
"."
] | [
"'''\n Import takes a serialized Juju model, deserializes it, and\n recreates it in the receiving controller.\n\n bytes_ : typing.Sequence[int]\n charms : typing.Sequence[str]\n resources : typing.Sequence[~SerializedModelResource]\n tools : typing.Sequence[~SerializedModel... | [
{
"param": "self",
"type": null
},
{
"param": "bytes_",
"type": null
},
{
"param": "charms",
"type": null
},
{
"param": "resources",
"type": null
},
{
"param": "tools",
"type": null
}
] | {
"returns": [],
"raises": [],
"params": [
{
"identifier": "self",
"type": null,
"docstring": null,
"docstring_tokens": [],
"default": null,
"is_optional": null
},
{
"identifier": "bytes_",
"type": null,
"docstring": null,
"docstring_tokens":... |
201cf4683d7f5f6f3b76fe38fbb37c25a7e14749 | sed-i/python-libjuju | juju/client/_client1.py | [
"Apache-2.0"
] | Python | LatestLogTime | <not_specific> | async def LatestLogTime(self, model_tag=None):
'''
LatestLogTime returns the time of the most recent log record
received by the logtransfer endpoint. This can be used as the start
point for streaming logs from the source if the transfer was
interrupted.
For performance r... |
LatestLogTime returns the time of the most recent log record
received by the logtransfer endpoint. This can be used as the start
point for streaming logs from the source if the transfer was
interrupted.
For performance reasons, not every time is tracked, so if the
targe... | LatestLogTime returns the time of the most recent log record
received by the logtransfer endpoint. This can be used as the start
point for streaming logs from the source if the transfer was
interrupted.
For performance reasons, not every time is tracked, so if the
target controller died during the transfer the latest ... | [
"LatestLogTime",
"returns",
"the",
"time",
"of",
"the",
"most",
"recent",
"log",
"record",
"received",
"by",
"the",
"logtransfer",
"endpoint",
".",
"This",
"can",
"be",
"used",
"as",
"the",
"start",
"point",
"for",
"streaming",
"logs",
"from",
"the",
"source... | async def LatestLogTime(self, model_tag=None):
if model_tag is not None and not isinstance(model_tag, (bytes, str)):
raise Exception("Expected model_tag to be a str, received: {}".format(type(model_tag)))
_params = dict()
msg = dict(type='MigrationTarget',
request=... | [
"async",
"def",
"LatestLogTime",
"(",
"self",
",",
"model_tag",
"=",
"None",
")",
":",
"if",
"model_tag",
"is",
"not",
"None",
"and",
"not",
"isinstance",
"(",
"model_tag",
",",
"(",
"bytes",
",",
"str",
")",
")",
":",
"raise",
"Exception",
"(",
"\"Exp... | LatestLogTime returns the time of the most recent log record
received by the logtransfer endpoint. | [
"LatestLogTime",
"returns",
"the",
"time",
"of",
"the",
"most",
"recent",
"log",
"record",
"received",
"by",
"the",
"logtransfer",
"endpoint",
"."
] | [
"'''\n LatestLogTime returns the time of the most recent log record\n received by the logtransfer endpoint. This can be used as the start\n point for streaming logs from the source if the transfer was\n interrupted.\n\n For performance reasons, not every time is tracked, so if the... | [
{
"param": "self",
"type": null
},
{
"param": "model_tag",
"type": null
}
] | {
"returns": [],
"raises": [],
"params": [
{
"identifier": "self",
"type": null,
"docstring": null,
"docstring_tokens": [],
"default": null,
"is_optional": null
},
{
"identifier": "model_tag",
"type": null,
"docstring": null,
"docstring_token... |
201cf4683d7f5f6f3b76fe38fbb37c25a7e14749 | sed-i/python-libjuju | juju/client/_client1.py | [
"Apache-2.0"
] | Python | Prechecks | <not_specific> | async def Prechecks(self, agent_version=None, controller_agent_version=None, name=None, owner_tag=None, uuid=None):
'''
Prechecks ensure that the target controller is ready to accept a
model migration.
agent_version : Number
controller_agent_version : Number
name : str
... |
Prechecks ensure that the target controller is ready to accept a
model migration.
agent_version : Number
controller_agent_version : Number
name : str
owner_tag : str
uuid : str
Returns -> None
| Prechecks ensure that the target controller is ready to accept a
model migration.
| [
"Prechecks",
"ensure",
"that",
"the",
"target",
"controller",
"is",
"ready",
"to",
"accept",
"a",
"model",
"migration",
"."
] | async def Prechecks(self, agent_version=None, controller_agent_version=None, name=None, owner_tag=None, uuid=None):
if agent_version is not None and not isinstance(agent_version, (dict, Number)):
raise Exception("Expected agent_version to be a Number, received: {}".format(type(agent_version)))
... | [
"async",
"def",
"Prechecks",
"(",
"self",
",",
"agent_version",
"=",
"None",
",",
"controller_agent_version",
"=",
"None",
",",
"name",
"=",
"None",
",",
"owner_tag",
"=",
"None",
",",
"uuid",
"=",
"None",
")",
":",
"if",
"agent_version",
"is",
"not",
"N... | Prechecks ensure that the target controller is ready to accept a
model migration. | [
"Prechecks",
"ensure",
"that",
"the",
"target",
"controller",
"is",
"ready",
"to",
"accept",
"a",
"model",
"migration",
"."
] | [
"'''\n Prechecks ensure that the target controller is ready to accept a\n model migration.\n\n agent_version : Number\n controller_agent_version : Number\n name : str\n owner_tag : str\n uuid : str\n Returns -> None\n '''",
"# map input types to rpc m... | [
{
"param": "self",
"type": null
},
{
"param": "agent_version",
"type": null
},
{
"param": "controller_agent_version",
"type": null
},
{
"param": "name",
"type": null
},
{
"param": "owner_tag",
"type": null
},
{
"param": "uuid",
"type": null
}
] | {
"returns": [],
"raises": [],
"params": [
{
"identifier": "self",
"type": null,
"docstring": null,
"docstring_tokens": [],
"default": null,
"is_optional": null
},
{
"identifier": "agent_version",
"type": null,
"docstring": null,
"docstring_t... |
201cf4683d7f5f6f3b76fe38fbb37c25a7e14749 | sed-i/python-libjuju | juju/client/_client1.py | [
"Apache-2.0"
] | Python | Next | <not_specific> | async def Next(self):
'''
Next will return the current state of everything on the first call
and subsequent calls will return just those model summaries that have
changed.
Returns -> SummaryWatcherNextResults
'''
# map input types to rpc msg
_params = d... |
Next will return the current state of everything on the first call
and subsequent calls will return just those model summaries that have
changed.
Returns -> SummaryWatcherNextResults
| Next will return the current state of everything on the first call
and subsequent calls will return just those model summaries that have
changed.
| [
"Next",
"will",
"return",
"the",
"current",
"state",
"of",
"everything",
"on",
"the",
"first",
"call",
"and",
"subsequent",
"calls",
"will",
"return",
"just",
"those",
"model",
"summaries",
"that",
"have",
"changed",
"."
] | async def Next(self):
_params = dict()
msg = dict(type='ModelSummaryWatcher',
request='Next',
version=1,
params=_params)
reply = await self.rpc(msg)
return reply | [
"async",
"def",
"Next",
"(",
"self",
")",
":",
"_params",
"=",
"dict",
"(",
")",
"msg",
"=",
"dict",
"(",
"type",
"=",
"'ModelSummaryWatcher'",
",",
"request",
"=",
"'Next'",
",",
"version",
"=",
"1",
",",
"params",
"=",
"_params",
")",
"reply",
"=",... | Next will return the current state of everything on the first call
and subsequent calls will return just those model summaries that have
changed. | [
"Next",
"will",
"return",
"the",
"current",
"state",
"of",
"everything",
"on",
"the",
"first",
"call",
"and",
"subsequent",
"calls",
"will",
"return",
"just",
"those",
"model",
"summaries",
"that",
"have",
"changed",
"."
] | [
"'''\n Next will return the current state of everything on the first call\n and subsequent calls will return just those model summaries that have\n changed.\n\n\n Returns -> SummaryWatcherNextResults\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": []
} |
201cf4683d7f5f6f3b76fe38fbb37c25a7e14749 | sed-i/python-libjuju | juju/client/_client1.py | [
"Apache-2.0"
] | Python | ModelEnvironVersion | <not_specific> | async def ModelEnvironVersion(self, entities=None):
'''
ModelEnvironVersion returns the current version of the environ corresponding
to each specified model.
entities : typing.Sequence[~Entity]
Returns -> IntResults
'''
if entities is not None and not isinstance(... |
ModelEnvironVersion returns the current version of the environ corresponding
to each specified model.
entities : typing.Sequence[~Entity]
Returns -> IntResults
| ModelEnvironVersion returns the current version of the environ corresponding
to each specified model.
entities : typing.Sequence[~Entity]
Returns -> IntResults | [
"ModelEnvironVersion",
"returns",
"the",
"current",
"version",
"of",
"the",
"environ",
"corresponding",
"to",
"each",
"specified",
"model",
".",
"entities",
":",
"typing",
".",
"Sequence",
"[",
"~Entity",
"]",
"Returns",
"-",
">",
"IntResults"
] | async def ModelEnvironVersion(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='ModelUpgrader',
... | [
"async",
"def",
"ModelEnvironVersion",
"(",
"self",
",",
"entities",
"=",
"None",
")",
":",
"if",
"entities",
"is",
"not",
"None",
"and",
"not",
"isinstance",
"(",
"entities",
",",
"(",
"bytes",
",",
"str",
",",
"list",
")",
")",
":",
"raise",
"Excepti... | ModelEnvironVersion returns the current version of the environ corresponding
to each specified model. | [
"ModelEnvironVersion",
"returns",
"the",
"current",
"version",
"of",
"the",
"environ",
"corresponding",
"to",
"each",
"specified",
"model",
"."
] | [
"'''\n ModelEnvironVersion returns the current version of the environ corresponding\n to each specified model.\n\n entities : typing.Sequence[~Entity]\n Returns -> IntResults\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... |
201cf4683d7f5f6f3b76fe38fbb37c25a7e14749 | sed-i/python-libjuju | juju/client/_client1.py | [
"Apache-2.0"
] | Python | ModelTargetEnvironVersion | <not_specific> | async def ModelTargetEnvironVersion(self, entities=None):
'''
ModelTargetEnvironVersion returns the target version of the environ
corresponding to each specified model. The target version is the
environ provider's version.
entities : typing.Sequence[~Entity]
Returns -> I... |
ModelTargetEnvironVersion returns the target version of the environ
corresponding to each specified model. The target version is the
environ provider's version.
entities : typing.Sequence[~Entity]
Returns -> IntResults
| ModelTargetEnvironVersion returns the target version of the environ
corresponding to each specified model. The target version is the
environ provider's version.
entities : typing.Sequence[~Entity]
Returns -> IntResults | [
"ModelTargetEnvironVersion",
"returns",
"the",
"target",
"version",
"of",
"the",
"environ",
"corresponding",
"to",
"each",
"specified",
"model",
".",
"The",
"target",
"version",
"is",
"the",
"environ",
"provider",
"'",
"s",
"version",
".",
"entities",
":",
"typi... | async def ModelTargetEnvironVersion(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='ModelUpgrader',
... | [
"async",
"def",
"ModelTargetEnvironVersion",
"(",
"self",
",",
"entities",
"=",
"None",
")",
":",
"if",
"entities",
"is",
"not",
"None",
"and",
"not",
"isinstance",
"(",
"entities",
",",
"(",
"bytes",
",",
"str",
",",
"list",
")",
")",
":",
"raise",
"E... | ModelTargetEnvironVersion returns the target version of the environ
corresponding to each specified model. | [
"ModelTargetEnvironVersion",
"returns",
"the",
"target",
"version",
"of",
"the",
"environ",
"corresponding",
"to",
"each",
"specified",
"model",
"."
] | [
"'''\n ModelTargetEnvironVersion returns the target version of the environ\n corresponding to each specified model. The target version is the\n environ provider's version.\n\n entities : typing.Sequence[~Entity]\n Returns -> IntResults\n '''",
"# map input types to rpc ms... | [
{
"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... |
201cf4683d7f5f6f3b76fe38fbb37c25a7e14749 | sed-i/python-libjuju | juju/client/_client1.py | [
"Apache-2.0"
] | Python | SetModelEnvironVersion | <not_specific> | async def SetModelEnvironVersion(self, models=None):
'''
SetModelEnvironVersion sets the current version of the environ corresponding
to each specified model.
models : typing.Sequence[~SetModelEnvironVersion]
Returns -> ErrorResults
'''
if models is not None and ... |
SetModelEnvironVersion sets the current version of the environ corresponding
to each specified model.
models : typing.Sequence[~SetModelEnvironVersion]
Returns -> ErrorResults
| SetModelEnvironVersion sets the current version of the environ corresponding
to each specified model.
| [
"SetModelEnvironVersion",
"sets",
"the",
"current",
"version",
"of",
"the",
"environ",
"corresponding",
"to",
"each",
"specified",
"model",
"."
] | async def SetModelEnvironVersion(self, models=None):
if models is not None and not isinstance(models, (bytes, str, list)):
raise Exception("Expected models to be a Sequence, received: {}".format(type(models)))
_params = dict()
msg = dict(type='ModelUpgrader',
reque... | [
"async",
"def",
"SetModelEnvironVersion",
"(",
"self",
",",
"models",
"=",
"None",
")",
":",
"if",
"models",
"is",
"not",
"None",
"and",
"not",
"isinstance",
"(",
"models",
",",
"(",
"bytes",
",",
"str",
",",
"list",
")",
")",
":",
"raise",
"Exception"... | SetModelEnvironVersion sets the current version of the environ corresponding
to each specified model. | [
"SetModelEnvironVersion",
"sets",
"the",
"current",
"version",
"of",
"the",
"environ",
"corresponding",
"to",
"each",
"specified",
"model",
"."
] | [
"'''\n SetModelEnvironVersion sets the current version of the environ corresponding\n to each specified model.\n\n models : typing.Sequence[~SetModelEnvironVersion]\n Returns -> ErrorResults\n '''",
"# map input types to rpc msg"
] | [
{
"param": "self",
"type": null
},
{
"param": "models",
"type": null
}
] | {
"returns": [],
"raises": [],
"params": [
{
"identifier": "self",
"type": null,
"docstring": null,
"docstring_tokens": [],
"default": null,
"is_optional": null
},
{
"identifier": "models",
"type": null,
"docstring": null,
"docstring_tokens":... |
201cf4683d7f5f6f3b76fe38fbb37c25a7e14749 | sed-i/python-libjuju | juju/client/_client1.py | [
"Apache-2.0"
] | Python | SetModelStatus | <not_specific> | async def SetModelStatus(self, entities=None):
'''
SetModelStatus sets the status of each given model.
entities : typing.Sequence[~EntityStatusArgs]
Returns -> ErrorResults
'''
if entities is not None and not isinstance(entities, (bytes, str, list)):
raise Ex... |
SetModelStatus sets the status of each given model.
entities : typing.Sequence[~EntityStatusArgs]
Returns -> ErrorResults
| SetModelStatus sets the status of each given model. | [
"SetModelStatus",
"sets",
"the",
"status",
"of",
"each",
"given",
"model",
"."
] | async def SetModelStatus(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='ModelUpgrader',
req... | [
"async",
"def",
"SetModelStatus",
"(",
"self",
",",
"entities",
"=",
"None",
")",
":",
"if",
"entities",
"is",
"not",
"None",
"and",
"not",
"isinstance",
"(",
"entities",
",",
"(",
"bytes",
",",
"str",
",",
"list",
")",
")",
":",
"raise",
"Exception",
... | SetModelStatus sets the status of each given model. | [
"SetModelStatus",
"sets",
"the",
"status",
"of",
"each",
"given",
"model",
"."
] | [
"'''\n SetModelStatus sets the status of each given model.\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... |
201cf4683d7f5f6f3b76fe38fbb37c25a7e14749 | sed-i/python-libjuju | juju/client/_client1.py | [
"Apache-2.0"
] | Python | WatchModelEnvironVersion | <not_specific> | async def WatchModelEnvironVersion(self, entities=None):
'''
WatchModelEnvironVersion watches for changes to the environ version of the
specified models.
NOTE(axw) this is currently implemented in terms of state.Model.Watch, so
the client may be notified of changes unrelated to ... |
WatchModelEnvironVersion watches for changes to the environ version of the
specified models.
NOTE(axw) this is currently implemented in terms of state.Model.Watch, so
the client may be notified of changes unrelated to the environ version.
entities : typing.Sequence[~Entity]
... | WatchModelEnvironVersion watches for changes to the environ version of the
specified models.
NOTE(axw) this is currently implemented in terms of state.Model.Watch, so
the client may be notified of changes unrelated to the environ version.
entities : typing.Sequence[~Entity]
Returns -> NotifyWatchResults | [
"WatchModelEnvironVersion",
"watches",
"for",
"changes",
"to",
"the",
"environ",
"version",
"of",
"the",
"specified",
"models",
".",
"NOTE",
"(",
"axw",
")",
"this",
"is",
"currently",
"implemented",
"in",
"terms",
"of",
"state",
".",
"Model",
".",
"Watch",
... | async def WatchModelEnvironVersion(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='ModelUpgrader',
... | [
"async",
"def",
"WatchModelEnvironVersion",
"(",
"self",
",",
"entities",
"=",
"None",
")",
":",
"if",
"entities",
"is",
"not",
"None",
"and",
"not",
"isinstance",
"(",
"entities",
",",
"(",
"bytes",
",",
"str",
",",
"list",
")",
")",
":",
"raise",
"Ex... | WatchModelEnvironVersion watches for changes to the environ version of the
specified models. | [
"WatchModelEnvironVersion",
"watches",
"for",
"changes",
"to",
"the",
"environ",
"version",
"of",
"the",
"specified",
"models",
"."
] | [
"'''\n WatchModelEnvironVersion watches for changes to the environ version of the\n specified models.\n\n NOTE(axw) this is currently implemented in terms of state.Model.Watch, so\n the client may be notified of changes unrelated to the environ version.\n\n entities : typing.Seque... | [
{
"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... |
201cf4683d7f5f6f3b76fe38fbb37c25a7e14749 | sed-i/python-libjuju | juju/client/_client1.py | [
"Apache-2.0"
] | Python | Next | <not_specific> | async def Next(self):
'''
Next returns when a change has occurred to the
entity being watched since the most recent call to Next
or the Watch call that created the NotifyWatcher.
Returns -> None
'''
# map input types to rpc msg
_params = dict()
... |
Next returns when a change has occurred to the
entity being watched since the most recent call to Next
or the Watch call that created the NotifyWatcher.
Returns -> None
| Next returns when a change has occurred to the
entity being watched since the most recent call to Next
or the Watch call that created the NotifyWatcher.
> None | [
"Next",
"returns",
"when",
"a",
"change",
"has",
"occurred",
"to",
"the",
"entity",
"being",
"watched",
"since",
"the",
"most",
"recent",
"call",
"to",
"Next",
"or",
"the",
"Watch",
"call",
"that",
"created",
"the",
"NotifyWatcher",
".",
">",
"None"
] | async def Next(self):
_params = dict()
msg = dict(type='NotifyWatcher',
request='Next',
version=1,
params=_params)
reply = await self.rpc(msg)
return reply | [
"async",
"def",
"Next",
"(",
"self",
")",
":",
"_params",
"=",
"dict",
"(",
")",
"msg",
"=",
"dict",
"(",
"type",
"=",
"'NotifyWatcher'",
",",
"request",
"=",
"'Next'",
",",
"version",
"=",
"1",
",",
"params",
"=",
"_params",
")",
"reply",
"=",
"aw... | Next returns when a change has occurred to the
entity being watched since the most recent call to Next
or the Watch call that created the NotifyWatcher. | [
"Next",
"returns",
"when",
"a",
"change",
"has",
"occurred",
"to",
"the",
"entity",
"being",
"watched",
"since",
"the",
"most",
"recent",
"call",
"to",
"Next",
"or",
"the",
"Watch",
"call",
"that",
"created",
"the",
"NotifyWatcher",
"."
] | [
"'''\n Next returns when a change has occurred to the\n entity being watched since the most recent call to Next\n or the Watch call that created the NotifyWatcher.\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": []
} |
201cf4683d7f5f6f3b76fe38fbb37c25a7e14749 | sed-i/python-libjuju | juju/client/_client1.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 srvOfferStatusWatcher.
Returns -> OfferStatusWatchResult
'''
# map input types t... |
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 srvOfferStatusWatcher.
Returns -> OfferStatusWatchResult
| 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 srvOfferStatusWatcher.
| [
"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",
"srvOfferStatusW... | async def Next(self):
_params = dict()
msg = dict(type='OfferStatusWatcher',
request='Next',
version=1,
params=_params)
reply = await self.rpc(msg)
return reply | [
"async",
"def",
"Next",
"(",
"self",
")",
":",
"_params",
"=",
"dict",
"(",
")",
"msg",
"=",
"dict",
"(",
"type",
"=",
"'OfferStatusWatcher'",
",",
"request",
"=",
"'Next'",
",",
"version",
"=",
"1",
",",
"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 srvOfferStatusWatcher. | [
"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",
"srvOfferStatusW... | [
"'''\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 srvOfferStatusWatcher.\n\n\n Returns -> OfferStatusWatchResult\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": []
} |
201cf4683d7f5f6f3b76fe38fbb37c25a7e14749 | sed-i/python-libjuju | juju/client/_client1.py | [
"Apache-2.0"
] | Python | List | <not_specific> | async def List(self, patterns=None):
'''
List builds the list of payloads being tracked for
the given unit and IDs. If no IDs are provided then all tracked
payloads for the unit are returned.
patterns : typing.Sequence[str]
Returns -> PayloadListResults
'''
... |
List builds the list of payloads being tracked for
the given unit and IDs. If no IDs are provided then all tracked
payloads for the unit are returned.
patterns : typing.Sequence[str]
Returns -> PayloadListResults
| List builds the list of payloads being tracked for
the given unit and IDs. If no IDs are provided then all tracked
payloads for the unit are returned.
patterns : typing.Sequence[str]
Returns -> PayloadListResults | [
"List",
"builds",
"the",
"list",
"of",
"payloads",
"being",
"tracked",
"for",
"the",
"given",
"unit",
"and",
"IDs",
".",
"If",
"no",
"IDs",
"are",
"provided",
"then",
"all",
"tracked",
"payloads",
"for",
"the",
"unit",
"are",
"returned",
".",
"patterns",
... | async def List(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='Payloads',
request='List',
... | [
"async",
"def",
"List",
"(",
"self",
",",
"patterns",
"=",
"None",
")",
":",
"if",
"patterns",
"is",
"not",
"None",
"and",
"not",
"isinstance",
"(",
"patterns",
",",
"(",
"bytes",
",",
"str",
",",
"list",
")",
")",
":",
"raise",
"Exception",
"(",
"... | List builds the list of payloads being tracked for
the given unit and IDs. | [
"List",
"builds",
"the",
"list",
"of",
"payloads",
"being",
"tracked",
"for",
"the",
"given",
"unit",
"and",
"IDs",
"."
] | [
"'''\n List builds the list of payloads being tracked for\n the given unit and IDs. If no IDs are provided then all tracked\n payloads for the unit are returned.\n\n patterns : typing.Sequence[str]\n Returns -> PayloadListResults\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... |
201cf4683d7f5f6f3b76fe38fbb37c25a7e14749 | sed-i/python-libjuju | juju/client/_client1.py | [
"Apache-2.0"
] | Python | List | <not_specific> | async def List(self, entities=None):
'''
List builds the list of payload being tracked for
the given unit and IDs. If no IDs are provided then all tracked
payloads for the unit are returned.
entities : typing.Sequence[~Entity]
Returns -> PayloadResults
'''
... |
List builds the list of payload being tracked for
the given unit and IDs. If no IDs are provided then all tracked
payloads for the unit are returned.
entities : typing.Sequence[~Entity]
Returns -> PayloadResults
| List builds the list of payload being tracked for
the given unit and IDs. If no IDs are provided then all tracked
payloads for the unit are returned.
entities : typing.Sequence[~Entity]
Returns -> PayloadResults | [
"List",
"builds",
"the",
"list",
"of",
"payload",
"being",
"tracked",
"for",
"the",
"given",
"unit",
"and",
"IDs",
".",
"If",
"no",
"IDs",
"are",
"provided",
"then",
"all",
"tracked",
"payloads",
"for",
"the",
"unit",
"are",
"returned",
".",
"entities",
... | async def List(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='PayloadsHookContext',
request... | [
"async",
"def",
"List",
"(",
"self",
",",
"entities",
"=",
"None",
")",
":",
"if",
"entities",
"is",
"not",
"None",
"and",
"not",
"isinstance",
"(",
"entities",
",",
"(",
"bytes",
",",
"str",
",",
"list",
")",
")",
":",
"raise",
"Exception",
"(",
"... | List builds the list of payload being tracked for
the given unit and IDs. | [
"List",
"builds",
"the",
"list",
"of",
"payload",
"being",
"tracked",
"for",
"the",
"given",
"unit",
"and",
"IDs",
"."
] | [
"'''\n List builds the list of payload being tracked for\n the given unit and IDs. If no IDs are provided then all tracked\n payloads for the unit are returned.\n\n entities : typing.Sequence[~Entity]\n Returns -> PayloadResults\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... |
201cf4683d7f5f6f3b76fe38fbb37c25a7e14749 | sed-i/python-libjuju | juju/client/_client1.py | [
"Apache-2.0"
] | Python | LookUp | <not_specific> | async def LookUp(self, args=None):
'''
LookUp identifies the payload with the provided name and raw ID.
args : typing.Sequence[~LookUpPayloadArg]
Returns -> PayloadResults
'''
if args is not None and not isinstance(args, (bytes, str, list)):
raise Exception("... |
LookUp identifies the payload with the provided name and raw ID.
args : typing.Sequence[~LookUpPayloadArg]
Returns -> PayloadResults
| LookUp identifies the payload with the provided name and raw ID. | [
"LookUp",
"identifies",
"the",
"payload",
"with",
"the",
"provided",
"name",
"and",
"raw",
"ID",
"."
] | async def LookUp(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='PayloadsHookContext',
request='LookUp',
... | [
"async",
"def",
"LookUp",
"(",
"self",
",",
"args",
"=",
"None",
")",
":",
"if",
"args",
"is",
"not",
"None",
"and",
"not",
"isinstance",
"(",
"args",
",",
"(",
"bytes",
",",
"str",
",",
"list",
")",
")",
":",
"raise",
"Exception",
"(",
"\"Expected... | LookUp identifies the payload with the provided name and raw ID. | [
"LookUp",
"identifies",
"the",
"payload",
"with",
"the",
"provided",
"name",
"and",
"raw",
"ID",
"."
] | [
"'''\n LookUp identifies the payload with the provided name and raw ID.\n\n args : typing.Sequence[~LookUpPayloadArg]\n Returns -> PayloadResults\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": [... |
201cf4683d7f5f6f3b76fe38fbb37c25a7e14749 | sed-i/python-libjuju | juju/client/_client1.py | [
"Apache-2.0"
] | Python | SetStatus | <not_specific> | async def SetStatus(self, args=None):
'''
SetStatus sets the raw status of a payload.
args : typing.Sequence[~SetPayloadStatusArg]
Returns -> PayloadResults
'''
if args is not None and not isinstance(args, (bytes, str, list)):
raise Exception("Expected args t... |
SetStatus sets the raw status of a payload.
args : typing.Sequence[~SetPayloadStatusArg]
Returns -> PayloadResults
| SetStatus sets the raw status of a payload. | [
"SetStatus",
"sets",
"the",
"raw",
"status",
"of",
"a",
"payload",
"."
] | async def SetStatus(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='PayloadsHookContext',
request='SetStatus',
... | [
"async",
"def",
"SetStatus",
"(",
"self",
",",
"args",
"=",
"None",
")",
":",
"if",
"args",
"is",
"not",
"None",
"and",
"not",
"isinstance",
"(",
"args",
",",
"(",
"bytes",
",",
"str",
",",
"list",
")",
")",
":",
"raise",
"Exception",
"(",
"\"Expec... | SetStatus sets the raw status of a payload. | [
"SetStatus",
"sets",
"the",
"raw",
"status",
"of",
"a",
"payload",
"."
] | [
"'''\n SetStatus sets the raw status of a payload.\n\n args : typing.Sequence[~SetPayloadStatusArg]\n Returns -> PayloadResults\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": [... |
201cf4683d7f5f6f3b76fe38fbb37c25a7e14749 | sed-i/python-libjuju | juju/client/_client1.py | [
"Apache-2.0"
] | Python | Untrack | <not_specific> | async def Untrack(self, entities=None):
'''
Untrack marks the identified payload as no longer being tracked.
entities : typing.Sequence[~Entity]
Returns -> PayloadResults
'''
if entities is not None and not isinstance(entities, (bytes, str, list)):
raise Exce... |
Untrack marks the identified payload as no longer being tracked.
entities : typing.Sequence[~Entity]
Returns -> PayloadResults
| Untrack marks the identified payload as no longer being tracked.
entities : typing.Sequence[~Entity]
Returns -> PayloadResults | [
"Untrack",
"marks",
"the",
"identified",
"payload",
"as",
"no",
"longer",
"being",
"tracked",
".",
"entities",
":",
"typing",
".",
"Sequence",
"[",
"~Entity",
"]",
"Returns",
"-",
">",
"PayloadResults"
] | async def Untrack(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='PayloadsHookContext',
requ... | [
"async",
"def",
"Untrack",
"(",
"self",
",",
"entities",
"=",
"None",
")",
":",
"if",
"entities",
"is",
"not",
"None",
"and",
"not",
"isinstance",
"(",
"entities",
",",
"(",
"bytes",
",",
"str",
",",
"list",
")",
")",
":",
"raise",
"Exception",
"(",
... | Untrack marks the identified payload as no longer being tracked. | [
"Untrack",
"marks",
"the",
"identified",
"payload",
"as",
"no",
"longer",
"being",
"tracked",
"."
] | [
"'''\n Untrack marks the identified payload as no longer being tracked.\n\n entities : typing.Sequence[~Entity]\n Returns -> PayloadResults\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... |
201cf4683d7f5f6f3b76fe38fbb37c25a7e14749 | sed-i/python-libjuju | juju/client/_client1.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 srvRelationStatusWatcher.
Returns -> RelationLifeSuspendedStatusWatchResult
'''
... |
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 srvRelationStatusWatcher.
Returns -> RelationLifeSuspendedStatusWatchResult
| 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 srvRelationStatusWatcher.
| [
"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",
"srvRelationStat... | async def Next(self):
_params = dict()
msg = dict(type='RelationStatusWatcher',
request='Next',
version=1,
params=_params)
reply = await self.rpc(msg)
return reply | [
"async",
"def",
"Next",
"(",
"self",
")",
":",
"_params",
"=",
"dict",
"(",
")",
"msg",
"=",
"dict",
"(",
"type",
"=",
"'RelationStatusWatcher'",
",",
"request",
"=",
"'Next'",
",",
"version",
"=",
"1",
",",
"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 srvRelationStatusWatcher. | [
"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",
"srvRelationStat... | [
"'''\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 srvRelationStatusWatcher.\n\n\n Returns -> RelationLifeSuspendedStatusWatchResult\n '''",
"# map input types to r... | [
{
"param": "self",
"type": null
}
] | {
"returns": [],
"raises": [],
"params": [
{
"identifier": "self",
"type": null,
"docstring": null,
"docstring_tokens": [],
"default": null,
"is_optional": null
}
],
"outlier_params": [],
"others": []
} |
201cf4683d7f5f6f3b76fe38fbb37c25a7e14749 | sed-i/python-libjuju | juju/client/_client1.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 srvRelationUnitsWatcher.
Returns -> RelationUnitsWatchResult
'''
# map input typ... |
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 srvRelationUnitsWatcher.
Returns -> RelationUnitsWatchResult
| 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 srvRelationUnitsWatcher.
| [
"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",
"srvRelationUnit... | async def Next(self):
_params = dict()
msg = dict(type='RelationUnitsWatcher',
request='Next',
version=1,
params=_params)
reply = await self.rpc(msg)
return reply | [
"async",
"def",
"Next",
"(",
"self",
")",
":",
"_params",
"=",
"dict",
"(",
")",
"msg",
"=",
"dict",
"(",
"type",
"=",
"'RelationUnitsWatcher'",
",",
"request",
"=",
"'Next'",
",",
"version",
"=",
"1",
",",
"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 srvRelationUnitsWatcher. | [
"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",
"srvRelationUnit... | [
"'''\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 srvRelationUnitsWatcher.\n\n\n Returns -> RelationUnitsWatchResult\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": []
} |
201cf4683d7f5f6f3b76fe38fbb37c25a7e14749 | sed-i/python-libjuju | juju/client/_client1.py | [
"Apache-2.0"
] | Python | AddPendingResources | <not_specific> | async def AddPendingResources(self, addcharmwithauthorization=None, entity=None, channel=None, force=None, macaroon=None, resources=None, tag=None, url=None):
'''
AddPendingResources adds the provided resources (info) to the Juju
model in a pending state, meaning they are not available until
... |
AddPendingResources adds the provided resources (info) to the Juju
model in a pending state, meaning they are not available until
resolved.
addcharmwithauthorization : AddCharmWithAuthorization
entity : Entity
channel : str
force : bool
macaroon : Macaro... | AddPendingResources adds the provided resources (info) to the Juju
model in a pending state, meaning they are not available until
resolved.
| [
"AddPendingResources",
"adds",
"the",
"provided",
"resources",
"(",
"info",
")",
"to",
"the",
"Juju",
"model",
"in",
"a",
"pending",
"state",
"meaning",
"they",
"are",
"not",
"available",
"until",
"resolved",
"."
] | async def AddPendingResources(self, addcharmwithauthorization=None, entity=None, channel=None, force=None, macaroon=None, resources=None, tag=None, url=None):
if addcharmwithauthorization is not None and not isinstance(addcharmwithauthorization, (dict, AddCharmWithAuthorization)):
raise Exception("E... | [
"async",
"def",
"AddPendingResources",
"(",
"self",
",",
"addcharmwithauthorization",
"=",
"None",
",",
"entity",
"=",
"None",
",",
"channel",
"=",
"None",
",",
"force",
"=",
"None",
",",
"macaroon",
"=",
"None",
",",
"resources",
"=",
"None",
",",
"tag",
... | AddPendingResources adds the provided resources (info) to the Juju
model in a pending state, meaning they are not available until
resolved. | [
"AddPendingResources",
"adds",
"the",
"provided",
"resources",
"(",
"info",
")",
"to",
"the",
"Juju",
"model",
"in",
"a",
"pending",
"state",
"meaning",
"they",
"are",
"not",
"available",
"until",
"resolved",
"."
] | [
"'''\n AddPendingResources adds the provided resources (info) to the Juju\n model in a pending state, meaning they are not available until\n resolved.\n\n addcharmwithauthorization : AddCharmWithAuthorization\n entity : Entity\n channel : str\n force : bool\n ... | [
{
"param": "self",
"type": null
},
{
"param": "addcharmwithauthorization",
"type": null
},
{
"param": "entity",
"type": null
},
{
"param": "channel",
"type": null
},
{
"param": "force",
"type": null
},
{
"param": "macaroon",
"type": null
},
{
... | {
"returns": [],
"raises": [],
"params": [
{
"identifier": "self",
"type": null,
"docstring": null,
"docstring_tokens": [],
"default": null,
"is_optional": null
},
{
"identifier": "addcharmwithauthorization",
"type": null,
"docstring": null,
... |
201cf4683d7f5f6f3b76fe38fbb37c25a7e14749 | sed-i/python-libjuju | juju/client/_client1.py | [
"Apache-2.0"
] | Python | ListResources | <not_specific> | async def ListResources(self, entities=None):
'''
ListResources returns the list of resources for the given application.
entities : typing.Sequence[~Entity]
Returns -> ResourcesResults
'''
if entities is not None and not isinstance(entities, (bytes, str, list)):
... |
ListResources returns the list of resources for the given application.
entities : typing.Sequence[~Entity]
Returns -> ResourcesResults
| ListResources returns the list of resources for the given application.
entities : typing.Sequence[~Entity]
Returns -> ResourcesResults | [
"ListResources",
"returns",
"the",
"list",
"of",
"resources",
"for",
"the",
"given",
"application",
".",
"entities",
":",
"typing",
".",
"Sequence",
"[",
"~Entity",
"]",
"Returns",
"-",
">",
"ResourcesResults"
] | async def ListResources(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='Resources',
request=... | [
"async",
"def",
"ListResources",
"(",
"self",
",",
"entities",
"=",
"None",
")",
":",
"if",
"entities",
"is",
"not",
"None",
"and",
"not",
"isinstance",
"(",
"entities",
",",
"(",
"bytes",
",",
"str",
",",
"list",
")",
")",
":",
"raise",
"Exception",
... | ListResources returns the list of resources for the given application. | [
"ListResources",
"returns",
"the",
"list",
"of",
"resources",
"for",
"the",
"given",
"application",
"."
] | [
"'''\n ListResources returns the list of resources for the given application.\n\n entities : typing.Sequence[~Entity]\n Returns -> ResourcesResults\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... |
201cf4683d7f5f6f3b76fe38fbb37c25a7e14749 | sed-i/python-libjuju | juju/client/_client1.py | [
"Apache-2.0"
] | Python | GetResourceInfo | <not_specific> | async def GetResourceInfo(self, resource_names=None):
'''
GetResourceInfo returns the resource info for each of the given
resource names (for the implicit application). If any one is missing then
the corresponding result is set with errors.NotFound.
resource_names : typing.Seque... |
GetResourceInfo returns the resource info for each of the given
resource names (for the implicit application). If any one is missing then
the corresponding result is set with errors.NotFound.
resource_names : typing.Sequence[str]
Returns -> UnitResourcesResult
| GetResourceInfo returns the resource info for each of the given
resource names (for the implicit application). If any one is missing then
the corresponding result is set with errors.NotFound.
| [
"GetResourceInfo",
"returns",
"the",
"resource",
"info",
"for",
"each",
"of",
"the",
"given",
"resource",
"names",
"(",
"for",
"the",
"implicit",
"application",
")",
".",
"If",
"any",
"one",
"is",
"missing",
"then",
"the",
"corresponding",
"result",
"is",
"s... | async def GetResourceInfo(self, resource_names=None):
if resource_names is not None and not isinstance(resource_names, (bytes, str, list)):
raise Exception("Expected resource_names to be a Sequence, received: {}".format(type(resource_names)))
_params = dict()
msg = dict(type='Resourc... | [
"async",
"def",
"GetResourceInfo",
"(",
"self",
",",
"resource_names",
"=",
"None",
")",
":",
"if",
"resource_names",
"is",
"not",
"None",
"and",
"not",
"isinstance",
"(",
"resource_names",
",",
"(",
"bytes",
",",
"str",
",",
"list",
")",
")",
":",
"rais... | GetResourceInfo returns the resource info for each of the given
resource names (for the implicit application). | [
"GetResourceInfo",
"returns",
"the",
"resource",
"info",
"for",
"each",
"of",
"the",
"given",
"resource",
"names",
"(",
"for",
"the",
"implicit",
"application",
")",
"."
] | [
"'''\n GetResourceInfo returns the resource info for each of the given\n resource names (for the implicit application). If any one is missing then\n the corresponding result is set with errors.NotFound.\n\n resource_names : typing.Sequence[str]\n Returns -> UnitResourcesResult\n ... | [
{
"param": "self",
"type": null
},
{
"param": "resource_names",
"type": null
}
] | {
"returns": [],
"raises": [],
"params": [
{
"identifier": "self",
"type": null,
"docstring": null,
"docstring_tokens": [],
"default": null,
"is_optional": null
},
{
"identifier": "resource_names",
"type": null,
"docstring": null,
"docstring_... |
201cf4683d7f5f6f3b76fe38fbb37c25a7e14749 | sed-i/python-libjuju | juju/client/_client1.py | [
"Apache-2.0"
] | Python | RetryStrategy | <not_specific> | async def RetryStrategy(self, entities=None):
'''
RetryStrategy returns RetryStrategyResults that can be used by any code that uses
to configure the retry timer that's currently in juju utils.
entities : typing.Sequence[~Entity]
Returns -> RetryStrategyResults
'''
... |
RetryStrategy returns RetryStrategyResults that can be used by any code that uses
to configure the retry timer that's currently in juju utils.
entities : typing.Sequence[~Entity]
Returns -> RetryStrategyResults
| RetryStrategy returns RetryStrategyResults that can be used by any code that uses
to configure the retry timer that's currently in juju utils.
entities : typing.Sequence[~Entity]
Returns -> RetryStrategyResults | [
"RetryStrategy",
"returns",
"RetryStrategyResults",
"that",
"can",
"be",
"used",
"by",
"any",
"code",
"that",
"uses",
"to",
"configure",
"the",
"retry",
"timer",
"that",
"'",
"s",
"currently",
"in",
"juju",
"utils",
".",
"entities",
":",
"typing",
".",
"Sequ... | async def RetryStrategy(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='RetryStrategy',
requ... | [
"async",
"def",
"RetryStrategy",
"(",
"self",
",",
"entities",
"=",
"None",
")",
":",
"if",
"entities",
"is",
"not",
"None",
"and",
"not",
"isinstance",
"(",
"entities",
",",
"(",
"bytes",
",",
"str",
",",
"list",
")",
")",
":",
"raise",
"Exception",
... | RetryStrategy returns RetryStrategyResults that can be used by any code that uses
to configure the retry timer that's currently in juju utils. | [
"RetryStrategy",
"returns",
"RetryStrategyResults",
"that",
"can",
"be",
"used",
"by",
"any",
"code",
"that",
"uses",
"to",
"configure",
"the",
"retry",
"timer",
"that",
"'",
"s",
"currently",
"in",
"juju",
"utils",
"."
] | [
"'''\n RetryStrategy returns RetryStrategyResults that can be used by any code that uses\n to configure the retry timer that's currently in juju utils.\n\n entities : typing.Sequence[~Entity]\n Returns -> RetryStrategyResults\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... |
201cf4683d7f5f6f3b76fe38fbb37c25a7e14749 | sed-i/python-libjuju | juju/client/_client1.py | [
"Apache-2.0"
] | Python | WatchRetryStrategy | <not_specific> | async def WatchRetryStrategy(self, entities=None):
'''
WatchRetryStrategy watches for changes to the model. Currently we only allow
changes to the boolean that determines whether retries should be attempted or not.
entities : typing.Sequence[~Entity]
Returns -> NotifyWatchResult... |
WatchRetryStrategy watches for changes to the model. Currently we only allow
changes to the boolean that determines whether retries should be attempted or not.
entities : typing.Sequence[~Entity]
Returns -> NotifyWatchResults
| WatchRetryStrategy watches for changes to the model. Currently we only allow
changes to the boolean that determines whether retries should be attempted or not.
entities : typing.Sequence[~Entity]
Returns -> NotifyWatchResults | [
"WatchRetryStrategy",
"watches",
"for",
"changes",
"to",
"the",
"model",
".",
"Currently",
"we",
"only",
"allow",
"changes",
"to",
"the",
"boolean",
"that",
"determines",
"whether",
"retries",
"should",
"be",
"attempted",
"or",
"not",
".",
"entities",
":",
"ty... | async def WatchRetryStrategy(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='RetryStrategy',
... | [
"async",
"def",
"WatchRetryStrategy",
"(",
"self",
",",
"entities",
"=",
"None",
")",
":",
"if",
"entities",
"is",
"not",
"None",
"and",
"not",
"isinstance",
"(",
"entities",
",",
"(",
"bytes",
",",
"str",
",",
"list",
")",
")",
":",
"raise",
"Exceptio... | WatchRetryStrategy watches for changes to the model. | [
"WatchRetryStrategy",
"watches",
"for",
"changes",
"to",
"the",
"model",
"."
] | [
"'''\n WatchRetryStrategy watches for changes to the model. Currently we only allow\n changes to the boolean that determines whether retries should be attempted or not.\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... |
201cf4683d7f5f6f3b76fe38fbb37c25a7e14749 | sed-i/python-libjuju | juju/client/_client1.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 srvStringsWatcher.
Returns -> StringsWatchResult
'''
# map input types to rpc ms... |
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 srvStringsWatcher.
Returns -> StringsWatchResult
| 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 srvStringsWatcher.
| [
"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",
"srvStringsWatch... | async def Next(self):
_params = dict()
msg = dict(type='StringsWatcher',
request='Next',
version=1,
params=_params)
reply = await self.rpc(msg)
return reply | [
"async",
"def",
"Next",
"(",
"self",
")",
":",
"_params",
"=",
"dict",
"(",
")",
"msg",
"=",
"dict",
"(",
"type",
"=",
"'StringsWatcher'",
",",
"request",
"=",
"'Next'",
",",
"version",
"=",
"1",
",",
"params",
"=",
"_params",
")",
"reply",
"=",
"a... | 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 srvStringsWatcher. | [
"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",
"srvStringsWatch... | [
"'''\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 srvStringsWatcher.\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": []
} |
201cf4683d7f5f6f3b76fe38fbb37c25a7e14749 | sed-i/python-libjuju | juju/client/_client1.py | [
"Apache-2.0"
] | Python | ModelConfig | <not_specific> | async def ModelConfig(self):
'''
ModelConfig returns the model's configuration.
Returns -> ModelConfigResult
'''
# map input types to rpc msg
_params = dict()
msg = dict(type='Undertaker',
request='ModelConfig',
version=1,
... |
ModelConfig returns the model's configuration.
Returns -> ModelConfigResult
| ModelConfig returns the model's configuration. | [
"ModelConfig",
"returns",
"the",
"model",
"'",
"s",
"configuration",
"."
] | async def ModelConfig(self):
_params = dict()
msg = dict(type='Undertaker',
request='ModelConfig',
version=1,
params=_params)
reply = await self.rpc(msg)
return reply | [
"async",
"def",
"ModelConfig",
"(",
"self",
")",
":",
"_params",
"=",
"dict",
"(",
")",
"msg",
"=",
"dict",
"(",
"type",
"=",
"'Undertaker'",
",",
"request",
"=",
"'ModelConfig'",
",",
"version",
"=",
"1",
",",
"params",
"=",
"_params",
")",
"reply",
... | ModelConfig returns the model's configuration. | [
"ModelConfig",
"returns",
"the",
"model",
"'",
"s",
"configuration",
"."
] | [
"'''\n ModelConfig returns the model's configuration.\n\n\n Returns -> ModelConfigResult\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": []
} |
201cf4683d7f5f6f3b76fe38fbb37c25a7e14749 | sed-i/python-libjuju | juju/client/_client1.py | [
"Apache-2.0"
] | Python | ModelInfo | <not_specific> | async def ModelInfo(self):
'''
ModelInfo returns information on the model needed by the undertaker worker.
Returns -> UndertakerModelInfoResult
'''
# map input types to rpc msg
_params = dict()
msg = dict(type='Undertaker',
request='ModelInfo... |
ModelInfo returns information on the model needed by the undertaker worker.
Returns -> UndertakerModelInfoResult
| ModelInfo returns information on the model needed by the undertaker worker. | [
"ModelInfo",
"returns",
"information",
"on",
"the",
"model",
"needed",
"by",
"the",
"undertaker",
"worker",
"."
] | async def ModelInfo(self):
_params = dict()
msg = dict(type='Undertaker',
request='ModelInfo',
version=1,
params=_params)
reply = await self.rpc(msg)
return reply | [
"async",
"def",
"ModelInfo",
"(",
"self",
")",
":",
"_params",
"=",
"dict",
"(",
")",
"msg",
"=",
"dict",
"(",
"type",
"=",
"'Undertaker'",
",",
"request",
"=",
"'ModelInfo'",
",",
"version",
"=",
"1",
",",
"params",
"=",
"_params",
")",
"reply",
"="... | ModelInfo returns information on the model needed by the undertaker worker. | [
"ModelInfo",
"returns",
"information",
"on",
"the",
"model",
"needed",
"by",
"the",
"undertaker",
"worker",
"."
] | [
"'''\n ModelInfo returns information on the model needed by the undertaker worker.\n\n\n Returns -> UndertakerModelInfoResult\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": []
} |
201cf4683d7f5f6f3b76fe38fbb37c25a7e14749 | sed-i/python-libjuju | juju/client/_client1.py | [
"Apache-2.0"
] | Python | ProcessDyingModel | <not_specific> | async def ProcessDyingModel(self):
'''
ProcessDyingModel checks if a dying model has any machines or applications.
If there are none, the model's life is changed from dying to dead.
Returns -> None
'''
# map input types to rpc msg
_params = dict()
msg =... |
ProcessDyingModel checks if a dying model has any machines or applications.
If there are none, the model's life is changed from dying to dead.
Returns -> None
| ProcessDyingModel checks if a dying model has any machines or applications.
If there are none, the model's life is changed from dying to dead.
> None | [
"ProcessDyingModel",
"checks",
"if",
"a",
"dying",
"model",
"has",
"any",
"machines",
"or",
"applications",
".",
"If",
"there",
"are",
"none",
"the",
"model",
"'",
"s",
"life",
"is",
"changed",
"from",
"dying",
"to",
"dead",
".",
">",
"None"
] | async def ProcessDyingModel(self):
_params = dict()
msg = dict(type='Undertaker',
request='ProcessDyingModel',
version=1,
params=_params)
reply = await self.rpc(msg)
return reply | [
"async",
"def",
"ProcessDyingModel",
"(",
"self",
")",
":",
"_params",
"=",
"dict",
"(",
")",
"msg",
"=",
"dict",
"(",
"type",
"=",
"'Undertaker'",
",",
"request",
"=",
"'ProcessDyingModel'",
",",
"version",
"=",
"1",
",",
"params",
"=",
"_params",
")",
... | ProcessDyingModel checks if a dying model has any machines or applications. | [
"ProcessDyingModel",
"checks",
"if",
"a",
"dying",
"model",
"has",
"any",
"machines",
"or",
"applications",
"."
] | [
"'''\n ProcessDyingModel checks if a dying model has any machines or applications.\n If there are none, the model's life is changed from dying to dead.\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": []
} |
201cf4683d7f5f6f3b76fe38fbb37c25a7e14749 | sed-i/python-libjuju | juju/client/_client1.py | [
"Apache-2.0"
] | Python | RemoveModel | <not_specific> | async def RemoveModel(self):
'''
RemoveModel removes any records of this model from Juju.
Returns -> None
'''
# map input types to rpc msg
_params = dict()
msg = dict(type='Undertaker',
request='RemoveModel',
version=1,
... |
RemoveModel removes any records of this model from Juju.
Returns -> None
| RemoveModel removes any records of this model from Juju.
Returns -> None | [
"RemoveModel",
"removes",
"any",
"records",
"of",
"this",
"model",
"from",
"Juju",
".",
"Returns",
"-",
">",
"None"
] | async def RemoveModel(self):
_params = dict()
msg = dict(type='Undertaker',
request='RemoveModel',
version=1,
params=_params)
reply = await self.rpc(msg)
return reply | [
"async",
"def",
"RemoveModel",
"(",
"self",
")",
":",
"_params",
"=",
"dict",
"(",
")",
"msg",
"=",
"dict",
"(",
"type",
"=",
"'Undertaker'",
",",
"request",
"=",
"'RemoveModel'",
",",
"version",
"=",
"1",
",",
"params",
"=",
"_params",
")",
"reply",
... | RemoveModel removes any records of this model from Juju. | [
"RemoveModel",
"removes",
"any",
"records",
"of",
"this",
"model",
"from",
"Juju",
"."
] | [
"'''\n RemoveModel removes any records of this model from Juju.\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": []
} |
201cf4683d7f5f6f3b76fe38fbb37c25a7e14749 | sed-i/python-libjuju | juju/client/_client1.py | [
"Apache-2.0"
] | Python | SetStatus | <not_specific> | async def SetStatus(self, entities=None):
'''
SetStatus sets the status of each given entity.
entities : typing.Sequence[~EntityStatusArgs]
Returns -> ErrorResults
'''
if entities is not None and not isinstance(entities, (bytes, str, list)):
raise Exception("... |
SetStatus sets the status of each given entity.
entities : typing.Sequence[~EntityStatusArgs]
Returns -> ErrorResults
| SetStatus sets the status of each given entity. | [
"SetStatus",
"sets",
"the",
"status",
"of",
"each",
"given",
"entity",
"."
] | async def SetStatus(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='Undertaker',
request='Se... | [
"async",
"def",
"SetStatus",
"(",
"self",
",",
"entities",
"=",
"None",
")",
":",
"if",
"entities",
"is",
"not",
"None",
"and",
"not",
"isinstance",
"(",
"entities",
",",
"(",
"bytes",
",",
"str",
",",
"list",
")",
")",
":",
"raise",
"Exception",
"("... | SetStatus sets the status of each given entity. | [
"SetStatus",
"sets",
"the",
"status",
"of",
"each",
"given",
"entity",
"."
] | [
"'''\n SetStatus sets the status of each given entity.\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... |
201cf4683d7f5f6f3b76fe38fbb37c25a7e14749 | sed-i/python-libjuju | juju/client/_client1.py | [
"Apache-2.0"
] | Python | UpdateStatus | <not_specific> | async def UpdateStatus(self, entities=None):
'''
UpdateStatus updates the status data of each given entity.
TODO(fwereade): WTF. This method exists *only* for the convenience of the
*client* API -- and is itself completely broken -- but we still expose it
in every facade with a S... |
UpdateStatus updates the status data of each given entity.
TODO(fwereade): WTF. This method exists *only* for the convenience of the
*client* API -- and is itself completely broken -- but we still expose it
in every facade with a StatusSetter? FFS.
entities : typing.Sequence[~E... | UpdateStatus updates the status data of each given entity.
| [
"UpdateStatus",
"updates",
"the",
"status",
"data",
"of",
"each",
"given",
"entity",
"."
] | async def UpdateStatus(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='Undertaker',
request=... | [
"async",
"def",
"UpdateStatus",
"(",
"self",
",",
"entities",
"=",
"None",
")",
":",
"if",
"entities",
"is",
"not",
"None",
"and",
"not",
"isinstance",
"(",
"entities",
",",
"(",
"bytes",
",",
"str",
",",
"list",
")",
")",
":",
"raise",
"Exception",
... | UpdateStatus updates the status data of each given entity. | [
"UpdateStatus",
"updates",
"the",
"status",
"data",
"of",
"each",
"given",
"entity",
"."
] | [
"'''\n UpdateStatus updates the status data of each given entity.\n TODO(fwereade): WTF. This method exists *only* for the convenience of the\n *client* API -- and is itself completely broken -- but we still expose it\n in every facade with a StatusSetter? FFS.\n\n entities : typi... | [
{
"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... |
201cf4683d7f5f6f3b76fe38fbb37c25a7e14749 | sed-i/python-libjuju | juju/client/_client1.py | [
"Apache-2.0"
] | Python | WatchModelResources | <not_specific> | async def WatchModelResources(self):
'''
WatchModelResources creates watchers for changes to the lifecycle of an
model's machines and applications and storage.
Returns -> NotifyWatchResults
'''
# map input types to rpc msg
_params = dict()
msg = dict(ty... |
WatchModelResources creates watchers for changes to the lifecycle of an
model's machines and applications and storage.
Returns -> NotifyWatchResults
| WatchModelResources creates watchers for changes to the lifecycle of an
model's machines and applications and storage.
| [
"WatchModelResources",
"creates",
"watchers",
"for",
"changes",
"to",
"the",
"lifecycle",
"of",
"an",
"model",
"'",
"s",
"machines",
"and",
"applications",
"and",
"storage",
"."
] | async def WatchModelResources(self):
_params = dict()
msg = dict(type='Undertaker',
request='WatchModelResources',
version=1,
params=_params)
reply = await self.rpc(msg)
return reply | [
"async",
"def",
"WatchModelResources",
"(",
"self",
")",
":",
"_params",
"=",
"dict",
"(",
")",
"msg",
"=",
"dict",
"(",
"type",
"=",
"'Undertaker'",
",",
"request",
"=",
"'WatchModelResources'",
",",
"version",
"=",
"1",
",",
"params",
"=",
"_params",
"... | WatchModelResources creates watchers for changes to the lifecycle of an
model's machines and applications and storage. | [
"WatchModelResources",
"creates",
"watchers",
"for",
"changes",
"to",
"the",
"lifecycle",
"of",
"an",
"model",
"'",
"s",
"machines",
"and",
"applications",
"and",
"storage",
"."
] | [
"'''\n WatchModelResources creates watchers for changes to the lifecycle of an\n model's machines and applications and storage.\n\n\n Returns -> NotifyWatchResults\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": []
} |
201cf4683d7f5f6f3b76fe38fbb37c25a7e14749 | sed-i/python-libjuju | juju/client/_client1.py | [
"Apache-2.0"
] | Python | AssignUnits | <not_specific> | async def AssignUnits(self, entities=None):
'''
AssignUnits assigns the units with the given ids to the correct machine. The
error results are returned in the same order as the given entities.
entities : typing.Sequence[~Entity]
Returns -> ErrorResults
'''
if en... |
AssignUnits assigns the units with the given ids to the correct machine. The
error results are returned in the same order as the given entities.
entities : typing.Sequence[~Entity]
Returns -> ErrorResults
| AssignUnits assigns the units with the given ids to the correct machine. The
error results are returned in the same order as the given entities.
entities : typing.Sequence[~Entity]
Returns -> ErrorResults | [
"AssignUnits",
"assigns",
"the",
"units",
"with",
"the",
"given",
"ids",
"to",
"the",
"correct",
"machine",
".",
"The",
"error",
"results",
"are",
"returned",
"in",
"the",
"same",
"order",
"as",
"the",
"given",
"entities",
".",
"entities",
":",
"typing",
"... | async def AssignUnits(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='UnitAssigner',
request... | [
"async",
"def",
"AssignUnits",
"(",
"self",
",",
"entities",
"=",
"None",
")",
":",
"if",
"entities",
"is",
"not",
"None",
"and",
"not",
"isinstance",
"(",
"entities",
",",
"(",
"bytes",
",",
"str",
",",
"list",
")",
")",
":",
"raise",
"Exception",
"... | AssignUnits assigns the units with the given ids to the correct machine. | [
"AssignUnits",
"assigns",
"the",
"units",
"with",
"the",
"given",
"ids",
"to",
"the",
"correct",
"machine",
"."
] | [
"'''\n AssignUnits assigns the units with the given ids to the correct machine. The\n error results are returned in the same order as the given entities.\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... |
201cf4683d7f5f6f3b76fe38fbb37c25a7e14749 | sed-i/python-libjuju | juju/client/_client1.py | [
"Apache-2.0"
] | Python | SetAgentStatus | <not_specific> | async def SetAgentStatus(self, entities=None):
'''
SetAgentStatus will set status for agents of Units passed in args, if one
of the args is not an Unit it will fail.
entities : typing.Sequence[~EntityStatusArgs]
Returns -> ErrorResults
'''
if entities is not None... |
SetAgentStatus will set status for agents of Units passed in args, if one
of the args is not an Unit it will fail.
entities : typing.Sequence[~EntityStatusArgs]
Returns -> ErrorResults
| SetAgentStatus will set status for agents of Units passed in args, if one
of the args is not an Unit it will fail.
| [
"SetAgentStatus",
"will",
"set",
"status",
"for",
"agents",
"of",
"Units",
"passed",
"in",
"args",
"if",
"one",
"of",
"the",
"args",
"is",
"not",
"an",
"Unit",
"it",
"will",
"fail",
"."
] | async def SetAgentStatus(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='UnitAssigner',
requ... | [
"async",
"def",
"SetAgentStatus",
"(",
"self",
",",
"entities",
"=",
"None",
")",
":",
"if",
"entities",
"is",
"not",
"None",
"and",
"not",
"isinstance",
"(",
"entities",
",",
"(",
"bytes",
",",
"str",
",",
"list",
")",
")",
":",
"raise",
"Exception",
... | SetAgentStatus will set status for agents of Units passed in args, if one
of the args is not an Unit it will fail. | [
"SetAgentStatus",
"will",
"set",
"status",
"for",
"agents",
"of",
"Units",
"passed",
"in",
"args",
"if",
"one",
"of",
"the",
"args",
"is",
"not",
"an",
"Unit",
"it",
"will",
"fail",
"."
] | [
"'''\n SetAgentStatus will set status for agents of Units passed in args, if one\n of the args is not an Unit it will fail.\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... |
201cf4683d7f5f6f3b76fe38fbb37c25a7e14749 | sed-i/python-libjuju | juju/client/_client1.py | [
"Apache-2.0"
] | Python | WatchUnitAssignments | <not_specific> | async def WatchUnitAssignments(self):
'''
WatchUnitAssignments returns a strings watcher that is notified when new unit
assignments are added to the db.
Returns -> StringsWatchResult
'''
# map input types to rpc msg
_params = dict()
msg = dict(type='Uni... |
WatchUnitAssignments returns a strings watcher that is notified when new unit
assignments are added to the db.
Returns -> StringsWatchResult
| WatchUnitAssignments returns a strings watcher that is notified when new unit
assignments are added to the db.
| [
"WatchUnitAssignments",
"returns",
"a",
"strings",
"watcher",
"that",
"is",
"notified",
"when",
"new",
"unit",
"assignments",
"are",
"added",
"to",
"the",
"db",
"."
] | async def WatchUnitAssignments(self):
_params = dict()
msg = dict(type='UnitAssigner',
request='WatchUnitAssignments',
version=1,
params=_params)
reply = await self.rpc(msg)
return reply | [
"async",
"def",
"WatchUnitAssignments",
"(",
"self",
")",
":",
"_params",
"=",
"dict",
"(",
")",
"msg",
"=",
"dict",
"(",
"type",
"=",
"'UnitAssigner'",
",",
"request",
"=",
"'WatchUnitAssignments'",
",",
"version",
"=",
"1",
",",
"params",
"=",
"_params",... | WatchUnitAssignments returns a strings watcher that is notified when new unit
assignments are added to the db. | [
"WatchUnitAssignments",
"returns",
"a",
"strings",
"watcher",
"that",
"is",
"notified",
"when",
"new",
"unit",
"assignments",
"are",
"added",
"to",
"the",
"db",
"."
] | [
"'''\n WatchUnitAssignments returns a strings watcher that is notified when new unit\n assignments are added to the db.\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": []
} |
201cf4683d7f5f6f3b76fe38fbb37c25a7e14749 | sed-i/python-libjuju | juju/client/_client1.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='VolumeAttachmentPlansWatcher',
request='Next',
version=1,
params=_params)
reply = await self.rpc(msg)
return reply | [
"async",
"def",
"Next",
"(",
"self",
")",
":",
"_params",
"=",
"dict",
"(",
")",
"msg",
"=",
"dict",
"(",
"type",
"=",
"'VolumeAttachmentPlansWatcher'",
",",
"request",
"=",
"'Next'",
",",
"version",
"=",
"1",
",",
"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": []
} |
8b383466832fc4bc28210a6a6d6ec666a88387e7 | sed-i/python-libjuju | juju/client/facade.py | [
"Apache-2.0"
] | Python | lookup | <not_specific> | def lookup(self, name, version=None):
"""If version is omitted, max version is used"""
versions = self.get(name)
if not versions:
return None
if version:
return versions[version]
return versions[max(versions)] | If version is omitted, max version is used | If version is omitted, max version is used | [
"If",
"version",
"is",
"omitted",
"max",
"version",
"is",
"used"
] | def lookup(self, name, version=None):
versions = self.get(name)
if not versions:
return None
if version:
return versions[version]
return versions[max(versions)] | [
"def",
"lookup",
"(",
"self",
",",
"name",
",",
"version",
"=",
"None",
")",
":",
"versions",
"=",
"self",
".",
"get",
"(",
"name",
")",
"if",
"not",
"versions",
":",
"return",
"None",
"if",
"version",
":",
"return",
"versions",
"[",
"version",
"]",
... | If version is omitted, max version is used | [
"If",
"version",
"is",
"omitted",
"max",
"version",
"is",
"used"
] | [
"\"\"\"If version is omitted, max version is used\"\"\""
] | [
{
"param": "self",
"type": null
},
{
"param": "name",
"type": null
},
{
"param": "version",
"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": [... |
8b383466832fc4bc28210a6a6d6ec666a88387e7 | sed-i/python-libjuju | juju/client/facade.py | [
"Apache-2.0"
] | Python | as_validation | <not_specific> | def as_validation(self):
"""
as_validation returns a series of validation statements for every item
in the the Args.
"""
parts = []
for item in self:
var_name = name_to_py(item[0])
var_type, var_sub_type, ok = kind_to_py(item[1])
if ok:... |
as_validation returns a series of validation statements for every item
in the the Args.
| as_validation returns a series of validation statements for every item
in the the Args. | [
"as_validation",
"returns",
"a",
"series",
"of",
"validation",
"statements",
"for",
"every",
"item",
"in",
"the",
"the",
"Args",
"."
] | def as_validation(self):
parts = []
for item in self:
var_name = name_to_py(item[0])
var_type, var_sub_type, ok = kind_to_py(item[1])
if ok:
parts.append(buildValidation(var_name, var_type, var_sub_type))
return '\n'.join(parts) | [
"def",
"as_validation",
"(",
"self",
")",
":",
"parts",
"=",
"[",
"]",
"for",
"item",
"in",
"self",
":",
"var_name",
"=",
"name_to_py",
"(",
"item",
"[",
"0",
"]",
")",
"var_type",
",",
"var_sub_type",
",",
"ok",
"=",
"kind_to_py",
"(",
"item",
"[",
... | as_validation returns a series of validation statements for every item
in the the Args. | [
"as_validation",
"returns",
"a",
"series",
"of",
"validation",
"statements",
"for",
"every",
"item",
"in",
"the",
"the",
"Args",
"."
] | [
"\"\"\"\n as_validation returns a series of validation statements for every item\n in the the Args.\n \"\"\""
] | [
{
"param": "self",
"type": null
}
] | {
"returns": [],
"raises": [],
"params": [
{
"identifier": "self",
"type": null,
"docstring": null,
"docstring_tokens": [],
"default": null,
"is_optional": null
}
],
"outlier_params": [],
"others": []
} |
8b383466832fc4bc28210a6a6d6ec666a88387e7 | sed-i/python-libjuju | juju/client/facade.py | [
"Apache-2.0"
] | Python | write_facades | <not_specific> | def write_facades(captures, options):
"""
Write the Facades to the appropriate _client<version>.py
"""
for version in sorted(captures.keys()):
filename = "{}/_client{}.py".format(options.output_dir, version)
with open(filename, "w") as f:
f.write(HEADER)
f.write(... |
Write the Facades to the appropriate _client<version>.py
| Write the Facades to the appropriate _client.py | [
"Write",
"the",
"Facades",
"to",
"the",
"appropriate",
"_client",
".",
"py"
] | def write_facades(captures, options):
for version in sorted(captures.keys()):
filename = "{}/_client{}.py".format(options.output_dir, version)
with open(filename, "w") as f:
f.write(HEADER)
f.write("from juju.client.facade import Type, ReturnMapping\n")
f.write("f... | [
"def",
"write_facades",
"(",
"captures",
",",
"options",
")",
":",
"for",
"version",
"in",
"sorted",
"(",
"captures",
".",
"keys",
"(",
")",
")",
":",
"filename",
"=",
"\"{}/_client{}.py\"",
".",
"format",
"(",
"options",
".",
"output_dir",
",",
"version",... | Write the Facades to the appropriate _client<version>.py | [
"Write",
"the",
"Facades",
"to",
"the",
"appropriate",
"_client<version",
">",
".",
"py"
] | [
"\"\"\"\n Write the Facades to the appropriate _client<version>.py\n\n \"\"\"",
"# Return the last (most recent) version for use in other routines."
] | [
{
"param": "captures",
"type": null
},
{
"param": "options",
"type": null
}
] | {
"returns": [],
"raises": [],
"params": [
{
"identifier": "captures",
"type": null,
"docstring": null,
"docstring_tokens": [],
"default": null,
"is_optional": null
},
{
"identifier": "options",
"type": null,
"docstring": null,
"docstring_tok... |
8b383466832fc4bc28210a6a6d6ec666a88387e7 | sed-i/python-libjuju | juju/client/facade.py | [
"Apache-2.0"
] | Python | write_definitions | null | def write_definitions(captures, options):
"""
Write auxillary (non versioned) classes to
_definitions.py The auxillary classes currently get
written redudantly into each capture object, so we can look in
one of them -- we just use the last one from the loop above.
"""
with open("{}/_definit... |
Write auxillary (non versioned) classes to
_definitions.py The auxillary classes currently get
written redudantly into each capture object, so we can look in
one of them -- we just use the last one from the loop above.
| Write auxillary (non versioned) classes to
_definitions.py The auxillary classes currently get
written redudantly into each capture object, so we can look in
one of them -- we just use the last one from the loop above. | [
"Write",
"auxillary",
"(",
"non",
"versioned",
")",
"classes",
"to",
"_definitions",
".",
"py",
"The",
"auxillary",
"classes",
"currently",
"get",
"written",
"redudantly",
"into",
"each",
"capture",
"object",
"so",
"we",
"can",
"look",
"in",
"one",
"of",
"th... | def write_definitions(captures, options):
with open("{}/_definitions.py".format(options.output_dir), "w") as f:
f.write(HEADER)
f.write("from juju.client.facade import Type, ReturnMapping\n\n")
for key in sorted(
[k for k in captures.keys() if "Facade" not in k]):
... | [
"def",
"write_definitions",
"(",
"captures",
",",
"options",
")",
":",
"with",
"open",
"(",
"\"{}/_definitions.py\"",
".",
"format",
"(",
"options",
".",
"output_dir",
")",
",",
"\"w\"",
")",
"as",
"f",
":",
"f",
".",
"write",
"(",
"HEADER",
")",
"f",
... | Write auxillary (non versioned) classes to
_definitions.py The auxillary classes currently get
written redudantly into each capture object, so we can look in
one of them -- we just use the last one from the loop above. | [
"Write",
"auxillary",
"(",
"non",
"versioned",
")",
"classes",
"to",
"_definitions",
".",
"py",
"The",
"auxillary",
"classes",
"currently",
"get",
"written",
"redudantly",
"into",
"each",
"capture",
"object",
"so",
"we",
"can",
"look",
"in",
"one",
"of",
"th... | [
"\"\"\"\n Write auxillary (non versioned) classes to\n _definitions.py The auxillary classes currently get\n written redudantly into each capture object, so we can look in\n one of them -- we just use the last one from the loop above.\n\n \"\"\""
] | [
{
"param": "captures",
"type": null
},
{
"param": "options",
"type": null
}
] | {
"returns": [],
"raises": [],
"params": [
{
"identifier": "captures",
"type": null,
"docstring": null,
"docstring_tokens": [],
"default": null,
"is_optional": null
},
{
"identifier": "options",
"type": null,
"docstring": null,
"docstring_tok... |
8b383466832fc4bc28210a6a6d6ec666a88387e7 | sed-i/python-libjuju | juju/client/facade.py | [
"Apache-2.0"
] | Python | write_client | null | def write_client(captures, options):
"""
Write the TypeFactory classes to _client.py, along with some
imports and tables so that we can look up versioned Facades.
"""
with open("{}/_client.py".format(options.output_dir), "w") as f:
f.write(HEADER)
f.write("from juju.client._definiti... |
Write the TypeFactory classes to _client.py, along with some
imports and tables so that we can look up versioned Facades.
| Write the TypeFactory classes to _client.py, along with some
imports and tables so that we can look up versioned Facades. | [
"Write",
"the",
"TypeFactory",
"classes",
"to",
"_client",
".",
"py",
"along",
"with",
"some",
"imports",
"and",
"tables",
"so",
"that",
"we",
"can",
"look",
"up",
"versioned",
"Facades",
"."
] | def write_client(captures, options):
with open("{}/_client.py".format(options.output_dir), "w") as f:
f.write(HEADER)
f.write("from juju.client._definitions import *\n\n")
clients = ", ".join("_client{}".format(v) for v in captures)
f.write("from juju.client import " + clients + "\n\... | [
"def",
"write_client",
"(",
"captures",
",",
"options",
")",
":",
"with",
"open",
"(",
"\"{}/_client.py\"",
".",
"format",
"(",
"options",
".",
"output_dir",
")",
",",
"\"w\"",
")",
"as",
"f",
":",
"f",
".",
"write",
"(",
"HEADER",
")",
"f",
".",
"wr... | Write the TypeFactory classes to _client.py, along with some
imports and tables so that we can look up versioned Facades. | [
"Write",
"the",
"TypeFactory",
"classes",
"to",
"_client",
".",
"py",
"along",
"with",
"some",
"imports",
"and",
"tables",
"so",
"that",
"we",
"can",
"look",
"up",
"versioned",
"Facades",
"."
] | [
"\"\"\"\n Write the TypeFactory classes to _client.py, along with some\n imports and tables so that we can look up versioned Facades.\n\n \"\"\""
] | [
{
"param": "captures",
"type": null
},
{
"param": "options",
"type": null
}
] | {
"returns": [],
"raises": [],
"params": [
{
"identifier": "captures",
"type": null,
"docstring": null,
"docstring_tokens": [],
"default": null,
"is_optional": null
},
{
"identifier": "options",
"type": null,
"docstring": null,
"docstring_tok... |
f1c5edd2764131b66760835a53f04b87b39c931a | sed-i/python-libjuju | juju/client/_client3.py | [
"Apache-2.0"
] | Python | Login | <not_specific> | async def Login(self, auth_tag=None, bakery_version=None, cli_args=None, client_version=None, credentials=None, macaroons=None, nonce=None, user_data=None):
'''
Login logs in with the provided credentials. All subsequent requests on the
connection will act as the authenticated user.
au... |
Login logs in with the provided credentials. All subsequent requests on the
connection will act as the authenticated user.
auth_tag : str
bakery_version : int
cli_args : str
client_version : str
credentials : str
macaroons : typing.Sequence[~Macaroon]
... | Login logs in with the provided credentials. All subsequent requests on the
connection will act as the authenticated user.
| [
"Login",
"logs",
"in",
"with",
"the",
"provided",
"credentials",
".",
"All",
"subsequent",
"requests",
"on",
"the",
"connection",
"will",
"act",
"as",
"the",
"authenticated",
"user",
"."
] | async def Login(self, auth_tag=None, bakery_version=None, cli_args=None, client_version=None, credentials=None, macaroons=None, nonce=None, user_data=None):
if auth_tag is not None and not isinstance(auth_tag, (bytes, str)):
raise Exception("Expected auth_tag to be a str, received: {}".format(type(a... | [
"async",
"def",
"Login",
"(",
"self",
",",
"auth_tag",
"=",
"None",
",",
"bakery_version",
"=",
"None",
",",
"cli_args",
"=",
"None",
",",
"client_version",
"=",
"None",
",",
"credentials",
"=",
"None",
",",
"macaroons",
"=",
"None",
",",
"nonce",
"=",
... | Login logs in with the provided credentials. | [
"Login",
"logs",
"in",
"with",
"the",
"provided",
"credentials",
"."
] | [
"'''\n Login logs in with the provided credentials. All subsequent requests on the\n connection will act as the authenticated user.\n\n auth_tag : str\n bakery_version : int\n cli_args : str\n client_version : str\n credentials : str\n macaroons : typing.Sequ... | [
{
"param": "self",
"type": null
},
{
"param": "auth_tag",
"type": null
},
{
"param": "bakery_version",
"type": null
},
{
"param": "cli_args",
"type": null
},
{
"param": "client_version",
"type": null
},
{
"param": "credentials",
"type": null
},
... | {
"returns": [],
"raises": [],
"params": [
{
"identifier": "self",
"type": null,
"docstring": null,
"docstring_tokens": [],
"default": null,
"is_optional": null
},
{
"identifier": "auth_tag",
"type": null,
"docstring": null,
"docstring_tokens... |
f1c5edd2764131b66760835a53f04b87b39c931a | sed-i/python-libjuju | juju/client/_client3.py | [
"Apache-2.0"
] | Python | RedirectInfo | <not_specific> | async def RedirectInfo(self):
'''
RedirectInfo returns redirected host information for the model.
In Juju it always returns an error because the Juju controller
does not multiplex controllers.
Returns -> RedirectInfoResult
'''
# map input types to rpc msg
... |
RedirectInfo returns redirected host information for the model.
In Juju it always returns an error because the Juju controller
does not multiplex controllers.
Returns -> RedirectInfoResult
| RedirectInfo returns redirected host information for the model.
In Juju it always returns an error because the Juju controller
does not multiplex controllers.
| [
"RedirectInfo",
"returns",
"redirected",
"host",
"information",
"for",
"the",
"model",
".",
"In",
"Juju",
"it",
"always",
"returns",
"an",
"error",
"because",
"the",
"Juju",
"controller",
"does",
"not",
"multiplex",
"controllers",
"."
] | async def RedirectInfo(self):
_params = dict()
msg = dict(type='Admin',
request='RedirectInfo',
version=3,
params=_params)
reply = await self.rpc(msg)
return reply | [
"async",
"def",
"RedirectInfo",
"(",
"self",
")",
":",
"_params",
"=",
"dict",
"(",
")",
"msg",
"=",
"dict",
"(",
"type",
"=",
"'Admin'",
",",
"request",
"=",
"'RedirectInfo'",
",",
"version",
"=",
"3",
",",
"params",
"=",
"_params",
")",
"reply",
"=... | RedirectInfo returns redirected host information for the model. | [
"RedirectInfo",
"returns",
"redirected",
"host",
"information",
"for",
"the",
"model",
"."
] | [
"'''\n RedirectInfo returns redirected host information for the model.\n In Juju it always returns an error because the Juju controller\n does not multiplex controllers.\n\n\n Returns -> RedirectInfoResult\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": []
} |
f1c5edd2764131b66760835a53f04b87b39c931a | sed-i/python-libjuju | juju/client/_client3.py | [
"Apache-2.0"
] | Python | CharmRelations | <not_specific> | async def CharmRelations(self, application=None):
'''
application : str
Returns -> ApplicationCharmRelationsResults
'''
if application is not None and not isinstance(application, (bytes, str)):
raise Exception("Expected application to be a str, received: {}".format(ty... |
application : str
Returns -> ApplicationCharmRelationsResults
| application : str
Returns -> ApplicationCharmRelationsResults | [
"application",
":",
"str",
"Returns",
"-",
">",
"ApplicationCharmRelationsResults"
] | async def CharmRelations(self, application=None):
if application is not None and not isinstance(application, (bytes, str)):
raise Exception("Expected application to be a str, received: {}".format(type(application)))
_params = dict()
msg = dict(type='Application',
r... | [
"async",
"def",
"CharmRelations",
"(",
"self",
",",
"application",
"=",
"None",
")",
":",
"if",
"application",
"is",
"not",
"None",
"and",
"not",
"isinstance",
"(",
"application",
",",
"(",
"bytes",
",",
"str",
")",
")",
":",
"raise",
"Exception",
"(",
... | application : str
Returns -> ApplicationCharmRelationsResults | [
"application",
":",
"str",
"Returns",
"-",
">",
"ApplicationCharmRelationsResults"
] | [
"'''\n application : str\n Returns -> ApplicationCharmRelationsResults\n '''",
"# map input types to rpc msg"
] | [
{
"param": "self",
"type": null
},
{
"param": "application",
"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... |
f1c5edd2764131b66760835a53f04b87b39c931a | sed-i/python-libjuju | juju/client/_client3.py | [
"Apache-2.0"
] | Python | Get | <not_specific> | async def Get(self, application=None):
'''
application : str
Returns -> ApplicationGetResults
'''
if application is not None and not isinstance(application, (bytes, str)):
raise Exception("Expected application to be a str, received: {}".format(type(application)))
... |
application : str
Returns -> ApplicationGetResults
| application : str
Returns -> ApplicationGetResults | [
"application",
":",
"str",
"Returns",
"-",
">",
"ApplicationGetResults"
] | async def Get(self, application=None):
if application is not None and not isinstance(application, (bytes, str)):
raise Exception("Expected application to be a str, received: {}".format(type(application)))
_params = dict()
msg = dict(type='Application',
request='Get... | [
"async",
"def",
"Get",
"(",
"self",
",",
"application",
"=",
"None",
")",
":",
"if",
"application",
"is",
"not",
"None",
"and",
"not",
"isinstance",
"(",
"application",
",",
"(",
"bytes",
",",
"str",
")",
")",
":",
"raise",
"Exception",
"(",
"\"Expecte... | application : str
Returns -> ApplicationGetResults | [
"application",
":",
"str",
"Returns",
"-",
">",
"ApplicationGetResults"
] | [
"'''\n application : str\n Returns -> ApplicationGetResults\n '''",
"# map input types to rpc msg"
] | [
{
"param": "self",
"type": null
},
{
"param": "application",
"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... |
f1c5edd2764131b66760835a53f04b87b39c931a | sed-i/python-libjuju | juju/client/_client3.py | [
"Apache-2.0"
] | Python | GetConstraints | <not_specific> | async def GetConstraints(self, application=None):
'''
application : str
Returns -> GetConstraintsResults
'''
if application is not None and not isinstance(application, (bytes, str)):
raise Exception("Expected application to be a str, received: {}".format(type(applicat... |
application : str
Returns -> GetConstraintsResults
| application : str
Returns -> GetConstraintsResults | [
"application",
":",
"str",
"Returns",
"-",
">",
"GetConstraintsResults"
] | async def GetConstraints(self, application=None):
if application is not None and not isinstance(application, (bytes, str)):
raise Exception("Expected application to be a str, received: {}".format(type(application)))
_params = dict()
msg = dict(type='Application',
r... | [
"async",
"def",
"GetConstraints",
"(",
"self",
",",
"application",
"=",
"None",
")",
":",
"if",
"application",
"is",
"not",
"None",
"and",
"not",
"isinstance",
"(",
"application",
",",
"(",
"bytes",
",",
"str",
")",
")",
":",
"raise",
"Exception",
"(",
... | application : str
Returns -> GetConstraintsResults | [
"application",
":",
"str",
"Returns",
"-",
">",
"GetConstraintsResults"
] | [
"'''\n application : str\n Returns -> GetConstraintsResults\n '''",
"# map input types to rpc msg"
] | [
{
"param": "self",
"type": null
},
{
"param": "application",
"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... |
f1c5edd2764131b66760835a53f04b87b39c931a | sed-i/python-libjuju | juju/client/_client3.py | [
"Apache-2.0"
] | Python | ApplicationOffers | <not_specific> | async def ApplicationOffers(self, bakery_version=None, offer_urls=None):
'''
ApplicationOffers gets details about remote applications that match given URLs.
bakery_version : int
offer_urls : typing.Sequence[str]
Returns -> ApplicationOffersResults
'''
if bakery_v... |
ApplicationOffers gets details about remote applications that match given URLs.
bakery_version : int
offer_urls : typing.Sequence[str]
Returns -> ApplicationOffersResults
| ApplicationOffers gets details about remote applications that match given URLs. | [
"ApplicationOffers",
"gets",
"details",
"about",
"remote",
"applications",
"that",
"match",
"given",
"URLs",
"."
] | async def ApplicationOffers(self, bakery_version=None, offer_urls=None):
if bakery_version is not None and not isinstance(bakery_version, int):
raise Exception("Expected bakery_version to be a int, received: {}".format(type(bakery_version)))
if offer_urls is not None and not isinstance(offer... | [
"async",
"def",
"ApplicationOffers",
"(",
"self",
",",
"bakery_version",
"=",
"None",
",",
"offer_urls",
"=",
"None",
")",
":",
"if",
"bakery_version",
"is",
"not",
"None",
"and",
"not",
"isinstance",
"(",
"bakery_version",
",",
"int",
")",
":",
"raise",
"... | ApplicationOffers gets details about remote applications that match given URLs. | [
"ApplicationOffers",
"gets",
"details",
"about",
"remote",
"applications",
"that",
"match",
"given",
"URLs",
"."
] | [
"'''\n ApplicationOffers gets details about remote applications that match given URLs.\n\n bakery_version : int\n offer_urls : typing.Sequence[str]\n Returns -> ApplicationOffersResults\n '''",
"# map input types to rpc msg"
] | [
{
"param": "self",
"type": null
},
{
"param": "bakery_version",
"type": null
},
{
"param": "offer_urls",
"type": null
}
] | {
"returns": [],
"raises": [],
"params": [
{
"identifier": "self",
"type": null,
"docstring": null,
"docstring_tokens": [],
"default": null,
"is_optional": null
},
{
"identifier": "bakery_version",
"type": null,
"docstring": null,
"docstring_... |
f1c5edd2764131b66760835a53f04b87b39c931a | sed-i/python-libjuju | juju/client/_client3.py | [
"Apache-2.0"
] | Python | DestroyOffers | <not_specific> | async def DestroyOffers(self, force=None, offer_urls=None):
'''
DestroyOffers removes the offers specified by the given URLs, forcing if necessary.
force : bool
offer_urls : typing.Sequence[str]
Returns -> ErrorResults
'''
if force is not None and not isinstance(... |
DestroyOffers removes the offers specified by the given URLs, forcing if necessary.
force : bool
offer_urls : typing.Sequence[str]
Returns -> ErrorResults
| DestroyOffers removes the offers specified by the given URLs, forcing if necessary.
force : bool
offer_urls : typing.Sequence[str]
Returns -> ErrorResults | [
"DestroyOffers",
"removes",
"the",
"offers",
"specified",
"by",
"the",
"given",
"URLs",
"forcing",
"if",
"necessary",
".",
"force",
":",
"bool",
"offer_urls",
":",
"typing",
".",
"Sequence",
"[",
"str",
"]",
"Returns",
"-",
">",
"ErrorResults"
] | async def DestroyOffers(self, force=None, offer_urls=None):
if force is not None and not isinstance(force, bool):
raise Exception("Expected force to be a bool, received: {}".format(type(force)))
if offer_urls is not None and not isinstance(offer_urls, (bytes, str, list)):
raise E... | [
"async",
"def",
"DestroyOffers",
"(",
"self",
",",
"force",
"=",
"None",
",",
"offer_urls",
"=",
"None",
")",
":",
"if",
"force",
"is",
"not",
"None",
"and",
"not",
"isinstance",
"(",
"force",
",",
"bool",
")",
":",
"raise",
"Exception",
"(",
"\"Expect... | DestroyOffers removes the offers specified by the given URLs, forcing if necessary. | [
"DestroyOffers",
"removes",
"the",
"offers",
"specified",
"by",
"the",
"given",
"URLs",
"forcing",
"if",
"necessary",
"."
] | [
"'''\n DestroyOffers removes the offers specified by the given URLs, forcing if necessary.\n\n force : bool\n offer_urls : typing.Sequence[str]\n Returns -> ErrorResults\n '''",
"# map input types to rpc msg"
] | [
{
"param": "self",
"type": null
},
{
"param": "force",
"type": null
},
{
"param": "offer_urls",
"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": ... |
f1c5edd2764131b66760835a53f04b87b39c931a | sed-i/python-libjuju | juju/client/_client3.py | [
"Apache-2.0"
] | Python | FindApplicationOffers | <not_specific> | async def FindApplicationOffers(self, filters=None):
'''
FindApplicationOffers gets details about remote applications that match given filter.
filters : typing.Sequence[~OfferFilter]
Returns -> QueryApplicationOffersResults
'''
if filters is not None and not isinstance(f... |
FindApplicationOffers gets details about remote applications that match given filter.
filters : typing.Sequence[~OfferFilter]
Returns -> QueryApplicationOffersResults
| FindApplicationOffers gets details about remote applications that match given filter. | [
"FindApplicationOffers",
"gets",
"details",
"about",
"remote",
"applications",
"that",
"match",
"given",
"filter",
"."
] | async def FindApplicationOffers(self, filters=None):
if filters is not None and not isinstance(filters, (bytes, str, list)):
raise Exception("Expected filters to be a Sequence, received: {}".format(type(filters)))
_params = dict()
msg = dict(type='ApplicationOffers',
... | [
"async",
"def",
"FindApplicationOffers",
"(",
"self",
",",
"filters",
"=",
"None",
")",
":",
"if",
"filters",
"is",
"not",
"None",
"and",
"not",
"isinstance",
"(",
"filters",
",",
"(",
"bytes",
",",
"str",
",",
"list",
")",
")",
":",
"raise",
"Exceptio... | FindApplicationOffers gets details about remote applications that match given filter. | [
"FindApplicationOffers",
"gets",
"details",
"about",
"remote",
"applications",
"that",
"match",
"given",
"filter",
"."
] | [
"'''\n FindApplicationOffers gets details about remote applications that match given filter.\n\n filters : typing.Sequence[~OfferFilter]\n Returns -> QueryApplicationOffersResults\n '''",
"# map input types to rpc msg"
] | [
{
"param": "self",
"type": null
},
{
"param": "filters",
"type": null
}
] | {
"returns": [],
"raises": [],
"params": [
{
"identifier": "self",
"type": null,
"docstring": null,
"docstring_tokens": [],
"default": null,
"is_optional": null
},
{
"identifier": "filters",
"type": null,
"docstring": null,
"docstring_tokens"... |
f1c5edd2764131b66760835a53f04b87b39c931a | sed-i/python-libjuju | juju/client/_client3.py | [
"Apache-2.0"
] | Python | GetConsumeDetails | <not_specific> | async def GetConsumeDetails(self, offer_urls=None, user_tag=None):
'''
GetConsumeDetails returns the details necessary to pass to another model
to allow the specified args user to consume the offers represented by the args URLs.
offer_urls : OfferURLs
user_tag : str
Retu... |
GetConsumeDetails returns the details necessary to pass to another model
to allow the specified args user to consume the offers represented by the args URLs.
offer_urls : OfferURLs
user_tag : str
Returns -> ConsumeOfferDetailsResults
| GetConsumeDetails returns the details necessary to pass to another model
to allow the specified args user to consume the offers represented by the args URLs.
| [
"GetConsumeDetails",
"returns",
"the",
"details",
"necessary",
"to",
"pass",
"to",
"another",
"model",
"to",
"allow",
"the",
"specified",
"args",
"user",
"to",
"consume",
"the",
"offers",
"represented",
"by",
"the",
"args",
"URLs",
"."
] | async def GetConsumeDetails(self, offer_urls=None, user_tag=None):
if offer_urls is not None and not isinstance(offer_urls, (dict, OfferURLs)):
raise Exception("Expected offer_urls to be a OfferURLs, received: {}".format(type(offer_urls)))
if user_tag is not None and not isinstance(user_tag,... | [
"async",
"def",
"GetConsumeDetails",
"(",
"self",
",",
"offer_urls",
"=",
"None",
",",
"user_tag",
"=",
"None",
")",
":",
"if",
"offer_urls",
"is",
"not",
"None",
"and",
"not",
"isinstance",
"(",
"offer_urls",
",",
"(",
"dict",
",",
"OfferURLs",
")",
")"... | GetConsumeDetails returns the details necessary to pass to another model
to allow the specified args user to consume the offers represented by the args URLs. | [
"GetConsumeDetails",
"returns",
"the",
"details",
"necessary",
"to",
"pass",
"to",
"another",
"model",
"to",
"allow",
"the",
"specified",
"args",
"user",
"to",
"consume",
"the",
"offers",
"represented",
"by",
"the",
"args",
"URLs",
"."
] | [
"'''\n GetConsumeDetails returns the details necessary to pass to another model\n to allow the specified args user to consume the offers represented by the args URLs.\n\n offer_urls : OfferURLs\n user_tag : str\n Returns -> ConsumeOfferDetailsResults\n '''",
"# map input ... | [
{
"param": "self",
"type": null
},
{
"param": "offer_urls",
"type": null
},
{
"param": "user_tag",
"type": null
}
] | {
"returns": [],
"raises": [],
"params": [
{
"identifier": "self",
"type": null,
"docstring": null,
"docstring_tokens": [],
"default": null,
"is_optional": null
},
{
"identifier": "offer_urls",
"type": null,
"docstring": null,
"docstring_toke... |
f1c5edd2764131b66760835a53f04b87b39c931a | sed-i/python-libjuju | juju/client/_client3.py | [
"Apache-2.0"
] | Python | ListApplicationOffers | <not_specific> | async def ListApplicationOffers(self, filters=None):
'''
ListApplicationOffers gets deployed details about application offers that match given filter.
The results contain details about the deployed applications such as connection count.
filters : typing.Sequence[~OfferFilter]
Re... |
ListApplicationOffers gets deployed details about application offers that match given filter.
The results contain details about the deployed applications such as connection count.
filters : typing.Sequence[~OfferFilter]
Returns -> QueryApplicationOffersResults
| ListApplicationOffers gets deployed details about application offers that match given filter.
The results contain details about the deployed applications such as connection count.
| [
"ListApplicationOffers",
"gets",
"deployed",
"details",
"about",
"application",
"offers",
"that",
"match",
"given",
"filter",
".",
"The",
"results",
"contain",
"details",
"about",
"the",
"deployed",
"applications",
"such",
"as",
"connection",
"count",
"."
] | async def ListApplicationOffers(self, filters=None):
if filters is not None and not isinstance(filters, (bytes, str, list)):
raise Exception("Expected filters to be a Sequence, received: {}".format(type(filters)))
_params = dict()
msg = dict(type='ApplicationOffers',
... | [
"async",
"def",
"ListApplicationOffers",
"(",
"self",
",",
"filters",
"=",
"None",
")",
":",
"if",
"filters",
"is",
"not",
"None",
"and",
"not",
"isinstance",
"(",
"filters",
",",
"(",
"bytes",
",",
"str",
",",
"list",
")",
")",
":",
"raise",
"Exceptio... | ListApplicationOffers gets deployed details about application offers that match given filter. | [
"ListApplicationOffers",
"gets",
"deployed",
"details",
"about",
"application",
"offers",
"that",
"match",
"given",
"filter",
"."
] | [
"'''\n ListApplicationOffers gets deployed details about application offers that match given filter.\n The results contain details about the deployed applications such as connection count.\n\n filters : typing.Sequence[~OfferFilter]\n Returns -> QueryApplicationOffersResults\n '''... | [
{
"param": "self",
"type": null
},
{
"param": "filters",
"type": null
}
] | {
"returns": [],
"raises": [],
"params": [
{
"identifier": "self",
"type": null,
"docstring": null,
"docstring_tokens": [],
"default": null,
"is_optional": null
},
{
"identifier": "filters",
"type": null,
"docstring": null,
"docstring_tokens"... |
f1c5edd2764131b66760835a53f04b87b39c931a | sed-i/python-libjuju | juju/client/_client3.py | [
"Apache-2.0"
] | Python | ModifyOfferAccess | <not_specific> | async def ModifyOfferAccess(self, changes=None):
'''
ModifyOfferAccess changes the application offer access granted to users.
changes : typing.Sequence[~ModifyOfferAccess]
Returns -> ErrorResults
'''
if changes is not None and not isinstance(changes, (bytes, str, list)):... |
ModifyOfferAccess changes the application offer access granted to users.
changes : typing.Sequence[~ModifyOfferAccess]
Returns -> ErrorResults
| ModifyOfferAccess changes the application offer access granted to users. | [
"ModifyOfferAccess",
"changes",
"the",
"application",
"offer",
"access",
"granted",
"to",
"users",
"."
] | async def ModifyOfferAccess(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='ApplicationOffers',
r... | [
"async",
"def",
"ModifyOfferAccess",
"(",
"self",
",",
"changes",
"=",
"None",
")",
":",
"if",
"changes",
"is",
"not",
"None",
"and",
"not",
"isinstance",
"(",
"changes",
",",
"(",
"bytes",
",",
"str",
",",
"list",
")",
")",
":",
"raise",
"Exception",
... | ModifyOfferAccess changes the application offer access granted to users. | [
"ModifyOfferAccess",
"changes",
"the",
"application",
"offer",
"access",
"granted",
"to",
"users",
"."
] | [
"'''\n ModifyOfferAccess changes the application offer access granted to users.\n\n changes : typing.Sequence[~ModifyOfferAccess]\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"... |
f1c5edd2764131b66760835a53f04b87b39c931a | sed-i/python-libjuju | juju/client/_client3.py | [
"Apache-2.0"
] | Python | Offer | <not_specific> | async def Offer(self, offers=None):
'''
Offer makes application endpoints available for consumption at a specified URL.
offers : typing.Sequence[~AddApplicationOffer]
Returns -> ErrorResults
'''
if offers is not None and not isinstance(offers, (bytes, str, list)):
... |
Offer makes application endpoints available for consumption at a specified URL.
offers : typing.Sequence[~AddApplicationOffer]
Returns -> ErrorResults
| Offer makes application endpoints available for consumption at a specified URL. | [
"Offer",
"makes",
"application",
"endpoints",
"available",
"for",
"consumption",
"at",
"a",
"specified",
"URL",
"."
] | async def Offer(self, offers=None):
if offers is not None and not isinstance(offers, (bytes, str, list)):
raise Exception("Expected offers to be a Sequence, received: {}".format(type(offers)))
_params = dict()
msg = dict(type='ApplicationOffers',
request='Offer',
... | [
"async",
"def",
"Offer",
"(",
"self",
",",
"offers",
"=",
"None",
")",
":",
"if",
"offers",
"is",
"not",
"None",
"and",
"not",
"isinstance",
"(",
"offers",
",",
"(",
"bytes",
",",
"str",
",",
"list",
")",
")",
":",
"raise",
"Exception",
"(",
"\"Exp... | Offer makes application endpoints available for consumption at a specified URL. | [
"Offer",
"makes",
"application",
"endpoints",
"available",
"for",
"consumption",
"at",
"a",
"specified",
"URL",
"."
] | [
"'''\n Offer makes application endpoints available for consumption at a specified URL.\n\n offers : typing.Sequence[~AddApplicationOffer]\n Returns -> ErrorResults\n '''",
"# map input types to rpc msg"
] | [
{
"param": "self",
"type": null
},
{
"param": "offers",
"type": null
}
] | {
"returns": [],
"raises": [],
"params": [
{
"identifier": "self",
"type": null,
"docstring": null,
"docstring_tokens": [],
"default": null,
"is_optional": null
},
{
"identifier": "offers",
"type": null,
"docstring": null,
"docstring_tokens":... |
f1c5edd2764131b66760835a53f04b87b39c931a | sed-i/python-libjuju | juju/client/_client3.py | [
"Apache-2.0"
] | Python | RemoteApplicationInfo | <not_specific> | async def RemoteApplicationInfo(self, bakery_version=None, offer_urls=None):
'''
RemoteApplicationInfo returns information about the requested remote application.
This call currently has no client side API, only there for the GUI at this stage.
bakery_version : int
offer_urls : ... |
RemoteApplicationInfo returns information about the requested remote application.
This call currently has no client side API, only there for the GUI at this stage.
bakery_version : int
offer_urls : typing.Sequence[str]
Returns -> RemoteApplicationInfoResults
| RemoteApplicationInfo returns information about the requested remote application.
This call currently has no client side API, only there for the GUI at this stage.
| [
"RemoteApplicationInfo",
"returns",
"information",
"about",
"the",
"requested",
"remote",
"application",
".",
"This",
"call",
"currently",
"has",
"no",
"client",
"side",
"API",
"only",
"there",
"for",
"the",
"GUI",
"at",
"this",
"stage",
"."
] | async def RemoteApplicationInfo(self, bakery_version=None, offer_urls=None):
if bakery_version is not None and not isinstance(bakery_version, int):
raise Exception("Expected bakery_version to be a int, received: {}".format(type(bakery_version)))
if offer_urls is not None and not isinstance(o... | [
"async",
"def",
"RemoteApplicationInfo",
"(",
"self",
",",
"bakery_version",
"=",
"None",
",",
"offer_urls",
"=",
"None",
")",
":",
"if",
"bakery_version",
"is",
"not",
"None",
"and",
"not",
"isinstance",
"(",
"bakery_version",
",",
"int",
")",
":",
"raise",... | RemoteApplicationInfo returns information about the requested remote application. | [
"RemoteApplicationInfo",
"returns",
"information",
"about",
"the",
"requested",
"remote",
"application",
"."
] | [
"'''\n RemoteApplicationInfo returns information about the requested remote application.\n This call currently has no client side API, only there for the GUI at this stage.\n\n bakery_version : int\n offer_urls : typing.Sequence[str]\n Returns -> RemoteApplicationInfoResults\n ... | [
{
"param": "self",
"type": null
},
{
"param": "bakery_version",
"type": null
},
{
"param": "offer_urls",
"type": null
}
] | {
"returns": [],
"raises": [],
"params": [
{
"identifier": "self",
"type": null,
"docstring": null,
"docstring_tokens": [],
"default": null,
"is_optional": null
},
{
"identifier": "bakery_version",
"type": null,
"docstring": null,
"docstring_... |
f1c5edd2764131b66760835a53f04b87b39c931a | sed-i/python-libjuju | juju/client/_client3.py | [
"Apache-2.0"
] | Python | AddCharm | <not_specific> | async def AddCharm(self, charm_origin=None, force=None, series=None, url=None):
'''
AddCharm adds the given charm URL (which must include revision) to the
environment, if it does not exist yet. Local charms are not supported,
only charm store and charm hub URLs. See also AddLocalCharm().... |
AddCharm adds the given charm URL (which must include revision) to the
environment, if it does not exist yet. Local charms are not supported,
only charm store and charm hub URLs. See also AddLocalCharm().
charm_origin : CharmOrigin
force : bool
series : str
url ... | AddCharm adds the given charm URL (which must include revision) to the
environment, if it does not exist yet. Local charms are not supported,
only charm store and charm hub URLs.
charm_origin : CharmOrigin
force : bool
series : str
url : str
Returns -> CharmOriginResult | [
"AddCharm",
"adds",
"the",
"given",
"charm",
"URL",
"(",
"which",
"must",
"include",
"revision",
")",
"to",
"the",
"environment",
"if",
"it",
"does",
"not",
"exist",
"yet",
".",
"Local",
"charms",
"are",
"not",
"supported",
"only",
"charm",
"store",
"and",... | async def AddCharm(self, charm_origin=None, force=None, series=None, url=None):
if charm_origin is not None and not isinstance(charm_origin, (dict, CharmOrigin)):
raise Exception("Expected charm_origin to be a CharmOrigin, received: {}".format(type(charm_origin)))
if force is not None and no... | [
"async",
"def",
"AddCharm",
"(",
"self",
",",
"charm_origin",
"=",
"None",
",",
"force",
"=",
"None",
",",
"series",
"=",
"None",
",",
"url",
"=",
"None",
")",
":",
"if",
"charm_origin",
"is",
"not",
"None",
"and",
"not",
"isinstance",
"(",
"charm_orig... | AddCharm adds the given charm URL (which must include revision) to the
environment, if it does not exist yet. | [
"AddCharm",
"adds",
"the",
"given",
"charm",
"URL",
"(",
"which",
"must",
"include",
"revision",
")",
"to",
"the",
"environment",
"if",
"it",
"does",
"not",
"exist",
"yet",
"."
] | [
"'''\n AddCharm adds the given charm URL (which must include revision) to the\n environment, if it does not exist yet. Local charms are not supported,\n only charm store and charm hub URLs. See also AddLocalCharm().\n\n charm_origin : CharmOrigin\n force : bool\n series : s... | [
{
"param": "self",
"type": null
},
{
"param": "charm_origin",
"type": null
},
{
"param": "force",
"type": null
},
{
"param": "series",
"type": null
},
{
"param": "url",
"type": null
}
] | {
"returns": [],
"raises": [],
"params": [
{
"identifier": "self",
"type": null,
"docstring": null,
"docstring_tokens": [],
"default": null,
"is_optional": null
},
{
"identifier": "charm_origin",
"type": null,
"docstring": null,
"docstring_to... |
f1c5edd2764131b66760835a53f04b87b39c931a | sed-i/python-libjuju | juju/client/_client3.py | [
"Apache-2.0"
] | Python | AddCharmWithAuthorization | <not_specific> | async def AddCharmWithAuthorization(self, charm_origin=None, force=None, macaroon=None, series=None, url=None):
'''
AddCharmWithAuthorization adds the given charm URL (which must include
revision) to the environment, if it does not exist yet. Local charms are
not supported, only charm st... |
AddCharmWithAuthorization adds the given charm URL (which must include
revision) to the environment, if it does not exist yet. Local charms are
not supported, only charm store and charm hub URLs. See also AddLocalCharm().
The authorization macaroon, args.CharmStoreMacaroon, may be
... | AddCharmWithAuthorization adds the given charm URL (which must include
revision) to the environment, if it does not exist yet. Local charms are
not supported, only charm store and charm hub URLs.
The authorization macaroon, args.CharmStoreMacaroon, may be
omitted, in which case this call is equivalent to AddCharm.
| [
"AddCharmWithAuthorization",
"adds",
"the",
"given",
"charm",
"URL",
"(",
"which",
"must",
"include",
"revision",
")",
"to",
"the",
"environment",
"if",
"it",
"does",
"not",
"exist",
"yet",
".",
"Local",
"charms",
"are",
"not",
"supported",
"only",
"charm",
... | async def AddCharmWithAuthorization(self, charm_origin=None, force=None, macaroon=None, series=None, url=None):
if charm_origin is not None and not isinstance(charm_origin, (dict, CharmOrigin)):
raise Exception("Expected charm_origin to be a CharmOrigin, received: {}".format(type(charm_origin)))
... | [
"async",
"def",
"AddCharmWithAuthorization",
"(",
"self",
",",
"charm_origin",
"=",
"None",
",",
"force",
"=",
"None",
",",
"macaroon",
"=",
"None",
",",
"series",
"=",
"None",
",",
"url",
"=",
"None",
")",
":",
"if",
"charm_origin",
"is",
"not",
"None",... | AddCharmWithAuthorization adds the given charm URL (which must include
revision) to the environment, if it does not exist yet. | [
"AddCharmWithAuthorization",
"adds",
"the",
"given",
"charm",
"URL",
"(",
"which",
"must",
"include",
"revision",
")",
"to",
"the",
"environment",
"if",
"it",
"does",
"not",
"exist",
"yet",
"."
] | [
"'''\n AddCharmWithAuthorization adds the given charm URL (which must include\n revision) to the environment, if it does not exist yet. Local charms are\n not supported, only charm store and charm hub URLs. See also AddLocalCharm().\n\n The authorization macaroon, args.CharmStoreMacaroon... | [
{
"param": "self",
"type": null
},
{
"param": "charm_origin",
"type": null
},
{
"param": "force",
"type": null
},
{
"param": "macaroon",
"type": null
},
{
"param": "series",
"type": null
},
{
"param": "url",
"type": null
}
] | {
"returns": [],
"raises": [],
"params": [
{
"identifier": "self",
"type": null,
"docstring": null,
"docstring_tokens": [],
"default": null,
"is_optional": null
},
{
"identifier": "charm_origin",
"type": null,
"docstring": null,
"docstring_to... |
f1c5edd2764131b66760835a53f04b87b39c931a | sed-i/python-libjuju | juju/client/_client3.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=3,
... | [
"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": []... |
f1c5edd2764131b66760835a53f04b87b39c931a | sed-i/python-libjuju | juju/client/_client3.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=3,
... | [
"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": []... |
f1c5edd2764131b66760835a53f04b87b39c931a | sed-i/python-libjuju | juju/client/_client3.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\n be filtered 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": ... |
f1c5edd2764131b66760835a53f04b87b39c931a | sed-i/python-libjuju | juju/client/_client3.py | [
"Apache-2.0"
] | Python | ResolveCharms | <not_specific> | async def ResolveCharms(self, macaroon=None, resolve=None):
'''
ResolveCharms resolves the given charm URLs with an optionally specified
preferred channel. Channel provided via CharmOrigin.
macaroon : Macaroon
resolve : typing.Sequence[~ResolveCharmWithChannel]
Returns ... |
ResolveCharms resolves the given charm URLs with an optionally specified
preferred channel. Channel provided via CharmOrigin.
macaroon : Macaroon
resolve : typing.Sequence[~ResolveCharmWithChannel]
Returns -> ResolveCharmWithChannelResults
| ResolveCharms resolves the given charm URLs with an optionally specified
preferred channel. Channel provided via CharmOrigin.
macaroon : Macaroon
resolve : typing.Sequence[~ResolveCharmWithChannel]
Returns -> ResolveCharmWithChannelResults | [
"ResolveCharms",
"resolves",
"the",
"given",
"charm",
"URLs",
"with",
"an",
"optionally",
"specified",
"preferred",
"channel",
".",
"Channel",
"provided",
"via",
"CharmOrigin",
".",
"macaroon",
":",
"Macaroon",
"resolve",
":",
"typing",
".",
"Sequence",
"[",
"~R... | async def ResolveCharms(self, macaroon=None, resolve=None):
if macaroon is not None and not isinstance(macaroon, (dict, Macaroon)):
raise Exception("Expected macaroon to be a Macaroon, received: {}".format(type(macaroon)))
if resolve is not None and not isinstance(resolve, (bytes, str, list)... | [
"async",
"def",
"ResolveCharms",
"(",
"self",
",",
"macaroon",
"=",
"None",
",",
"resolve",
"=",
"None",
")",
":",
"if",
"macaroon",
"is",
"not",
"None",
"and",
"not",
"isinstance",
"(",
"macaroon",
",",
"(",
"dict",
",",
"Macaroon",
")",
")",
":",
"... | ResolveCharms resolves the given charm URLs with an optionally specified
preferred channel. | [
"ResolveCharms",
"resolves",
"the",
"given",
"charm",
"URLs",
"with",
"an",
"optionally",
"specified",
"preferred",
"channel",
"."
] | [
"'''\n ResolveCharms resolves the given charm URLs with an optionally specified\n preferred channel. Channel provided via CharmOrigin.\n\n macaroon : Macaroon\n resolve : typing.Sequence[~ResolveCharmWithChannel]\n Returns -> ResolveCharmWithChannelResults\n '''",
"# map... | [
{
"param": "self",
"type": null
},
{
"param": "macaroon",
"type": null
},
{
"param": "resolve",
"type": null
}
] | {
"returns": [],
"raises": [],
"params": [
{
"identifier": "self",
"type": null,
"docstring": null,
"docstring_tokens": [],
"default": null,
"is_optional": null
},
{
"identifier": "macaroon",
"type": null,
"docstring": null,
"docstring_tokens... |
f1c5edd2764131b66760835a53f04b87b39c931a | sed-i/python-libjuju | juju/client/_client3.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=3,
params=_params)
reply = await self.rpc(msg)
return reply | [
"async",
"def",
"APIHostPorts",
"(",
"self",
")",
":",
"_params",
"=",
"dict",
"(",
")",
"msg",
"=",
"dict",
"(",
"type",
"=",
"'Client'",
",",
"request",
"=",
"'APIHostPorts'",
",",
"version",
"=",
"3",
",",
"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": []
} |
f1c5edd2764131b66760835a53f04b87b39c931a | sed-i/python-libjuju | juju/client/_client3.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=3,
params=_params)
reply = await self.rpc(msg)
return reply | [
"async",
"def",
"AbortCurrentUpgrade",
"(",
"self",
")",
":",
"_params",
"=",
"dict",
"(",
")",
"msg",
"=",
"dict",
"(",
"type",
"=",
"'Client'",
",",
"request",
"=",
"'AbortCurrentUpgrade'",
",",
"version",
"=",
"3",
",",
"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": []
} |
f1c5edd2764131b66760835a53f04b87b39c931a | sed-i/python-libjuju | juju/client/_client3.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"... |
f1c5edd2764131b66760835a53f04b87b39c931a | sed-i/python-libjuju | juju/client/_client3.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":... |
f1c5edd2764131b66760835a53f04b87b39c931a | sed-i/python-libjuju | juju/client/_client3.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":... |
f1c5edd2764131b66760835a53f04b87b39c931a | sed-i/python-libjuju | juju/client/_client3.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=3,
params=_params)
reply = await self.rpc(msg)
return reply | [
"async",
"def",
"AgentVersion",
"(",
"self",
")",
":",
"_params",
"=",
"dict",
"(",
")",
"msg",
"=",
"dict",
"(",
"type",
"=",
"'Client'",
",",
"request",
"=",
"'AgentVersion'",
",",
"version",
"=",
"3",
",",
"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": []
} |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.