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 |
|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
9ea37a35dc8c47b3c3319b4189fc93bd51329bab | lemoniac/arca | apps/cc/test/arcacc.py | [
"MIT"
] | Python | compile_file | <not_specific> | def compile_file(filename):
"""compiles 'filename' and returns the standard output and error"""
proc = popen(["../cc", filename])
exitcode = proc.wait()
if exitcode < 0:
return (None, "compiler crash " + filename)
if exitcode != 0:
return (None, "compiler failed: " + filename)
er... | compiles 'filename' and returns the standard output and error | compiles 'filename' and returns the standard output and error | [
"compiles",
"'",
"filename",
"'",
"and",
"returns",
"the",
"standard",
"output",
"and",
"error"
] | def compile_file(filename):
proc = popen(["../cc", filename])
exitcode = proc.wait()
if exitcode < 0:
return (None, "compiler crash " + filename)
if exitcode != 0:
return (None, "compiler failed: " + filename)
err = ""
for line in proc.stderr:
err += line
out = ""
... | [
"def",
"compile_file",
"(",
"filename",
")",
":",
"proc",
"=",
"popen",
"(",
"[",
"\"../cc\"",
",",
"filename",
"]",
")",
"exitcode",
"=",
"proc",
".",
"wait",
"(",
")",
"if",
"exitcode",
"<",
"0",
":",
"return",
"(",
"None",
",",
"\"compiler crash \""... | compiles 'filename' and returns the standard output and error | [
"compiles",
"'",
"filename",
"'",
"and",
"returns",
"the",
"standard",
"output",
"and",
"error"
] | [
"\"\"\"compiles 'filename' and returns the standard output and error\"\"\""
] | [
{
"param": "filename",
"type": null
}
] | {
"returns": [],
"raises": [],
"params": [
{
"identifier": "filename",
"type": null,
"docstring": null,
"docstring_tokens": [],
"default": null,
"is_optional": null
}
],
"outlier_params": [],
"others": []
} |
9ea37a35dc8c47b3c3319b4189fc93bd51329bab | lemoniac/arca | apps/cc/test/arcacc.py | [
"MIT"
] | Python | run_file | <not_specific> | def run_file(filename, params):
"""run a file in the virtual machine and return the output and the return code"""
args = ["../../../emu"]
if "gpu" not in params or not params["gpu"]:
args.append("--no-gpu")
if "screenshot" in params:
args.append("--screenshot")
args.append(filename)
... | run a file in the virtual machine and return the output and the return code | run a file in the virtual machine and return the output and the return code | [
"run",
"a",
"file",
"in",
"the",
"virtual",
"machine",
"and",
"return",
"the",
"output",
"and",
"the",
"return",
"code"
] | def run_file(filename, params):
args = ["../../../emu"]
if "gpu" not in params or not params["gpu"]:
args.append("--no-gpu")
if "screenshot" in params:
args.append("--screenshot")
args.append(filename)
proc = popen(args)
if proc.wait() < 0:
return (None, "vm crashed", Non... | [
"def",
"run_file",
"(",
"filename",
",",
"params",
")",
":",
"args",
"=",
"[",
"\"../../../emu\"",
"]",
"if",
"\"gpu\"",
"not",
"in",
"params",
"or",
"not",
"params",
"[",
"\"gpu\"",
"]",
":",
"args",
".",
"append",
"(",
"\"--no-gpu\"",
")",
"if",
"\"s... | run a file in the virtual machine and return the output and the return code | [
"run",
"a",
"file",
"in",
"the",
"virtual",
"machine",
"and",
"return",
"the",
"output",
"and",
"the",
"return",
"code"
] | [
"\"\"\"run a file in the virtual machine and return the output and the return code\"\"\""
] | [
{
"param": "filename",
"type": null
},
{
"param": "params",
"type": null
}
] | {
"returns": [],
"raises": [],
"params": [
{
"identifier": "filename",
"type": null,
"docstring": null,
"docstring_tokens": [],
"default": null,
"is_optional": null
},
{
"identifier": "params",
"type": null,
"docstring": null,
"docstring_toke... |
75d768e7f8ca00395314cdaff7c51af9a8b99cc6 | lemoniac/arca | apps/cc/test/TestBase.py | [
"MIT"
] | Python | compile_file | <not_specific> | def compile_file(self, filename, assert_if_fail = False):
"""compiles 'filename' and returns the standard output and error"""
(out, err) = arcacc.compile_file(filename)
self.assertNotEqual(out, None, err)
return (out, err) | compiles 'filename' and returns the standard output and error | compiles 'filename' and returns the standard output and error | [
"compiles",
"'",
"filename",
"'",
"and",
"returns",
"the",
"standard",
"output",
"and",
"error"
] | def compile_file(self, filename, assert_if_fail = False):
(out, err) = arcacc.compile_file(filename)
self.assertNotEqual(out, None, err)
return (out, err) | [
"def",
"compile_file",
"(",
"self",
",",
"filename",
",",
"assert_if_fail",
"=",
"False",
")",
":",
"(",
"out",
",",
"err",
")",
"=",
"arcacc",
".",
"compile_file",
"(",
"filename",
")",
"self",
".",
"assertNotEqual",
"(",
"out",
",",
"None",
",",
"err... | compiles 'filename' and returns the standard output and error | [
"compiles",
"'",
"filename",
"'",
"and",
"returns",
"the",
"standard",
"output",
"and",
"error"
] | [
"\"\"\"compiles 'filename' and returns the standard output and error\"\"\""
] | [
{
"param": "self",
"type": null
},
{
"param": "filename",
"type": null
},
{
"param": "assert_if_fail",
"type": null
}
] | {
"returns": [],
"raises": [],
"params": [
{
"identifier": "self",
"type": null,
"docstring": null,
"docstring_tokens": [],
"default": null,
"is_optional": null
},
{
"identifier": "filename",
"type": null,
"docstring": null,
"docstring_tokens... |
75d768e7f8ca00395314cdaff7c51af9a8b99cc6 | lemoniac/arca | apps/cc/test/TestBase.py | [
"MIT"
] | Python | run_file | <not_specific> | def run_file(self, filename, params):
"""run a file in the virtual machine and return the output and the return code"""
(out, err, r1) = arcacc.run_file(filename, params)
self.assertNotEqual(out, None, err)
return (out, err, r1) | run a file in the virtual machine and return the output and the return code | run a file in the virtual machine and return the output and the return code | [
"run",
"a",
"file",
"in",
"the",
"virtual",
"machine",
"and",
"return",
"the",
"output",
"and",
"the",
"return",
"code"
] | def run_file(self, filename, params):
(out, err, r1) = arcacc.run_file(filename, params)
self.assertNotEqual(out, None, err)
return (out, err, r1) | [
"def",
"run_file",
"(",
"self",
",",
"filename",
",",
"params",
")",
":",
"(",
"out",
",",
"err",
",",
"r1",
")",
"=",
"arcacc",
".",
"run_file",
"(",
"filename",
",",
"params",
")",
"self",
".",
"assertNotEqual",
"(",
"out",
",",
"None",
",",
"err... | run a file in the virtual machine and return the output and the return code | [
"run",
"a",
"file",
"in",
"the",
"virtual",
"machine",
"and",
"return",
"the",
"output",
"and",
"the",
"return",
"code"
] | [
"\"\"\"run a file in the virtual machine and return the output and the return code\"\"\""
] | [
{
"param": "self",
"type": null
},
{
"param": "filename",
"type": null
},
{
"param": "params",
"type": null
}
] | {
"returns": [],
"raises": [],
"params": [
{
"identifier": "self",
"type": null,
"docstring": null,
"docstring_tokens": [],
"default": null,
"is_optional": null
},
{
"identifier": "filename",
"type": null,
"docstring": null,
"docstring_tokens... |
b721caf12b72ee6abcada59f044f43d584c08777 | gfedi/servififa | 2018/scripts/problema_3_c.py | [
"MIT"
] | Python | position_to_cell | <not_specific> | def position_to_cell(position):
"""
get position in the 5X5 grid
"""
x = position["x"]
y = position["y"]
if x <= 20:
cell_x = 0
elif x > 20 and x <= 40:
cell_x = 1
elif x > 40 and x <= 60:
cell_x = 2
elif x > 60 and x <= 80:
cell_x = 3
elif x > 80... |
get position in the 5X5 grid
| get position in the 5X5 grid | [
"get",
"position",
"in",
"the",
"5X5",
"grid"
] | def position_to_cell(position):
x = position["x"]
y = position["y"]
if x <= 20:
cell_x = 0
elif x > 20 and x <= 40:
cell_x = 1
elif x > 40 and x <= 60:
cell_x = 2
elif x > 60 and x <= 80:
cell_x = 3
elif x > 80:
cell_x = 4
if y <= 20:
cell_... | [
"def",
"position_to_cell",
"(",
"position",
")",
":",
"x",
"=",
"position",
"[",
"\"x\"",
"]",
"y",
"=",
"position",
"[",
"\"y\"",
"]",
"if",
"x",
"<=",
"20",
":",
"cell_x",
"=",
"0",
"elif",
"x",
">",
"20",
"and",
"x",
"<=",
"40",
":",
"cell_x",... | get position in the 5X5 grid | [
"get",
"position",
"in",
"the",
"5X5",
"grid"
] | [
"\"\"\"\n get position in the 5X5 grid\n \"\"\""
] | [
{
"param": "position",
"type": null
}
] | {
"returns": [],
"raises": [],
"params": [
{
"identifier": "position",
"type": null,
"docstring": null,
"docstring_tokens": [],
"default": null,
"is_optional": null
}
],
"outlier_params": [],
"others": []
} |
0fb30546d5e952b48fb5c406b97f21c0c9647660 | lucyb/cvc | cvc/Cvc.py | [
"MIT"
] | Python | generate_password | <not_specific> | def generate_password(self):
'''Generate a string with random characters in the format cvc-cvc-cvc
'''
words = [self.random_word() for i in range(0,3)]
return Cvc.separator.join(words) | Generate a string with random characters in the format cvc-cvc-cvc
| Generate a string with random characters in the format cvc-cvc-cvc | [
"Generate",
"a",
"string",
"with",
"random",
"characters",
"in",
"the",
"format",
"cvc",
"-",
"cvc",
"-",
"cvc"
] | def generate_password(self):
words = [self.random_word() for i in range(0,3)]
return Cvc.separator.join(words) | [
"def",
"generate_password",
"(",
"self",
")",
":",
"words",
"=",
"[",
"self",
".",
"random_word",
"(",
")",
"for",
"i",
"in",
"range",
"(",
"0",
",",
"3",
")",
"]",
"return",
"Cvc",
".",
"separator",
".",
"join",
"(",
"words",
")"
] | Generate a string with random characters in the format cvc-cvc-cvc | [
"Generate",
"a",
"string",
"with",
"random",
"characters",
"in",
"the",
"format",
"cvc",
"-",
"cvc",
"-",
"cvc"
] | [
"'''Generate a string with random characters in the format cvc-cvc-cvc\n '''"
] | [
{
"param": "self",
"type": null
}
] | {
"returns": [],
"raises": [],
"params": [
{
"identifier": "self",
"type": null,
"docstring": null,
"docstring_tokens": [],
"default": null,
"is_optional": null
}
],
"outlier_params": [],
"others": []
} |
1ee33185e4887ca50a25b8dd9ae209d542738303 | sublimelsp/LSP-terraform | plugin.py | [
"MIT"
] | Python | plat | Optional[str] | def plat() -> Optional[str]:
'''
Returns the user friendly platform version that
sublime is running on.
'''
if sublime.platform() == 'osx':
return 'darwin'
elif sublime.platform() == 'windows':
return 'windows'
elif sublime.platform() == 'linux':
if platform.system() ... |
Returns the user friendly platform version that
sublime is running on.
| Returns the user friendly platform version that
sublime is running on. | [
"Returns",
"the",
"user",
"friendly",
"platform",
"version",
"that",
"sublime",
"is",
"running",
"on",
"."
] | def plat() -> Optional[str]:
if sublime.platform() == 'osx':
return 'darwin'
elif sublime.platform() == 'windows':
return 'windows'
elif sublime.platform() == 'linux':
if platform.system() == 'Linux':
return 'linux'
elif sys.platform.startswith('freebsd'):
... | [
"def",
"plat",
"(",
")",
"->",
"Optional",
"[",
"str",
"]",
":",
"if",
"sublime",
".",
"platform",
"(",
")",
"==",
"'osx'",
":",
"return",
"'darwin'",
"elif",
"sublime",
".",
"platform",
"(",
")",
"==",
"'windows'",
":",
"return",
"'windows'",
"elif",
... | Returns the user friendly platform version that
sublime is running on. | [
"Returns",
"the",
"user",
"friendly",
"platform",
"version",
"that",
"sublime",
"is",
"running",
"on",
"."
] | [
"'''\n Returns the user friendly platform version that\n sublime is running on.\n '''"
] | [] | {
"returns": [],
"raises": [],
"params": [],
"outlier_params": [],
"others": []
} |
1ee33185e4887ca50a25b8dd9ae209d542738303 | sublimelsp/LSP-terraform | plugin.py | [
"MIT"
] | Python | arch | Optional[str] | def arch() -> Optional[str]:
'''
Returns the user friendly architecture version that
sublime is running on.
'''
if sublime.arch() == "x32":
return "386"
elif sublime.arch() == "x64":
return "amd64"
elif sublime.arch() == "arm64":
return "arm64"
else:
retur... |
Returns the user friendly architecture version that
sublime is running on.
| Returns the user friendly architecture version that
sublime is running on. | [
"Returns",
"the",
"user",
"friendly",
"architecture",
"version",
"that",
"sublime",
"is",
"running",
"on",
"."
] | def arch() -> Optional[str]:
if sublime.arch() == "x32":
return "386"
elif sublime.arch() == "x64":
return "amd64"
elif sublime.arch() == "arm64":
return "arm64"
else:
return None | [
"def",
"arch",
"(",
")",
"->",
"Optional",
"[",
"str",
"]",
":",
"if",
"sublime",
".",
"arch",
"(",
")",
"==",
"\"x32\"",
":",
"return",
"\"386\"",
"elif",
"sublime",
".",
"arch",
"(",
")",
"==",
"\"x64\"",
":",
"return",
"\"amd64\"",
"elif",
"sublim... | Returns the user friendly architecture version that
sublime is running on. | [
"Returns",
"the",
"user",
"friendly",
"architecture",
"version",
"that",
"sublime",
"is",
"running",
"on",
"."
] | [
"'''\n Returns the user friendly architecture version that\n sublime is running on.\n '''"
] | [] | {
"returns": [],
"raises": [],
"params": [],
"outlier_params": [],
"others": []
} |
2c1f352d97f0ef5fb2efbc82bf8f3b59b50990ac | MiirHo3eIN/Real_Time_BHM | common/processing.py | [
"MIT"
] | Python | fit | <not_specific> | def fit(self, dataset):
"""
fit the pca to find eigen values and eigen vectors of training set.
:param dataset: trainset in shape M (number of features) x N (number of samples)
:retrun Ex: Eigen-Values of PCA
:return Vx: Eigen-Vectors of PCA
:return k: Optimal Sub-space domain
"""
energy_percent... |
fit the pca to find eigen values and eigen vectors of training set.
:param dataset: trainset in shape M (number of features) x N (number of samples)
:retrun Ex: Eigen-Values of PCA
:return Vx: Eigen-Vectors of PCA
:return k: Optimal Sub-space domain
| fit the pca to find eigen values and eigen vectors of training set. | [
"fit",
"the",
"pca",
"to",
"find",
"eigen",
"values",
"and",
"eigen",
"vectors",
"of",
"training",
"set",
"."
] | def fit(self, dataset):
energy_percentage = 0.97
Cx = np.dot(dataset, dataset.T)/self.dim
Ex, Vx = np.linalg.eigh(Cx)
Ex = Ex[::-1]
Vx = Vx[:, ::-1]
lcumsum = np.cumsum(Ex/np.sum(Ex))
k = np.argmax(lcumsum > energy_percentage)
return Ex,Vx,k | [
"def",
"fit",
"(",
"self",
",",
"dataset",
")",
":",
"energy_percentage",
"=",
"0.97",
"Cx",
"=",
"np",
".",
"dot",
"(",
"dataset",
",",
"dataset",
".",
"T",
")",
"/",
"self",
".",
"dim",
"Ex",
",",
"Vx",
"=",
"np",
".",
"linalg",
".",
"eigh",
... | fit the pca to find eigen values and eigen vectors of training set. | [
"fit",
"the",
"pca",
"to",
"find",
"eigen",
"values",
"and",
"eigen",
"vectors",
"of",
"training",
"set",
"."
] | [
"\"\"\"\n\t\tfit the pca to find eigen values and eigen vectors of training set. \n\n\t\t:param dataset: trainset in shape M (number of features) x N (number of samples)\n\t\t:retrun Ex: \tEigen-Values of PCA \n\t\t:return Vx: \tEigen-Vectors of PCA \n\t\t:return k:\t\tOptimal Sub-space domain \n\t\t\"\"\""
] | [
{
"param": "self",
"type": null
},
{
"param": "dataset",
"type": null
}
] | {
"returns": [
{
"docstring": "Eigen-Vectors of PCA",
"docstring_tokens": [
"Eigen",
"-",
"Vectors",
"of",
"PCA"
],
"type": "Vx"
},
{
"docstring": "Optimal Sub-space domain",
"docstring_tokens": [
"Optimal",
"Sub",... |
2c1f352d97f0ef5fb2efbc82bf8f3b59b50990ac | MiirHo3eIN/Real_Time_BHM | common/processing.py | [
"MIT"
] | Python | pca_reconst | <not_specific> | def pca_reconst(self, data, eigenvector):
"""
Returns reconstructed signal based on Eigen Vectors and Compression Factor
:param data: original data in high space dimension
:param eigenvector: eigenvectors to project data from high dimensional to latens space
:param k: latent space
:return: recons... |
Returns reconstructed signal based on Eigen Vectors and Compression Factor
:param data: original data in high space dimension
:param eigenvector: eigenvectors to project data from high dimensional to latens space
:param k: latent space
:return: reconstructed signal
| Returns reconstructed signal based on Eigen Vectors and Compression Factor | [
"Returns",
"reconstructed",
"signal",
"based",
"on",
"Eigen",
"Vectors",
"and",
"Compression",
"Factor"
] | def pca_reconst(self, data, eigenvector):
return np.linalg.multi_dot([eigenvector[:, :self.cf], eigenvector[:, :self.cf].T, data]) | [
"def",
"pca_reconst",
"(",
"self",
",",
"data",
",",
"eigenvector",
")",
":",
"return",
"np",
".",
"linalg",
".",
"multi_dot",
"(",
"[",
"eigenvector",
"[",
":",
",",
":",
"self",
".",
"cf",
"]",
",",
"eigenvector",
"[",
":",
",",
":",
"self",
".",... | Returns reconstructed signal based on Eigen Vectors and Compression Factor | [
"Returns",
"reconstructed",
"signal",
"based",
"on",
"Eigen",
"Vectors",
"and",
"Compression",
"Factor"
] | [
"\"\"\"\n\t\tReturns reconstructed signal based on Eigen Vectors and Compression Factor \n\n\t\t:param data: \t\toriginal data in high space dimension \n\t\t:param eigenvector: eigenvectors to project data from high dimensional to latens space\n\t\t:param k: \t\t\tlatent space\n\t\t:return: \t\t\treconstructed sign... | [
{
"param": "self",
"type": null
},
{
"param": "data",
"type": null
},
{
"param": "eigenvector",
"type": null
}
] | {
"returns": [
{
"docstring": null,
"docstring_tokens": [
"None"
],
"type": null
}
],
"raises": [],
"params": [
{
"identifier": "self",
"type": null,
"docstring": null,
"docstring_tokens": [],
"default": null,
"is_optional": null
... |
2c1f352d97f0ef5fb2efbc82bf8f3b59b50990ac | MiirHo3eIN/Real_Time_BHM | common/processing.py | [
"MIT"
] | Python | predict_time_ | <not_specific> | def predict_time_(self, dataset, Vx):
"""
Compute Mean Square Error in time domain
:param dataset: 1D Acceleration
:param Vx: Eigen Values of trained pca
:return mse_: Single MSE for a period in time domain
"""
x_recons = self.pca_reconst(data = dataset, eigenvector = Vx)
mse_ = mse(dataset, x... |
Compute Mean Square Error in time domain
:param dataset: 1D Acceleration
:param Vx: Eigen Values of trained pca
:return mse_: Single MSE for a period in time domain
| Compute Mean Square Error in time domain | [
"Compute",
"Mean",
"Square",
"Error",
"in",
"time",
"domain"
] | def predict_time_(self, dataset, Vx):
x_recons = self.pca_reconst(data = dataset, eigenvector = Vx)
mse_ = mse(dataset, x_recons)
return mse_ | [
"def",
"predict_time_",
"(",
"self",
",",
"dataset",
",",
"Vx",
")",
":",
"x_recons",
"=",
"self",
".",
"pca_reconst",
"(",
"data",
"=",
"dataset",
",",
"eigenvector",
"=",
"Vx",
")",
"mse_",
"=",
"mse",
"(",
"dataset",
",",
"x_recons",
")",
"return",
... | Compute Mean Square Error in time domain | [
"Compute",
"Mean",
"Square",
"Error",
"in",
"time",
"domain"
] | [
"\"\"\"\n\t\tCompute Mean Square Error in time domain \n\n\t\t:param dataset: 1D Acceleration \n\t\t:param Vx: \t\tEigen Values of trained pca \n\t\t:return mse_:\tSingle MSE for a period in time domain \n\t\t\"\"\""
] | [
{
"param": "self",
"type": null
},
{
"param": "dataset",
"type": null
},
{
"param": "Vx",
"type": null
}
] | {
"returns": [
{
"docstring": "Single MSE for a period in time domain",
"docstring_tokens": [
"Single",
"MSE",
"for",
"a",
"period",
"in",
"time",
"domain"
],
"type": "mse_"
}
],
"raises": [],
"params": [
{
... |
2c1f352d97f0ef5fb2efbc82bf8f3b59b50990ac | MiirHo3eIN/Real_Time_BHM | common/processing.py | [
"MIT"
] | Python | predict_dwt_ | <not_specific> | def predict_dwt_(self, dataset, Vx):
"""
Compute Mean Square Error in Discerete Wavelet domain
:param dataset:dataset: 1D Acceleration
:param Vx: Eigen Values of trained pca
:return mse_: Single MSE for a period of DWT transform values
"""
coef_Apx, coef_delta = pywt.dwt(dataset, wavelet = 'db10',... |
Compute Mean Square Error in Discerete Wavelet domain
:param dataset:dataset: 1D Acceleration
:param Vx: Eigen Values of trained pca
:return mse_: Single MSE for a period of DWT transform values
| Compute Mean Square Error in Discerete Wavelet domain | [
"Compute",
"Mean",
"Square",
"Error",
"in",
"Discerete",
"Wavelet",
"domain"
] | def predict_dwt_(self, dataset, Vx):
coef_Apx, coef_delta = pywt.dwt(dataset, wavelet = 'db10', mode='symmetric', axis= 0)
x_recons = self.pca_reconst(data = coef_Apx, eigenvector = Vx)
mse_ = mse(coef_Apx, x_recons)
return mse_ | [
"def",
"predict_dwt_",
"(",
"self",
",",
"dataset",
",",
"Vx",
")",
":",
"coef_Apx",
",",
"coef_delta",
"=",
"pywt",
".",
"dwt",
"(",
"dataset",
",",
"wavelet",
"=",
"'db10'",
",",
"mode",
"=",
"'symmetric'",
",",
"axis",
"=",
"0",
")",
"x_recons",
"... | Compute Mean Square Error in Discerete Wavelet domain | [
"Compute",
"Mean",
"Square",
"Error",
"in",
"Discerete",
"Wavelet",
"domain"
] | [
"\"\"\"\n\t\tCompute Mean Square Error in Discerete Wavelet domain\n\n\t\t:param dataset:dataset: 1D Acceleration \n\t\t:param Vx: \t\tEigen Values of trained pca \n\t\t:return mse_:\tSingle MSE for a period of DWT transform values \n\t\t\"\"\""
] | [
{
"param": "self",
"type": null
},
{
"param": "dataset",
"type": null
},
{
"param": "Vx",
"type": null
}
] | {
"returns": [
{
"docstring": "Single MSE for a period of DWT transform values",
"docstring_tokens": [
"Single",
"MSE",
"for",
"a",
"period",
"of",
"DWT",
"transform",
"values"
],
"type": "mse_"
}
],
"raises": ... |
2c1f352d97f0ef5fb2efbc82bf8f3b59b50990ac | MiirHo3eIN/Real_Time_BHM | common/processing.py | [
"MIT"
] | Python | predict_freq_ | <not_specific> | def predict_freq_(self, dataset, Vx, axis_):
"""
Compute Mean Square Error in Frequency domain
:param dataset:dataset: 1D Acceleration
:param Vx: Eigen Values of trained pca
:return mse_: Single MSE for a period of DWT transform values
"""
fft_amp = fft_transform_(dataset, axis_ = axis_)
x_reco... |
Compute Mean Square Error in Frequency domain
:param dataset:dataset: 1D Acceleration
:param Vx: Eigen Values of trained pca
:return mse_: Single MSE for a period of DWT transform values
| Compute Mean Square Error in Frequency domain | [
"Compute",
"Mean",
"Square",
"Error",
"in",
"Frequency",
"domain"
] | def predict_freq_(self, dataset, Vx, axis_):
fft_amp = fft_transform_(dataset, axis_ = axis_)
x_recons = self.pca_reconst(data = fft_amp, eigenvector = Vx)
mse_ = mse(fft_amp, x_recons)
return mse_ | [
"def",
"predict_freq_",
"(",
"self",
",",
"dataset",
",",
"Vx",
",",
"axis_",
")",
":",
"fft_amp",
"=",
"fft_transform_",
"(",
"dataset",
",",
"axis_",
"=",
"axis_",
")",
"x_recons",
"=",
"self",
".",
"pca_reconst",
"(",
"data",
"=",
"fft_amp",
",",
"e... | Compute Mean Square Error in Frequency domain | [
"Compute",
"Mean",
"Square",
"Error",
"in",
"Frequency",
"domain"
] | [
"\"\"\"\n\t\tCompute Mean Square Error in Frequency domain\n\n\t\t:param dataset:dataset: 1D Acceleration \n\t\t:param Vx: \t\tEigen Values of trained pca \n\t\t:return mse_:\tSingle MSE for a period of DWT transform values \n\t\t\"\"\""
] | [
{
"param": "self",
"type": null
},
{
"param": "dataset",
"type": null
},
{
"param": "Vx",
"type": null
},
{
"param": "axis_",
"type": null
}
] | {
"returns": [
{
"docstring": "Single MSE for a period of DWT transform values",
"docstring_tokens": [
"Single",
"MSE",
"for",
"a",
"period",
"of",
"DWT",
"transform",
"values"
],
"type": "mse_"
}
],
"raises": ... |
2c1f352d97f0ef5fb2efbc82bf8f3b59b50990ac | MiirHo3eIN/Real_Time_BHM | common/processing.py | [
"MIT"
] | Python | predict | <not_specific> | def predict(self, ds, Vx, dt_start, dt_end):
"""
Returns MSE values of interval of 15 minutes
:param ds: dataset of 5 days for testing
:param Vx: Trained Eigen Vectors
:param ds_start: Start date in dataset
:param ds_end: Finish date in dateset
:return output: Dictionary with 2 <value/pair> of ... |
Returns MSE values of interval of 15 minutes
:param ds: dataset of 5 days for testing
:param Vx: Trained Eigen Vectors
:param ds_start: Start date in dataset
:param ds_end: Finish date in dateset
:return output: Dictionary with 2 <value/pair> of MSE/starting date of the interval
| Returns MSE values of interval of 15 minutes | [
"Returns",
"MSE",
"values",
"of",
"interval",
"of",
"15",
"minutes"
] | def predict(self, ds, Vx, dt_start, dt_end):
output = {}
conv = (1*2.5)*2**-15
for d_inx in tqdm([date for date in time_slot_gen(dt_start,dt_end, 4)]):
init = ds['ts']/1000 > d_inx
last = ds['ts']/1000 < d_inx + (60*15)
section = ds['z'][init & last]
if section.shape[0]>0:
filtered_data = energ... | [
"def",
"predict",
"(",
"self",
",",
"ds",
",",
"Vx",
",",
"dt_start",
",",
"dt_end",
")",
":",
"output",
"=",
"{",
"}",
"conv",
"=",
"(",
"1",
"*",
"2.5",
")",
"*",
"2",
"**",
"-",
"15",
"for",
"d_inx",
"in",
"tqdm",
"(",
"[",
"date",
"for",
... | Returns MSE values of interval of 15 minutes | [
"Returns",
"MSE",
"values",
"of",
"interval",
"of",
"15",
"minutes"
] | [
"\"\"\"\n\t\tReturns MSE values of interval of 15 minutes \n\n\t\t:param ds:\t\t\tdataset of 5 days for testing \n\t\t:param Vx:\t\t\tTrained Eigen Vectors \n\t\t:param ds_start:\tStart date in dataset\n\t\t:param ds_end: \t\tFinish date in dateset\n\t\t:return output:\t\tDictionary with 2 <value/pair> of MSE/start... | [
{
"param": "self",
"type": null
},
{
"param": "ds",
"type": null
},
{
"param": "Vx",
"type": null
},
{
"param": "dt_start",
"type": null
},
{
"param": "dt_end",
"type": null
}
] | {
"returns": [
{
"docstring": "Dictionary with 2 of MSE/starting date of the interval",
"docstring_tokens": [
"Dictionary",
"with",
"2",
"of",
"MSE",
"/",
"starting",
"date",
"of",
"the",
"interval"
],
... |
059810c3daf85c4d82660c8b92a994e845183ae8 | sed-i/python-libjuju | juju/client/_client4.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... |
059810c3daf85c4d82660c8b92a994e845183ae8 | sed-i/python-libjuju | juju/client/_client4.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... |
059810c3daf85c4d82660c8b92a994e845183ae8 | sed-i/python-libjuju | juju/client/_client4.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... |
059810c3daf85c4d82660c8b92a994e845183ae8 | sed-i/python-libjuju | juju/client/_client4.py | [
"Apache-2.0"
] | Python | ExportBundle | <not_specific> | async def ExportBundle(self):
'''
ExportBundle exports the current model configuration as bundle.
Returns -> StringResult
'''
# map input types to rpc msg
_params = dict()
msg = dict(type='Bundle',
request='ExportBundle',
v... |
ExportBundle exports the current model configuration as bundle.
Returns -> StringResult
| ExportBundle exports the current model configuration as bundle. | [
"ExportBundle",
"exports",
"the",
"current",
"model",
"configuration",
"as",
"bundle",
"."
] | async def ExportBundle(self):
_params = dict()
msg = dict(type='Bundle',
request='ExportBundle',
version=4,
params=_params)
reply = await self.rpc(msg)
return reply | [
"async",
"def",
"ExportBundle",
"(",
"self",
")",
":",
"_params",
"=",
"dict",
"(",
")",
"msg",
"=",
"dict",
"(",
"type",
"=",
"'Bundle'",
",",
"request",
"=",
"'ExportBundle'",
",",
"version",
"=",
"4",
",",
"params",
"=",
"_params",
")",
"reply",
"... | ExportBundle exports the current model configuration as bundle. | [
"ExportBundle",
"exports",
"the",
"current",
"model",
"configuration",
"as",
"bundle",
"."
] | [
"'''\n ExportBundle exports the current model configuration as bundle.\n\n\n Returns -> StringResult\n '''",
"# map input types to rpc msg"
] | [
{
"param": "self",
"type": null
}
] | {
"returns": [],
"raises": [],
"params": [
{
"identifier": "self",
"type": null,
"docstring": null,
"docstring_tokens": [],
"default": null,
"is_optional": null
}
],
"outlier_params": [],
"others": []
} |
059810c3daf85c4d82660c8b92a994e845183ae8 | sed-i/python-libjuju | juju/client/_client4.py | [
"Apache-2.0"
] | Python | GetChanges | <not_specific> | async def GetChanges(self, bundleurl=None, yaml=None):
'''
GetChanges returns the list of changes required to deploy the given bundle
data. The changes are sorted by requirements, so that they can be applied in
order.
GetChanges has been superseded in favour of GetChangesMapArgs.... |
GetChanges returns the list of changes required to deploy the given bundle
data. The changes are sorted by requirements, so that they can be applied in
order.
GetChanges has been superseded in favour of GetChangesMapArgs. It's
preferable to use that new method to add new functio... | GetChanges returns the list of changes required to deploy the given bundle
data. The changes are sorted by requirements, so that they can be applied in
order.
GetChanges has been superseded in favour of GetChangesMapArgs. It's
preferable to use that new method to add new functionality and move clients
away from this on... | [
"GetChanges",
"returns",
"the",
"list",
"of",
"changes",
"required",
"to",
"deploy",
"the",
"given",
"bundle",
"data",
".",
"The",
"changes",
"are",
"sorted",
"by",
"requirements",
"so",
"that",
"they",
"can",
"be",
"applied",
"in",
"order",
".",
"GetChanges... | async def GetChanges(self, bundleurl=None, yaml=None):
if bundleurl is not None and not isinstance(bundleurl, (bytes, str)):
raise Exception("Expected bundleurl to be a str, received: {}".format(type(bundleurl)))
if yaml is not None and not isinstance(yaml, (bytes, str)):
raise E... | [
"async",
"def",
"GetChanges",
"(",
"self",
",",
"bundleurl",
"=",
"None",
",",
"yaml",
"=",
"None",
")",
":",
"if",
"bundleurl",
"is",
"not",
"None",
"and",
"not",
"isinstance",
"(",
"bundleurl",
",",
"(",
"bytes",
",",
"str",
")",
")",
":",
"raise",... | GetChanges returns the list of changes required to deploy the given bundle
data. | [
"GetChanges",
"returns",
"the",
"list",
"of",
"changes",
"required",
"to",
"deploy",
"the",
"given",
"bundle",
"data",
"."
] | [
"'''\n GetChanges returns the list of changes required to deploy the given bundle\n data. The changes are sorted by requirements, so that they can be applied in\n order.\n GetChanges has been superseded in favour of GetChangesMapArgs. It's\n preferable to use that new method to ad... | [
{
"param": "self",
"type": null
},
{
"param": "bundleurl",
"type": null
},
{
"param": "yaml",
"type": null
}
] | {
"returns": [],
"raises": [],
"params": [
{
"identifier": "self",
"type": null,
"docstring": null,
"docstring_tokens": [],
"default": null,
"is_optional": null
},
{
"identifier": "bundleurl",
"type": null,
"docstring": null,
"docstring_token... |
059810c3daf85c4d82660c8b92a994e845183ae8 | sed-i/python-libjuju | juju/client/_client4.py | [
"Apache-2.0"
] | Python | GetChangesMapArgs | <not_specific> | async def GetChangesMapArgs(self, bundleurl=None, yaml=None):
'''
GetChangesMapArgs returns the list of changes required to deploy the given
bundle data. The changes are sorted by requirements, so that they can be
applied in order.
V4 GetChangesMapArgs is not supported on anythin... |
GetChangesMapArgs returns the list of changes required to deploy the given
bundle data. The changes are sorted by requirements, so that they can be
applied in order.
V4 GetChangesMapArgs is not supported on anything less than v4
bundleurl : str
yaml : str
Return... | GetChangesMapArgs returns the list of changes required to deploy the given
bundle data. The changes are sorted by requirements, so that they can be
applied in order.
V4 GetChangesMapArgs is not supported on anything less than v4
bundleurl : str
yaml : str
Returns -> BundleChangesMapArgsResults | [
"GetChangesMapArgs",
"returns",
"the",
"list",
"of",
"changes",
"required",
"to",
"deploy",
"the",
"given",
"bundle",
"data",
".",
"The",
"changes",
"are",
"sorted",
"by",
"requirements",
"so",
"that",
"they",
"can",
"be",
"applied",
"in",
"order",
".",
"V4"... | async def GetChangesMapArgs(self, bundleurl=None, yaml=None):
if bundleurl is not None and not isinstance(bundleurl, (bytes, str)):
raise Exception("Expected bundleurl to be a str, received: {}".format(type(bundleurl)))
if yaml is not None and not isinstance(yaml, (bytes, str)):
... | [
"async",
"def",
"GetChangesMapArgs",
"(",
"self",
",",
"bundleurl",
"=",
"None",
",",
"yaml",
"=",
"None",
")",
":",
"if",
"bundleurl",
"is",
"not",
"None",
"and",
"not",
"isinstance",
"(",
"bundleurl",
",",
"(",
"bytes",
",",
"str",
")",
")",
":",
"... | GetChangesMapArgs returns the list of changes required to deploy the given
bundle data. | [
"GetChangesMapArgs",
"returns",
"the",
"list",
"of",
"changes",
"required",
"to",
"deploy",
"the",
"given",
"bundle",
"data",
"."
] | [
"'''\n GetChangesMapArgs returns the list of changes required to deploy the given\n bundle data. The changes are sorted by requirements, so that they can be\n applied in order.\n V4 GetChangesMapArgs is not supported on anything less than v4\n\n bundleurl : str\n yaml : str... | [
{
"param": "self",
"type": null
},
{
"param": "bundleurl",
"type": null
},
{
"param": "yaml",
"type": null
}
] | {
"returns": [],
"raises": [],
"params": [
{
"identifier": "self",
"type": null,
"docstring": null,
"docstring_tokens": [],
"default": null,
"is_optional": null
},
{
"identifier": "bundleurl",
"type": null,
"docstring": null,
"docstring_token... |
059810c3daf85c4d82660c8b92a994e845183ae8 | sed-i/python-libjuju | juju/client/_client4.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... |
059810c3daf85c4d82660c8b92a994e845183ae8 | sed-i/python-libjuju | juju/client/_client4.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... |
059810c3daf85c4d82660c8b92a994e845183ae8 | sed-i/python-libjuju | juju/client/_client4.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=4,
... | [
"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": []... |
059810c3daf85c4d82660c8b92a994e845183ae8 | sed-i/python-libjuju | juju/client/_client4.py | [
"Apache-2.0"
] | Python | CheckCharmPlacement | <not_specific> | async def CheckCharmPlacement(self, placements=None):
'''
CheckCharmPlacement checks if a charm is allowed to be placed with in a
given application.
placements : typing.Sequence[~ApplicationCharmPlacement]
Returns -> ErrorResults
'''
if placements is not None and... |
CheckCharmPlacement checks if a charm is allowed to be placed with in a
given application.
placements : typing.Sequence[~ApplicationCharmPlacement]
Returns -> ErrorResults
| CheckCharmPlacement checks if a charm is allowed to be placed with in a
given application.
| [
"CheckCharmPlacement",
"checks",
"if",
"a",
"charm",
"is",
"allowed",
"to",
"be",
"placed",
"with",
"in",
"a",
"given",
"application",
"."
] | async def CheckCharmPlacement(self, placements=None):
if placements is not None and not isinstance(placements, (bytes, str, list)):
raise Exception("Expected placements to be a Sequence, received: {}".format(type(placements)))
_params = dict()
msg = dict(type='Charms',
... | [
"async",
"def",
"CheckCharmPlacement",
"(",
"self",
",",
"placements",
"=",
"None",
")",
":",
"if",
"placements",
"is",
"not",
"None",
"and",
"not",
"isinstance",
"(",
"placements",
",",
"(",
"bytes",
",",
"str",
",",
"list",
")",
")",
":",
"raise",
"E... | CheckCharmPlacement checks if a charm is allowed to be placed with in a
given application. | [
"CheckCharmPlacement",
"checks",
"if",
"a",
"charm",
"is",
"allowed",
"to",
"be",
"placed",
"with",
"in",
"a",
"given",
"application",
"."
] | [
"'''\n CheckCharmPlacement checks if a charm is allowed to be placed with in a\n given application.\n\n placements : typing.Sequence[~ApplicationCharmPlacement]\n Returns -> ErrorResults\n '''",
"# map input types to rpc msg"
] | [
{
"param": "self",
"type": null
},
{
"param": "placements",
"type": null
}
] | {
"returns": [],
"raises": [],
"params": [
{
"identifier": "self",
"type": null,
"docstring": null,
"docstring_tokens": [],
"default": null,
"is_optional": null
},
{
"identifier": "placements",
"type": null,
"docstring": null,
"docstring_toke... |
059810c3daf85c4d82660c8b92a994e845183ae8 | sed-i/python-libjuju | juju/client/_client4.py | [
"Apache-2.0"
] | Python | GetDownloadInfos | <not_specific> | async def GetDownloadInfos(self, entities=None):
'''
GetDownloadInfos attempts to get the bundle corresponding to the charm url
and origin.
entities : typing.Sequence[~CharmURLAndOrigin]
Returns -> DownloadInfoResults
'''
if entities is not None and not isinstanc... |
GetDownloadInfos attempts to get the bundle corresponding to the charm url
and origin.
entities : typing.Sequence[~CharmURLAndOrigin]
Returns -> DownloadInfoResults
| GetDownloadInfos attempts to get the bundle corresponding to the charm url
and origin.
| [
"GetDownloadInfos",
"attempts",
"to",
"get",
"the",
"bundle",
"corresponding",
"to",
"the",
"charm",
"url",
"and",
"origin",
"."
] | async def GetDownloadInfos(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='Charms',
request=... | [
"async",
"def",
"GetDownloadInfos",
"(",
"self",
",",
"entities",
"=",
"None",
")",
":",
"if",
"entities",
"is",
"not",
"None",
"and",
"not",
"isinstance",
"(",
"entities",
",",
"(",
"bytes",
",",
"str",
",",
"list",
")",
")",
":",
"raise",
"Exception"... | GetDownloadInfos attempts to get the bundle corresponding to the charm url
and origin. | [
"GetDownloadInfos",
"attempts",
"to",
"get",
"the",
"bundle",
"corresponding",
"to",
"the",
"charm",
"url",
"and",
"origin",
"."
] | [
"'''\n GetDownloadInfos attempts to get the bundle corresponding to the charm url\n and origin.\n\n entities : typing.Sequence[~CharmURLAndOrigin]\n Returns -> DownloadInfoResults\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... |
059810c3daf85c4d82660c8b92a994e845183ae8 | sed-i/python-libjuju | juju/client/_client4.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=4,
... | [
"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": []... |
059810c3daf85c4d82660c8b92a994e845183ae8 | sed-i/python-libjuju | juju/client/_client4.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": ... |
059810c3daf85c4d82660c8b92a994e845183ae8 | sed-i/python-libjuju | juju/client/_client4.py | [
"Apache-2.0"
] | Python | ListCharmResources | <not_specific> | async def ListCharmResources(self, entities=None):
'''
ListCharmResources returns a series of resources for a given charm.
entities : typing.Sequence[~CharmURLAndOrigin]
Returns -> CharmResourcesResults
'''
if entities is not None and not isinstance(entities, (bytes, str... |
ListCharmResources returns a series of resources for a given charm.
entities : typing.Sequence[~CharmURLAndOrigin]
Returns -> CharmResourcesResults
| ListCharmResources returns a series of resources for a given charm. | [
"ListCharmResources",
"returns",
"a",
"series",
"of",
"resources",
"for",
"a",
"given",
"charm",
"."
] | async def ListCharmResources(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='Charms',
reques... | [
"async",
"def",
"ListCharmResources",
"(",
"self",
",",
"entities",
"=",
"None",
")",
":",
"if",
"entities",
"is",
"not",
"None",
"and",
"not",
"isinstance",
"(",
"entities",
",",
"(",
"bytes",
",",
"str",
",",
"list",
")",
")",
":",
"raise",
"Exceptio... | ListCharmResources returns a series of resources for a given charm. | [
"ListCharmResources",
"returns",
"a",
"series",
"of",
"resources",
"for",
"a",
"given",
"charm",
"."
] | [
"'''\n ListCharmResources returns a series of resources for a given charm.\n\n entities : typing.Sequence[~CharmURLAndOrigin]\n Returns -> CharmResourcesResults\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... |
059810c3daf85c4d82660c8b92a994e845183ae8 | sed-i/python-libjuju | juju/client/_client4.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... |
059810c3daf85c4d82660c8b92a994e845183ae8 | sed-i/python-libjuju | juju/client/_client4.py | [
"Apache-2.0"
] | Python | AreManuallyProvisioned | <not_specific> | async def AreManuallyProvisioned(self, entities=None):
'''
AreManuallyProvisioned returns whether each given entity is
manually provisioned or not. Only machine tags are accepted.
entities : typing.Sequence[~Entity]
Returns -> BoolResults
'''
if entities is not N... |
AreManuallyProvisioned returns whether each given entity is
manually provisioned or not. Only machine tags are accepted.
entities : typing.Sequence[~Entity]
Returns -> BoolResults
| AreManuallyProvisioned returns whether each given entity is
manually provisioned or not. Only machine tags are accepted.
entities : typing.Sequence[~Entity]
Returns -> BoolResults | [
"AreManuallyProvisioned",
"returns",
"whether",
"each",
"given",
"entity",
"is",
"manually",
"provisioned",
"or",
"not",
".",
"Only",
"machine",
"tags",
"are",
"accepted",
".",
"entities",
":",
"typing",
".",
"Sequence",
"[",
"~Entity",
"]",
"Returns",
"-",
">... | async def AreManuallyProvisioned(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='InstancePoller',
... | [
"async",
"def",
"AreManuallyProvisioned",
"(",
"self",
",",
"entities",
"=",
"None",
")",
":",
"if",
"entities",
"is",
"not",
"None",
"and",
"not",
"isinstance",
"(",
"entities",
",",
"(",
"bytes",
",",
"str",
",",
"list",
")",
")",
":",
"raise",
"Exce... | AreManuallyProvisioned returns whether each given entity is
manually provisioned or not. | [
"AreManuallyProvisioned",
"returns",
"whether",
"each",
"given",
"entity",
"is",
"manually",
"provisioned",
"or",
"not",
"."
] | [
"'''\n AreManuallyProvisioned returns whether each given entity is\n manually provisioned or not. Only machine tags are accepted.\n\n entities : typing.Sequence[~Entity]\n Returns -> BoolResults\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... |
059810c3daf85c4d82660c8b92a994e845183ae8 | sed-i/python-libjuju | juju/client/_client4.py | [
"Apache-2.0"
] | Python | InstanceId | <not_specific> | async def InstanceId(self, entities=None):
'''
InstanceId returns the provider specific instance id for each given
machine or an CodeNotProvisioned error, if not set.
entities : typing.Sequence[~Entity]
Returns -> StringResults
'''
if entities is not None and not... |
InstanceId returns the provider specific instance id for each given
machine or an CodeNotProvisioned error, if not set.
entities : typing.Sequence[~Entity]
Returns -> StringResults
| InstanceId returns the provider specific instance id for each given
machine or an CodeNotProvisioned error, if not set.
entities : typing.Sequence[~Entity]
Returns -> StringResults | [
"InstanceId",
"returns",
"the",
"provider",
"specific",
"instance",
"id",
"for",
"each",
"given",
"machine",
"or",
"an",
"CodeNotProvisioned",
"error",
"if",
"not",
"set",
".",
"entities",
":",
"typing",
".",
"Sequence",
"[",
"~Entity",
"]",
"Returns",
"-",
... | async def InstanceId(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='InstancePoller',
reques... | [
"async",
"def",
"InstanceId",
"(",
"self",
",",
"entities",
"=",
"None",
")",
":",
"if",
"entities",
"is",
"not",
"None",
"and",
"not",
"isinstance",
"(",
"entities",
",",
"(",
"bytes",
",",
"str",
",",
"list",
")",
")",
":",
"raise",
"Exception",
"(... | InstanceId returns the provider specific instance id for each given
machine or an CodeNotProvisioned error, if not set. | [
"InstanceId",
"returns",
"the",
"provider",
"specific",
"instance",
"id",
"for",
"each",
"given",
"machine",
"or",
"an",
"CodeNotProvisioned",
"error",
"if",
"not",
"set",
"."
] | [
"'''\n InstanceId returns the provider specific instance id for each given\n machine or an CodeNotProvisioned error, if not set.\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... |
059810c3daf85c4d82660c8b92a994e845183ae8 | sed-i/python-libjuju | juju/client/_client4.py | [
"Apache-2.0"
] | Python | InstanceStatus | <not_specific> | async def InstanceStatus(self, entities=None):
'''
InstanceStatus returns the instance status for each given entity.
Only machine tags are accepted.
entities : typing.Sequence[~Entity]
Returns -> StatusResults
'''
if entities is not None and not isinstance(entiti... |
InstanceStatus returns the instance status for each given entity.
Only machine tags are accepted.
entities : typing.Sequence[~Entity]
Returns -> StatusResults
| InstanceStatus returns the instance status for each given entity.
Only machine tags are accepted.
entities : typing.Sequence[~Entity]
Returns -> StatusResults | [
"InstanceStatus",
"returns",
"the",
"instance",
"status",
"for",
"each",
"given",
"entity",
".",
"Only",
"machine",
"tags",
"are",
"accepted",
".",
"entities",
":",
"typing",
".",
"Sequence",
"[",
"~Entity",
"]",
"Returns",
"-",
">",
"StatusResults"
] | async def InstanceStatus(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='InstancePoller',
re... | [
"async",
"def",
"InstanceStatus",
"(",
"self",
",",
"entities",
"=",
"None",
")",
":",
"if",
"entities",
"is",
"not",
"None",
"and",
"not",
"isinstance",
"(",
"entities",
",",
"(",
"bytes",
",",
"str",
",",
"list",
")",
")",
":",
"raise",
"Exception",
... | InstanceStatus returns the instance status for each given entity. | [
"InstanceStatus",
"returns",
"the",
"instance",
"status",
"for",
"each",
"given",
"entity",
"."
] | [
"'''\n InstanceStatus returns the instance status for each given entity.\n Only machine tags are accepted.\n\n entities : typing.Sequence[~Entity]\n Returns -> StatusResults\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... |
059810c3daf85c4d82660c8b92a994e845183ae8 | sed-i/python-libjuju | juju/client/_client4.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='InstancePoller',
request='Lif... | [
"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... |
059810c3daf85c4d82660c8b92a994e845183ae8 | sed-i/python-libjuju | juju/client/_client4.py | [
"Apache-2.0"
] | Python | ModelConfig | <not_specific> | async def ModelConfig(self):
'''
ModelConfig returns the current model's configuration.
Returns -> ModelConfigResult
'''
# map input types to rpc msg
_params = dict()
msg = dict(type='InstancePoller',
request='ModelConfig',
... |
ModelConfig returns the current model's configuration.
Returns -> ModelConfigResult
| ModelConfig returns the current model's configuration. | [
"ModelConfig",
"returns",
"the",
"current",
"model",
"'",
"s",
"configuration",
"."
] | async def ModelConfig(self):
_params = dict()
msg = dict(type='InstancePoller',
request='ModelConfig',
version=4,
params=_params)
reply = await self.rpc(msg)
return reply | [
"async",
"def",
"ModelConfig",
"(",
"self",
")",
":",
"_params",
"=",
"dict",
"(",
")",
"msg",
"=",
"dict",
"(",
"type",
"=",
"'InstancePoller'",
",",
"request",
"=",
"'ModelConfig'",
",",
"version",
"=",
"4",
",",
"params",
"=",
"_params",
")",
"reply... | ModelConfig returns the current model's configuration. | [
"ModelConfig",
"returns",
"the",
"current",
"model",
"'",
"s",
"configuration",
"."
] | [
"'''\n ModelConfig returns the current 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": []
} |
059810c3daf85c4d82660c8b92a994e845183ae8 | sed-i/python-libjuju | juju/client/_client4.py | [
"Apache-2.0"
] | Python | ProviderAddresses | <not_specific> | async def ProviderAddresses(self, entities=None):
'''
ProviderAddresses returns the list of all known provider addresses
for each given entity. Only machine tags are accepted.
entities : typing.Sequence[~Entity]
Returns -> MachineAddressesResults
'''
if entities ... |
ProviderAddresses returns the list of all known provider addresses
for each given entity. Only machine tags are accepted.
entities : typing.Sequence[~Entity]
Returns -> MachineAddressesResults
| ProviderAddresses returns the list of all known provider addresses
for each given entity. Only machine tags are accepted.
entities : typing.Sequence[~Entity]
Returns -> MachineAddressesResults | [
"ProviderAddresses",
"returns",
"the",
"list",
"of",
"all",
"known",
"provider",
"addresses",
"for",
"each",
"given",
"entity",
".",
"Only",
"machine",
"tags",
"are",
"accepted",
".",
"entities",
":",
"typing",
".",
"Sequence",
"[",
"~Entity",
"]",
"Returns",
... | async def ProviderAddresses(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='InstancePoller',
... | [
"async",
"def",
"ProviderAddresses",
"(",
"self",
",",
"entities",
"=",
"None",
")",
":",
"if",
"entities",
"is",
"not",
"None",
"and",
"not",
"isinstance",
"(",
"entities",
",",
"(",
"bytes",
",",
"str",
",",
"list",
")",
")",
":",
"raise",
"Exception... | ProviderAddresses returns the list of all known provider addresses
for each given entity. | [
"ProviderAddresses",
"returns",
"the",
"list",
"of",
"all",
"known",
"provider",
"addresses",
"for",
"each",
"given",
"entity",
"."
] | [
"'''\n ProviderAddresses returns the list of all known provider addresses\n for each given entity. Only machine tags are accepted.\n\n entities : typing.Sequence[~Entity]\n Returns -> MachineAddressesResults\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... |
059810c3daf85c4d82660c8b92a994e845183ae8 | sed-i/python-libjuju | juju/client/_client4.py | [
"Apache-2.0"
] | Python | SetInstanceStatus | <not_specific> | async def SetInstanceStatus(self, entities=None):
'''
SetInstanceStatus updates the instance status for each given entity.
Only machine tags are accepted.
entities : typing.Sequence[~EntityStatusArgs]
Returns -> ErrorResults
'''
if entities is not None and not is... |
SetInstanceStatus updates the instance status for each given entity.
Only machine tags are accepted.
entities : typing.Sequence[~EntityStatusArgs]
Returns -> ErrorResults
| SetInstanceStatus updates the instance status for each given entity.
Only machine tags are accepted.
| [
"SetInstanceStatus",
"updates",
"the",
"instance",
"status",
"for",
"each",
"given",
"entity",
".",
"Only",
"machine",
"tags",
"are",
"accepted",
"."
] | async def SetInstanceStatus(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='InstancePoller',
... | [
"async",
"def",
"SetInstanceStatus",
"(",
"self",
",",
"entities",
"=",
"None",
")",
":",
"if",
"entities",
"is",
"not",
"None",
"and",
"not",
"isinstance",
"(",
"entities",
",",
"(",
"bytes",
",",
"str",
",",
"list",
")",
")",
":",
"raise",
"Exception... | SetInstanceStatus updates the instance status for each given entity. | [
"SetInstanceStatus",
"updates",
"the",
"instance",
"status",
"for",
"each",
"given",
"entity",
"."
] | [
"'''\n SetInstanceStatus updates the instance status for each given entity.\n Only machine tags are accepted.\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... |
059810c3daf85c4d82660c8b92a994e845183ae8 | sed-i/python-libjuju | juju/client/_client4.py | [
"Apache-2.0"
] | Python | SetProviderAddresses | <not_specific> | async def SetProviderAddresses(self, machine_addresses=None):
'''
SetProviderAddresses updates the list of known provider addresses
for each given entity. Only machine tags are accepted.
machine_addresses : typing.Sequence[~MachineAddresses]
Returns -> ErrorResults
'''
... |
SetProviderAddresses updates the list of known provider addresses
for each given entity. Only machine tags are accepted.
machine_addresses : typing.Sequence[~MachineAddresses]
Returns -> ErrorResults
| SetProviderAddresses updates the list of known provider addresses
for each given entity. Only machine tags are accepted.
| [
"SetProviderAddresses",
"updates",
"the",
"list",
"of",
"known",
"provider",
"addresses",
"for",
"each",
"given",
"entity",
".",
"Only",
"machine",
"tags",
"are",
"accepted",
"."
] | async def SetProviderAddresses(self, machine_addresses=None):
if machine_addresses is not None and not isinstance(machine_addresses, (bytes, str, list)):
raise Exception("Expected machine_addresses to be a Sequence, received: {}".format(type(machine_addresses)))
_params = dict()
msg ... | [
"async",
"def",
"SetProviderAddresses",
"(",
"self",
",",
"machine_addresses",
"=",
"None",
")",
":",
"if",
"machine_addresses",
"is",
"not",
"None",
"and",
"not",
"isinstance",
"(",
"machine_addresses",
",",
"(",
"bytes",
",",
"str",
",",
"list",
")",
")",
... | SetProviderAddresses updates the list of known provider addresses
for each given entity. | [
"SetProviderAddresses",
"updates",
"the",
"list",
"of",
"known",
"provider",
"addresses",
"for",
"each",
"given",
"entity",
"."
] | [
"'''\n SetProviderAddresses updates the list of known provider addresses\n for each given entity. Only machine tags are accepted.\n\n machine_addresses : typing.Sequence[~MachineAddresses]\n Returns -> ErrorResults\n '''",
"# map input types to rpc msg"
] | [
{
"param": "self",
"type": null
},
{
"param": "machine_addresses",
"type": null
}
] | {
"returns": [],
"raises": [],
"params": [
{
"identifier": "self",
"type": null,
"docstring": null,
"docstring_tokens": [],
"default": null,
"is_optional": null
},
{
"identifier": "machine_addresses",
"type": null,
"docstring": null,
"docstri... |
059810c3daf85c4d82660c8b92a994e845183ae8 | sed-i/python-libjuju | juju/client/_client4.py | [
"Apache-2.0"
] | Python | SetProviderNetworkConfig | <not_specific> | async def SetProviderNetworkConfig(self, args=None):
'''
SetProviderNetworkConfig updates the provider addresses for one or more
machines.
What's more, if the client request includes provider-specific IDs (e.g.
network, subnet or address IDs), this method will also iterate any p... |
SetProviderNetworkConfig updates the provider addresses for one or more
machines.
What's more, if the client request includes provider-specific IDs (e.g.
network, subnet or address IDs), this method will also iterate any present
link layer devices (and their addresses) and merg... | SetProviderNetworkConfig updates the provider addresses for one or more
machines.
| [
"SetProviderNetworkConfig",
"updates",
"the",
"provider",
"addresses",
"for",
"one",
"or",
"more",
"machines",
"."
] | async def SetProviderNetworkConfig(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='InstancePoller',
request='Set... | [
"async",
"def",
"SetProviderNetworkConfig",
"(",
"self",
",",
"args",
"=",
"None",
")",
":",
"if",
"args",
"is",
"not",
"None",
"and",
"not",
"isinstance",
"(",
"args",
",",
"(",
"bytes",
",",
"str",
",",
"list",
")",
")",
":",
"raise",
"Exception",
... | SetProviderNetworkConfig updates the provider addresses for one or more
machines. | [
"SetProviderNetworkConfig",
"updates",
"the",
"provider",
"addresses",
"for",
"one",
"or",
"more",
"machines",
"."
] | [
"'''\n SetProviderNetworkConfig updates the provider addresses for one or more\n machines.\n\n What's more, if the client request includes provider-specific IDs (e.g.\n network, subnet or address IDs), this method will also iterate any present\n link layer devices (and their addre... | [
{
"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": [... |
059810c3daf85c4d82660c8b92a994e845183ae8 | sed-i/python-libjuju | juju/client/_client4.py | [
"Apache-2.0"
] | Python | WatchForModelConfigChanges | <not_specific> | async def WatchForModelConfigChanges(self):
'''
WatchForModelConfigChanges returns a NotifyWatcher that observes
changes to the model configuration.
Note that although the NotifyWatchResult contains an Error field,
it's not used because we are only returning a single watcher,
... |
WatchForModelConfigChanges returns a NotifyWatcher that observes
changes to the model configuration.
Note that although the NotifyWatchResult contains an Error field,
it's not used because we are only returning a single watcher,
so we use the regular error return.
Retu... | WatchForModelConfigChanges returns a NotifyWatcher that observes
changes to the model configuration.
Note that although the NotifyWatchResult contains an Error field,
it's not used because we are only returning a single watcher,
so we use the regular error return.
| [
"WatchForModelConfigChanges",
"returns",
"a",
"NotifyWatcher",
"that",
"observes",
"changes",
"to",
"the",
"model",
"configuration",
".",
"Note",
"that",
"although",
"the",
"NotifyWatchResult",
"contains",
"an",
"Error",
"field",
"it",
"'",
"s",
"not",
"used",
"be... | async def WatchForModelConfigChanges(self):
_params = dict()
msg = dict(type='InstancePoller',
request='WatchForModelConfigChanges',
version=4,
params=_params)
reply = await self.rpc(msg)
return reply | [
"async",
"def",
"WatchForModelConfigChanges",
"(",
"self",
")",
":",
"_params",
"=",
"dict",
"(",
")",
"msg",
"=",
"dict",
"(",
"type",
"=",
"'InstancePoller'",
",",
"request",
"=",
"'WatchForModelConfigChanges'",
",",
"version",
"=",
"4",
",",
"params",
"="... | WatchForModelConfigChanges returns a NotifyWatcher that observes
changes to the model configuration. | [
"WatchForModelConfigChanges",
"returns",
"a",
"NotifyWatcher",
"that",
"observes",
"changes",
"to",
"the",
"model",
"configuration",
"."
] | [
"'''\n WatchForModelConfigChanges returns a NotifyWatcher that observes\n changes to the model configuration.\n Note that although the NotifyWatchResult contains an Error field,\n it's not used because we are only returning a single watcher,\n so we use the regular error return.\n... | [
{
"param": "self",
"type": null
}
] | {
"returns": [],
"raises": [],
"params": [
{
"identifier": "self",
"type": null,
"docstring": null,
"docstring_tokens": [],
"default": null,
"is_optional": null
}
],
"outlier_params": [],
"others": []
} |
059810c3daf85c4d82660c8b92a994e845183ae8 | sed-i/python-libjuju | juju/client/_client4.py | [
"Apache-2.0"
] | Python | WatchModelMachineStartTimes | <not_specific> | async def WatchModelMachineStartTimes(self):
'''
WatchModelMachineStartTimes watches the non-container machines in the model
for changes to the Life or AgentStartTime fields and reports them as a batch.
Returns -> StringsWatchResult
'''
# map input types to rpc msg
... |
WatchModelMachineStartTimes watches the non-container machines in the model
for changes to the Life or AgentStartTime fields and reports them as a batch.
Returns -> StringsWatchResult
| WatchModelMachineStartTimes watches the non-container machines in the model
for changes to the Life or AgentStartTime fields and reports them as a batch.
| [
"WatchModelMachineStartTimes",
"watches",
"the",
"non",
"-",
"container",
"machines",
"in",
"the",
"model",
"for",
"changes",
"to",
"the",
"Life",
"or",
"AgentStartTime",
"fields",
"and",
"reports",
"them",
"as",
"a",
"batch",
"."
] | async def WatchModelMachineStartTimes(self):
_params = dict()
msg = dict(type='InstancePoller',
request='WatchModelMachineStartTimes',
version=4,
params=_params)
reply = await self.rpc(msg)
return reply | [
"async",
"def",
"WatchModelMachineStartTimes",
"(",
"self",
")",
":",
"_params",
"=",
"dict",
"(",
")",
"msg",
"=",
"dict",
"(",
"type",
"=",
"'InstancePoller'",
",",
"request",
"=",
"'WatchModelMachineStartTimes'",
",",
"version",
"=",
"4",
",",
"params",
"... | WatchModelMachineStartTimes watches the non-container machines in the model
for changes to the Life or AgentStartTime fields and reports them as a batch. | [
"WatchModelMachineStartTimes",
"watches",
"the",
"non",
"-",
"container",
"machines",
"in",
"the",
"model",
"for",
"changes",
"to",
"the",
"Life",
"or",
"AgentStartTime",
"fields",
"and",
"reports",
"them",
"as",
"a",
"batch",
"."
] | [
"'''\n WatchModelMachineStartTimes watches the non-container machines in the model\n for changes to the Life or AgentStartTime fields and reports them as a batch.\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": []
} |
059810c3daf85c4d82660c8b92a994e845183ae8 | sed-i/python-libjuju | juju/client/_client4.py | [
"Apache-2.0"
] | Python | WatchModelMachines | <not_specific> | async def WatchModelMachines(self):
'''
WatchModelMachines returns a StringsWatcher that notifies of
changes to the life cycles of the top level machines in the current
model.
Returns -> StringsWatchResult
'''
# map input types to rpc msg
_params = dict... |
WatchModelMachines returns a StringsWatcher that notifies of
changes to the life cycles of the top level machines in the current
model.
Returns -> StringsWatchResult
| WatchModelMachines returns a StringsWatcher that notifies of
changes to the life cycles of the top level machines in the current
model.
| [
"WatchModelMachines",
"returns",
"a",
"StringsWatcher",
"that",
"notifies",
"of",
"changes",
"to",
"the",
"life",
"cycles",
"of",
"the",
"top",
"level",
"machines",
"in",
"the",
"current",
"model",
"."
] | async def WatchModelMachines(self):
_params = dict()
msg = dict(type='InstancePoller',
request='WatchModelMachines',
version=4,
params=_params)
reply = await self.rpc(msg)
return reply | [
"async",
"def",
"WatchModelMachines",
"(",
"self",
")",
":",
"_params",
"=",
"dict",
"(",
")",
"msg",
"=",
"dict",
"(",
"type",
"=",
"'InstancePoller'",
",",
"request",
"=",
"'WatchModelMachines'",
",",
"version",
"=",
"4",
",",
"params",
"=",
"_params",
... | WatchModelMachines returns a StringsWatcher that notifies of
changes to the life cycles of the top level machines in the current
model. | [
"WatchModelMachines",
"returns",
"a",
"StringsWatcher",
"that",
"notifies",
"of",
"changes",
"to",
"the",
"life",
"cycles",
"of",
"the",
"top",
"level",
"machines",
"in",
"the",
"current",
"model",
"."
] | [
"'''\n WatchModelMachines returns a StringsWatcher that notifies of\n changes to the life cycles of the top level machines in the current\n model.\n\n\n Returns -> StringsWatchResult\n '''",
"# map input types to rpc msg"
] | [
{
"param": "self",
"type": null
}
] | {
"returns": [],
"raises": [],
"params": [
{
"identifier": "self",
"type": null,
"docstring": null,
"docstring_tokens": [],
"default": null,
"is_optional": null
}
],
"outlier_params": [],
"others": []
} |
059810c3daf85c4d82660c8b92a994e845183ae8 | sed-i/python-libjuju | juju/client/_client4.py | [
"Apache-2.0"
] | Python | APIAddresses | <not_specific> | async def APIAddresses(self):
'''
APIAddresses returns the list of addresses used to connect to the API.
Returns -> StringsResult
'''
# map input types to rpc msg
_params = dict()
msg = dict(type='Machiner',
request='APIAddresses',
... |
APIAddresses returns the list of addresses used to connect to the API.
Returns -> StringsResult
| APIAddresses returns the list of addresses used to connect to the API. | [
"APIAddresses",
"returns",
"the",
"list",
"of",
"addresses",
"used",
"to",
"connect",
"to",
"the",
"API",
"."
] | async def APIAddresses(self):
_params = dict()
msg = dict(type='Machiner',
request='APIAddresses',
version=4,
params=_params)
reply = await self.rpc(msg)
return reply | [
"async",
"def",
"APIAddresses",
"(",
"self",
")",
":",
"_params",
"=",
"dict",
"(",
")",
"msg",
"=",
"dict",
"(",
"type",
"=",
"'Machiner'",
",",
"request",
"=",
"'APIAddresses'",
",",
"version",
"=",
"4",
",",
"params",
"=",
"_params",
")",
"reply",
... | APIAddresses returns the list of addresses used to connect to the API. | [
"APIAddresses",
"returns",
"the",
"list",
"of",
"addresses",
"used",
"to",
"connect",
"to",
"the",
"API",
"."
] | [
"'''\n APIAddresses returns the list of addresses used to connect to the API.\n\n\n Returns -> StringsResult\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": []
} |
059810c3daf85c4d82660c8b92a994e845183ae8 | sed-i/python-libjuju | juju/client/_client4.py | [
"Apache-2.0"
] | Python | APIHostPorts | <not_specific> | async def APIHostPorts(self):
'''
APIHostPorts returns the API server addresses.
Returns -> APIHostPortsResult
'''
# map input types to rpc msg
_params = dict()
msg = dict(type='Machiner',
request='APIHostPorts',
version=4,... |
APIHostPorts returns the API server addresses.
Returns -> APIHostPortsResult
| APIHostPorts returns the API server addresses. | [
"APIHostPorts",
"returns",
"the",
"API",
"server",
"addresses",
"."
] | async def APIHostPorts(self):
_params = dict()
msg = dict(type='Machiner',
request='APIHostPorts',
version=4,
params=_params)
reply = await self.rpc(msg)
return reply | [
"async",
"def",
"APIHostPorts",
"(",
"self",
")",
":",
"_params",
"=",
"dict",
"(",
")",
"msg",
"=",
"dict",
"(",
"type",
"=",
"'Machiner'",
",",
"request",
"=",
"'APIHostPorts'",
",",
"version",
"=",
"4",
",",
"params",
"=",
"_params",
")",
"reply",
... | APIHostPorts returns the API server addresses. | [
"APIHostPorts",
"returns",
"the",
"API",
"server",
"addresses",
"."
] | [
"'''\n APIHostPorts returns the API server addresses.\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": []
} |
059810c3daf85c4d82660c8b92a994e845183ae8 | sed-i/python-libjuju | juju/client/_client4.py | [
"Apache-2.0"
] | Python | EnsureDead | <not_specific> | async def EnsureDead(self, entities=None):
'''
EnsureDead calls EnsureDead on each given entity from state. It
will fail if the entity is not present. If it's Alive, nothing will
happen (see state/EnsureDead() for units or machines).
entities : typing.Sequence[~Entity]
R... |
EnsureDead calls EnsureDead on each given entity from state. It
will fail if the entity is not present. If it's Alive, nothing will
happen (see state/EnsureDead() for units or machines).
entities : typing.Sequence[~Entity]
Returns -> ErrorResults
| EnsureDead calls EnsureDead on each given entity from state. It
will fail if the entity is not present. If it's Alive, nothing will
happen for units or machines).
entities : typing.Sequence[~Entity]
Returns -> ErrorResults | [
"EnsureDead",
"calls",
"EnsureDead",
"on",
"each",
"given",
"entity",
"from",
"state",
".",
"It",
"will",
"fail",
"if",
"the",
"entity",
"is",
"not",
"present",
".",
"If",
"it",
"'",
"s",
"Alive",
"nothing",
"will",
"happen",
"for",
"units",
"or",
"machi... | async def EnsureDead(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='Machiner',
request='Ens... | [
"async",
"def",
"EnsureDead",
"(",
"self",
",",
"entities",
"=",
"None",
")",
":",
"if",
"entities",
"is",
"not",
"None",
"and",
"not",
"isinstance",
"(",
"entities",
",",
"(",
"bytes",
",",
"str",
",",
"list",
")",
")",
":",
"raise",
"Exception",
"(... | EnsureDead calls EnsureDead on each given entity from state. | [
"EnsureDead",
"calls",
"EnsureDead",
"on",
"each",
"given",
"entity",
"from",
"state",
"."
] | [
"'''\n EnsureDead calls EnsureDead on each given entity from state. It\n will fail if the entity is not present. If it's Alive, nothing will\n happen (see state/EnsureDead() for units or machines).\n\n entities : typing.Sequence[~Entity]\n Returns -> ErrorResults\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... |
059810c3daf85c4d82660c8b92a994e845183ae8 | sed-i/python-libjuju | juju/client/_client4.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='Machiner',
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... |
059810c3daf85c4d82660c8b92a994e845183ae8 | sed-i/python-libjuju | juju/client/_client4.py | [
"Apache-2.0"
] | Python | ModelUUID | <not_specific> | async def ModelUUID(self):
'''
ModelUUID returns the model UUID that this machine resides in.
It is implemented here directly as a result of removing it from
embedded APIAddresser *without* bumping the facade version.
It should be blanked when this facade version is next incremen... |
ModelUUID returns the model UUID that this machine resides in.
It is implemented here directly as a result of removing it from
embedded APIAddresser *without* bumping the facade version.
It should be blanked when this facade version is next incremented.
Returns -> StringResult... | ModelUUID returns the model UUID that this machine resides in.
It is implemented here directly as a result of removing it from
embedded APIAddresser *without* bumping the facade version.
It should be blanked when this facade version is next incremented.
| [
"ModelUUID",
"returns",
"the",
"model",
"UUID",
"that",
"this",
"machine",
"resides",
"in",
".",
"It",
"is",
"implemented",
"here",
"directly",
"as",
"a",
"result",
"of",
"removing",
"it",
"from",
"embedded",
"APIAddresser",
"*",
"without",
"*",
"bumping",
"... | async def ModelUUID(self):
_params = dict()
msg = dict(type='Machiner',
request='ModelUUID',
version=4,
params=_params)
reply = await self.rpc(msg)
return reply | [
"async",
"def",
"ModelUUID",
"(",
"self",
")",
":",
"_params",
"=",
"dict",
"(",
")",
"msg",
"=",
"dict",
"(",
"type",
"=",
"'Machiner'",
",",
"request",
"=",
"'ModelUUID'",
",",
"version",
"=",
"4",
",",
"params",
"=",
"_params",
")",
"reply",
"=",
... | ModelUUID returns the model UUID that this machine resides in. | [
"ModelUUID",
"returns",
"the",
"model",
"UUID",
"that",
"this",
"machine",
"resides",
"in",
"."
] | [
"'''\n ModelUUID returns the model UUID that this machine resides in.\n It is implemented here directly as a result of removing it from\n embedded APIAddresser *without* bumping the facade version.\n It should be blanked when this facade version is next incremented.\n\n\n Returns ... | [
{
"param": "self",
"type": null
}
] | {
"returns": [],
"raises": [],
"params": [
{
"identifier": "self",
"type": null,
"docstring": null,
"docstring_tokens": [],
"default": null,
"is_optional": null
}
],
"outlier_params": [],
"others": []
} |
059810c3daf85c4d82660c8b92a994e845183ae8 | sed-i/python-libjuju | juju/client/_client4.py | [
"Apache-2.0"
] | Python | RecordAgentStartTime | <not_specific> | async def RecordAgentStartTime(self, entities=None):
'''
RecordAgentStartTime updates the agent start time field in the machine doc.
entities : typing.Sequence[~Entity]
Returns -> ErrorResults
'''
if entities is not None and not isinstance(entities, (bytes, str, list)):
... |
RecordAgentStartTime updates the agent start time field in the machine doc.
entities : typing.Sequence[~Entity]
Returns -> ErrorResults
| RecordAgentStartTime updates the agent start time field in the machine doc.
entities : typing.Sequence[~Entity]
Returns -> ErrorResults | [
"RecordAgentStartTime",
"updates",
"the",
"agent",
"start",
"time",
"field",
"in",
"the",
"machine",
"doc",
".",
"entities",
":",
"typing",
".",
"Sequence",
"[",
"~Entity",
"]",
"Returns",
"-",
">",
"ErrorResults"
] | async def RecordAgentStartTime(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='Machiner',
re... | [
"async",
"def",
"RecordAgentStartTime",
"(",
"self",
",",
"entities",
"=",
"None",
")",
":",
"if",
"entities",
"is",
"not",
"None",
"and",
"not",
"isinstance",
"(",
"entities",
",",
"(",
"bytes",
",",
"str",
",",
"list",
")",
")",
":",
"raise",
"Except... | RecordAgentStartTime updates the agent start time field in the machine doc. | [
"RecordAgentStartTime",
"updates",
"the",
"agent",
"start",
"time",
"field",
"in",
"the",
"machine",
"doc",
"."
] | [
"'''\n RecordAgentStartTime updates the agent start time field in the machine doc.\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... |
059810c3daf85c4d82660c8b92a994e845183ae8 | sed-i/python-libjuju | juju/client/_client4.py | [
"Apache-2.0"
] | Python | SetObservedNetworkConfig | <not_specific> | async def SetObservedNetworkConfig(self, config=None, tag=None):
'''
SetObservedNetworkConfig reads the network config for the machine
identified by the input args.
This config is merged with the new network config supplied in the
same args and updated if it has changed.
... |
SetObservedNetworkConfig reads the network config for the machine
identified by the input args.
This config is merged with the new network config supplied in the
same args and updated if it has changed.
config : typing.Sequence[~NetworkConfig]
tag : str
Returns ... | SetObservedNetworkConfig reads the network config for the machine
identified by the input args.
This config is merged with the new network config supplied in the
same args and updated if it has changed.
config : typing.Sequence[~NetworkConfig]
tag : str
Returns -> None | [
"SetObservedNetworkConfig",
"reads",
"the",
"network",
"config",
"for",
"the",
"machine",
"identified",
"by",
"the",
"input",
"args",
".",
"This",
"config",
"is",
"merged",
"with",
"the",
"new",
"network",
"config",
"supplied",
"in",
"the",
"same",
"args",
"an... | async def SetObservedNetworkConfig(self, config=None, tag=None):
if config is not None and not isinstance(config, (bytes, str, list)):
raise Exception("Expected config to be a Sequence, received: {}".format(type(config)))
if tag is not None and not isinstance(tag, (bytes, str)):
... | [
"async",
"def",
"SetObservedNetworkConfig",
"(",
"self",
",",
"config",
"=",
"None",
",",
"tag",
"=",
"None",
")",
":",
"if",
"config",
"is",
"not",
"None",
"and",
"not",
"isinstance",
"(",
"config",
",",
"(",
"bytes",
",",
"str",
",",
"list",
")",
"... | SetObservedNetworkConfig reads the network config for the machine
identified by the input args. | [
"SetObservedNetworkConfig",
"reads",
"the",
"network",
"config",
"for",
"the",
"machine",
"identified",
"by",
"the",
"input",
"args",
"."
] | [
"'''\n SetObservedNetworkConfig reads the network config for the machine\n identified by the input args.\n This config is merged with the new network config supplied in the\n same args and updated if it has changed.\n\n config : typing.Sequence[~NetworkConfig]\n tag : str\n... | [
{
"param": "self",
"type": null
},
{
"param": "config",
"type": null
},
{
"param": "tag",
"type": null
}
] | {
"returns": [],
"raises": [],
"params": [
{
"identifier": "self",
"type": null,
"docstring": null,
"docstring_tokens": [],
"default": null,
"is_optional": null
},
{
"identifier": "config",
"type": null,
"docstring": null,
"docstring_tokens":... |
059810c3daf85c4d82660c8b92a994e845183ae8 | sed-i/python-libjuju | juju/client/_client4.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='Machiner',
request='SetS... | [
"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... |
059810c3daf85c4d82660c8b92a994e845183ae8 | sed-i/python-libjuju | juju/client/_client4.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='Machiner',
request='U... | [
"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... |
059810c3daf85c4d82660c8b92a994e845183ae8 | sed-i/python-libjuju | juju/client/_client4.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='Machiner',
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... |
059810c3daf85c4d82660c8b92a994e845183ae8 | sed-i/python-libjuju | juju/client/_client4.py | [
"Apache-2.0"
] | Python | WatchAPIHostPorts | <not_specific> | async def WatchAPIHostPorts(self):
'''
WatchAPIHostPorts watches the API server addresses.
Returns -> NotifyWatchResult
'''
# map input types to rpc msg
_params = dict()
msg = dict(type='Machiner',
request='WatchAPIHostPorts',
... |
WatchAPIHostPorts watches the API server addresses.
Returns -> NotifyWatchResult
| WatchAPIHostPorts watches the API server addresses. | [
"WatchAPIHostPorts",
"watches",
"the",
"API",
"server",
"addresses",
"."
] | async def WatchAPIHostPorts(self):
_params = dict()
msg = dict(type='Machiner',
request='WatchAPIHostPorts',
version=4,
params=_params)
reply = await self.rpc(msg)
return reply | [
"async",
"def",
"WatchAPIHostPorts",
"(",
"self",
")",
":",
"_params",
"=",
"dict",
"(",
")",
"msg",
"=",
"dict",
"(",
"type",
"=",
"'Machiner'",
",",
"request",
"=",
"'WatchAPIHostPorts'",
",",
"version",
"=",
"4",
",",
"params",
"=",
"_params",
")",
... | WatchAPIHostPorts watches the API server addresses. | [
"WatchAPIHostPorts",
"watches",
"the",
"API",
"server",
"addresses",
"."
] | [
"'''\n WatchAPIHostPorts watches the API server addresses.\n\n\n Returns -> NotifyWatchResult\n '''",
"# map input types to rpc msg"
] | [
{
"param": "self",
"type": null
}
] | {
"returns": [],
"raises": [],
"params": [
{
"identifier": "self",
"type": null,
"docstring": null,
"docstring_tokens": [],
"default": null,
"is_optional": null
}
],
"outlier_params": [],
"others": []
} |
059810c3daf85c4d82660c8b92a994e845183ae8 | sed-i/python-libjuju | juju/client/_client4.py | [
"Apache-2.0"
] | Python | AbortBranch | <not_specific> | async def AbortBranch(self, branch=None):
'''
AbortBranch aborts the input branch, marking it complete. However no
changes are made applicable to the whole model. No units may be assigned
to the branch when aborting.
branch : str
Returns -> ErrorResult
'''
... |
AbortBranch aborts the input branch, marking it complete. However no
changes are made applicable to the whole model. No units may be assigned
to the branch when aborting.
branch : str
Returns -> ErrorResult
| AbortBranch aborts the input branch, marking it complete. However no
changes are made applicable to the whole model. No units may be assigned
to the branch when aborting.
branch : str
Returns -> ErrorResult | [
"AbortBranch",
"aborts",
"the",
"input",
"branch",
"marking",
"it",
"complete",
".",
"However",
"no",
"changes",
"are",
"made",
"applicable",
"to",
"the",
"whole",
"model",
".",
"No",
"units",
"may",
"be",
"assigned",
"to",
"the",
"branch",
"when",
"aborting... | async def AbortBranch(self, branch=None):
if branch is not None and not isinstance(branch, (bytes, str)):
raise Exception("Expected branch to be a str, received: {}".format(type(branch)))
_params = dict()
msg = dict(type='ModelGeneration',
request='AbortBranch',
... | [
"async",
"def",
"AbortBranch",
"(",
"self",
",",
"branch",
"=",
"None",
")",
":",
"if",
"branch",
"is",
"not",
"None",
"and",
"not",
"isinstance",
"(",
"branch",
",",
"(",
"bytes",
",",
"str",
")",
")",
":",
"raise",
"Exception",
"(",
"\"Expected branc... | AbortBranch aborts the input branch, marking it complete. | [
"AbortBranch",
"aborts",
"the",
"input",
"branch",
"marking",
"it",
"complete",
"."
] | [
"'''\n AbortBranch aborts the input branch, marking it complete. However no\n changes are made applicable to the whole model. No units may be assigned\n to the branch when aborting.\n\n branch : str\n Returns -> ErrorResult\n '''",
"# map input types to rpc msg"
] | [
{
"param": "self",
"type": null
},
{
"param": "branch",
"type": null
}
] | {
"returns": [],
"raises": [],
"params": [
{
"identifier": "self",
"type": null,
"docstring": null,
"docstring_tokens": [],
"default": null,
"is_optional": null
},
{
"identifier": "branch",
"type": null,
"docstring": null,
"docstring_tokens":... |
059810c3daf85c4d82660c8b92a994e845183ae8 | sed-i/python-libjuju | juju/client/_client4.py | [
"Apache-2.0"
] | Python | AddBranch | <not_specific> | async def AddBranch(self, branch=None):
'''
AddBranch adds a new branch with the input name to the model.
branch : str
Returns -> ErrorResult
'''
if branch is not None and not isinstance(branch, (bytes, str)):
raise Exception("Expected branch to be a str, rec... |
AddBranch adds a new branch with the input name to the model.
branch : str
Returns -> ErrorResult
| AddBranch adds a new branch with the input name to the model.
branch : str
Returns -> ErrorResult | [
"AddBranch",
"adds",
"a",
"new",
"branch",
"with",
"the",
"input",
"name",
"to",
"the",
"model",
".",
"branch",
":",
"str",
"Returns",
"-",
">",
"ErrorResult"
] | async def AddBranch(self, branch=None):
if branch is not None and not isinstance(branch, (bytes, str)):
raise Exception("Expected branch to be a str, received: {}".format(type(branch)))
_params = dict()
msg = dict(type='ModelGeneration',
request='AddBranch',
... | [
"async",
"def",
"AddBranch",
"(",
"self",
",",
"branch",
"=",
"None",
")",
":",
"if",
"branch",
"is",
"not",
"None",
"and",
"not",
"isinstance",
"(",
"branch",
",",
"(",
"bytes",
",",
"str",
")",
")",
":",
"raise",
"Exception",
"(",
"\"Expected branch ... | AddBranch adds a new branch with the input name to the model. | [
"AddBranch",
"adds",
"a",
"new",
"branch",
"with",
"the",
"input",
"name",
"to",
"the",
"model",
"."
] | [
"'''\n AddBranch adds a new branch with the input name to the model.\n\n branch : str\n Returns -> ErrorResult\n '''",
"# map input types to rpc msg"
] | [
{
"param": "self",
"type": null
},
{
"param": "branch",
"type": null
}
] | {
"returns": [],
"raises": [],
"params": [
{
"identifier": "self",
"type": null,
"docstring": null,
"docstring_tokens": [],
"default": null,
"is_optional": null
},
{
"identifier": "branch",
"type": null,
"docstring": null,
"docstring_tokens":... |
059810c3daf85c4d82660c8b92a994e845183ae8 | sed-i/python-libjuju | juju/client/_client4.py | [
"Apache-2.0"
] | Python | BranchInfo | <not_specific> | async def BranchInfo(self, branches=None, detailed=None):
'''
BranchInfo will return details of branch identified by the input argument,
including units on the branch and the configuration disjoint with the
master generation.
An error is returned if no in-flight branch matching i... |
BranchInfo will return details of branch identified by the input argument,
including units on the branch and the configuration disjoint with the
master generation.
An error is returned if no in-flight branch matching in input is found.
branches : typing.Sequence[str]
de... | BranchInfo will return details of branch identified by the input argument,
including units on the branch and the configuration disjoint with the
master generation.
An error is returned if no in-flight branch matching in input is found.
branches : typing.Sequence[str]
detailed : bool
Returns -> BranchResults | [
"BranchInfo",
"will",
"return",
"details",
"of",
"branch",
"identified",
"by",
"the",
"input",
"argument",
"including",
"units",
"on",
"the",
"branch",
"and",
"the",
"configuration",
"disjoint",
"with",
"the",
"master",
"generation",
".",
"An",
"error",
"is",
... | async def BranchInfo(self, branches=None, detailed=None):
if branches is not None and not isinstance(branches, (bytes, str, list)):
raise Exception("Expected branches to be a Sequence, received: {}".format(type(branches)))
if detailed is not None and not isinstance(detailed, bool):
... | [
"async",
"def",
"BranchInfo",
"(",
"self",
",",
"branches",
"=",
"None",
",",
"detailed",
"=",
"None",
")",
":",
"if",
"branches",
"is",
"not",
"None",
"and",
"not",
"isinstance",
"(",
"branches",
",",
"(",
"bytes",
",",
"str",
",",
"list",
")",
")",... | BranchInfo will return details of branch identified by the input argument,
including units on the branch and the configuration disjoint with the
master generation. | [
"BranchInfo",
"will",
"return",
"details",
"of",
"branch",
"identified",
"by",
"the",
"input",
"argument",
"including",
"units",
"on",
"the",
"branch",
"and",
"the",
"configuration",
"disjoint",
"with",
"the",
"master",
"generation",
"."
] | [
"'''\n BranchInfo will return details of branch identified by the input argument,\n including units on the branch and the configuration disjoint with the\n master generation.\n An error is returned if no in-flight branch matching in input is found.\n\n branches : typing.Sequence[s... | [
{
"param": "self",
"type": null
},
{
"param": "branches",
"type": null
},
{
"param": "detailed",
"type": null
}
] | {
"returns": [],
"raises": [],
"params": [
{
"identifier": "self",
"type": null,
"docstring": null,
"docstring_tokens": [],
"default": null,
"is_optional": null
},
{
"identifier": "branches",
"type": null,
"docstring": null,
"docstring_tokens... |
059810c3daf85c4d82660c8b92a994e845183ae8 | sed-i/python-libjuju | juju/client/_client4.py | [
"Apache-2.0"
] | Python | CommitBranch | <not_specific> | async def CommitBranch(self, branch=None):
'''
CommitBranch commits the input branch, making its changes applicable to
the whole model and marking it complete.
branch : str
Returns -> IntResult
'''
if branch is not None and not isinstance(branch, (bytes, str)):
... |
CommitBranch commits the input branch, making its changes applicable to
the whole model and marking it complete.
branch : str
Returns -> IntResult
| CommitBranch commits the input branch, making its changes applicable to
the whole model and marking it complete.
branch : str
Returns -> IntResult | [
"CommitBranch",
"commits",
"the",
"input",
"branch",
"making",
"its",
"changes",
"applicable",
"to",
"the",
"whole",
"model",
"and",
"marking",
"it",
"complete",
".",
"branch",
":",
"str",
"Returns",
"-",
">",
"IntResult"
] | async def CommitBranch(self, branch=None):
if branch is not None and not isinstance(branch, (bytes, str)):
raise Exception("Expected branch to be a str, received: {}".format(type(branch)))
_params = dict()
msg = dict(type='ModelGeneration',
request='CommitBranch',
... | [
"async",
"def",
"CommitBranch",
"(",
"self",
",",
"branch",
"=",
"None",
")",
":",
"if",
"branch",
"is",
"not",
"None",
"and",
"not",
"isinstance",
"(",
"branch",
",",
"(",
"bytes",
",",
"str",
")",
")",
":",
"raise",
"Exception",
"(",
"\"Expected bran... | CommitBranch commits the input branch, making its changes applicable to
the whole model and marking it complete. | [
"CommitBranch",
"commits",
"the",
"input",
"branch",
"making",
"its",
"changes",
"applicable",
"to",
"the",
"whole",
"model",
"and",
"marking",
"it",
"complete",
"."
] | [
"'''\n CommitBranch commits the input branch, making its changes applicable to\n the whole model and marking it complete.\n\n branch : str\n Returns -> IntResult\n '''",
"# map input types to rpc msg"
] | [
{
"param": "self",
"type": null
},
{
"param": "branch",
"type": null
}
] | {
"returns": [],
"raises": [],
"params": [
{
"identifier": "self",
"type": null,
"docstring": null,
"docstring_tokens": [],
"default": null,
"is_optional": null
},
{
"identifier": "branch",
"type": null,
"docstring": null,
"docstring_tokens":... |
059810c3daf85c4d82660c8b92a994e845183ae8 | sed-i/python-libjuju | juju/client/_client4.py | [
"Apache-2.0"
] | Python | HasActiveBranch | <not_specific> | async def HasActiveBranch(self, branch=None):
'''
HasActiveBranch returns a true result if the input model has an "in-flight"
branch matching the input name.
branch : str
Returns -> BoolResult
'''
if branch is not None and not isinstance(branch, (bytes, str)):
... |
HasActiveBranch returns a true result if the input model has an "in-flight"
branch matching the input name.
branch : str
Returns -> BoolResult
| HasActiveBranch returns a true result if the input model has an "in-flight"
branch matching the input name.
branch : str
Returns -> BoolResult | [
"HasActiveBranch",
"returns",
"a",
"true",
"result",
"if",
"the",
"input",
"model",
"has",
"an",
"\"",
"in",
"-",
"flight",
"\"",
"branch",
"matching",
"the",
"input",
"name",
".",
"branch",
":",
"str",
"Returns",
"-",
">",
"BoolResult"
] | async def HasActiveBranch(self, branch=None):
if branch is not None and not isinstance(branch, (bytes, str)):
raise Exception("Expected branch to be a str, received: {}".format(type(branch)))
_params = dict()
msg = dict(type='ModelGeneration',
request='HasActiveBra... | [
"async",
"def",
"HasActiveBranch",
"(",
"self",
",",
"branch",
"=",
"None",
")",
":",
"if",
"branch",
"is",
"not",
"None",
"and",
"not",
"isinstance",
"(",
"branch",
",",
"(",
"bytes",
",",
"str",
")",
")",
":",
"raise",
"Exception",
"(",
"\"Expected b... | HasActiveBranch returns a true result if the input model has an "in-flight"
branch matching the input name. | [
"HasActiveBranch",
"returns",
"a",
"true",
"result",
"if",
"the",
"input",
"model",
"has",
"an",
"\"",
"in",
"-",
"flight",
"\"",
"branch",
"matching",
"the",
"input",
"name",
"."
] | [
"'''\n HasActiveBranch returns a true result if the input model has an \"in-flight\"\n branch matching the input name.\n\n branch : str\n Returns -> BoolResult\n '''",
"# map input types to rpc msg"
] | [
{
"param": "self",
"type": null
},
{
"param": "branch",
"type": null
}
] | {
"returns": [],
"raises": [],
"params": [
{
"identifier": "self",
"type": null,
"docstring": null,
"docstring_tokens": [],
"default": null,
"is_optional": null
},
{
"identifier": "branch",
"type": null,
"docstring": null,
"docstring_tokens":... |
059810c3daf85c4d82660c8b92a994e845183ae8 | sed-i/python-libjuju | juju/client/_client4.py | [
"Apache-2.0"
] | Python | ListCommits | <not_specific> | async def ListCommits(self):
'''
ListCommits will return the commits, hence only branches with generation_id higher than 0
Returns -> BranchResults
'''
# map input types to rpc msg
_params = dict()
msg = dict(type='ModelGeneration',
request='... |
ListCommits will return the commits, hence only branches with generation_id higher than 0
Returns -> BranchResults
| ListCommits will return the commits, hence only branches with generation_id higher than 0
Returns -> BranchResults | [
"ListCommits",
"will",
"return",
"the",
"commits",
"hence",
"only",
"branches",
"with",
"generation_id",
"higher",
"than",
"0",
"Returns",
"-",
">",
"BranchResults"
] | async def ListCommits(self):
_params = dict()
msg = dict(type='ModelGeneration',
request='ListCommits',
version=4,
params=_params)
reply = await self.rpc(msg)
return reply | [
"async",
"def",
"ListCommits",
"(",
"self",
")",
":",
"_params",
"=",
"dict",
"(",
")",
"msg",
"=",
"dict",
"(",
"type",
"=",
"'ModelGeneration'",
",",
"request",
"=",
"'ListCommits'",
",",
"version",
"=",
"4",
",",
"params",
"=",
"_params",
")",
"repl... | ListCommits will return the commits, hence only branches with generation_id higher than 0
Returns -> BranchResults | [
"ListCommits",
"will",
"return",
"the",
"commits",
"hence",
"only",
"branches",
"with",
"generation_id",
"higher",
"than",
"0",
"Returns",
"-",
">",
"BranchResults"
] | [
"'''\n ListCommits will return the commits, hence only branches with generation_id higher than 0\n\n\n Returns -> BranchResults\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": []
} |
059810c3daf85c4d82660c8b92a994e845183ae8 | sed-i/python-libjuju | juju/client/_client4.py | [
"Apache-2.0"
] | Python | ShowCommit | <not_specific> | async def ShowCommit(self, generation_id=None):
'''
ShowCommit will return details a commit given by its generationId
An error is returned if either no branch can be found corresponding to the generation id.
Or the generation id given is below 1.
generation_id : int
Retu... |
ShowCommit will return details a commit given by its generationId
An error is returned if either no branch can be found corresponding to the generation id.
Or the generation id given is below 1.
generation_id : int
Returns -> GenerationResult
| ShowCommit will return details a commit given by its generationId
An error is returned if either no branch can be found corresponding to the generation id.
Or the generation id given is below 1.
| [
"ShowCommit",
"will",
"return",
"details",
"a",
"commit",
"given",
"by",
"its",
"generationId",
"An",
"error",
"is",
"returned",
"if",
"either",
"no",
"branch",
"can",
"be",
"found",
"corresponding",
"to",
"the",
"generation",
"id",
".",
"Or",
"the",
"genera... | async def ShowCommit(self, generation_id=None):
if generation_id is not None and not isinstance(generation_id, int):
raise Exception("Expected generation_id to be a int, received: {}".format(type(generation_id)))
_params = dict()
msg = dict(type='ModelGeneration',
... | [
"async",
"def",
"ShowCommit",
"(",
"self",
",",
"generation_id",
"=",
"None",
")",
":",
"if",
"generation_id",
"is",
"not",
"None",
"and",
"not",
"isinstance",
"(",
"generation_id",
",",
"int",
")",
":",
"raise",
"Exception",
"(",
"\"Expected generation_id to ... | ShowCommit will return details a commit given by its generationId
An error is returned if either no branch can be found corresponding to the generation id. | [
"ShowCommit",
"will",
"return",
"details",
"a",
"commit",
"given",
"by",
"its",
"generationId",
"An",
"error",
"is",
"returned",
"if",
"either",
"no",
"branch",
"can",
"be",
"found",
"corresponding",
"to",
"the",
"generation",
"id",
"."
] | [
"'''\n ShowCommit will return details a commit given by its generationId\n An error is returned if either no branch can be found corresponding to the generation id.\n Or the generation id given is below 1.\n\n generation_id : int\n Returns -> GenerationResult\n '''",
"# m... | [
{
"param": "self",
"type": null
},
{
"param": "generation_id",
"type": null
}
] | {
"returns": [],
"raises": [],
"params": [
{
"identifier": "self",
"type": null,
"docstring": null,
"docstring_tokens": [],
"default": null,
"is_optional": null
},
{
"identifier": "generation_id",
"type": null,
"docstring": null,
"docstring_t... |
059810c3daf85c4d82660c8b92a994e845183ae8 | sed-i/python-libjuju | juju/client/_client4.py | [
"Apache-2.0"
] | Python | TrackBranch | <not_specific> | async def TrackBranch(self, branch=None, entities=None, num_units=None):
'''
TrackBranch marks the input units and/or applications as tracking the input
branch, causing them to realise changes made under that branch.
branch : str
entities : typing.Sequence[~Entity]
num_u... |
TrackBranch marks the input units and/or applications as tracking the input
branch, causing them to realise changes made under that branch.
branch : str
entities : typing.Sequence[~Entity]
num_units : int
Returns -> ErrorResults
| TrackBranch marks the input units and/or applications as tracking the input
branch, causing them to realise changes made under that branch.
branch : str
entities : typing.Sequence[~Entity]
num_units : int
Returns -> ErrorResults | [
"TrackBranch",
"marks",
"the",
"input",
"units",
"and",
"/",
"or",
"applications",
"as",
"tracking",
"the",
"input",
"branch",
"causing",
"them",
"to",
"realise",
"changes",
"made",
"under",
"that",
"branch",
".",
"branch",
":",
"str",
"entities",
":",
"typi... | async def TrackBranch(self, branch=None, entities=None, num_units=None):
if branch is not None and not isinstance(branch, (bytes, str)):
raise Exception("Expected branch to be a str, received: {}".format(type(branch)))
if entities is not None and not isinstance(entities, (bytes, str, list)):... | [
"async",
"def",
"TrackBranch",
"(",
"self",
",",
"branch",
"=",
"None",
",",
"entities",
"=",
"None",
",",
"num_units",
"=",
"None",
")",
":",
"if",
"branch",
"is",
"not",
"None",
"and",
"not",
"isinstance",
"(",
"branch",
",",
"(",
"bytes",
",",
"st... | TrackBranch marks the input units and/or applications as tracking the input
branch, causing them to realise changes made under that branch. | [
"TrackBranch",
"marks",
"the",
"input",
"units",
"and",
"/",
"or",
"applications",
"as",
"tracking",
"the",
"input",
"branch",
"causing",
"them",
"to",
"realise",
"changes",
"made",
"under",
"that",
"branch",
"."
] | [
"'''\n TrackBranch marks the input units and/or applications as tracking the input\n branch, causing them to realise changes made under that branch.\n\n branch : str\n entities : typing.Sequence[~Entity]\n num_units : int\n Returns -> ErrorResults\n '''",
"# map in... | [
{
"param": "self",
"type": null
},
{
"param": "branch",
"type": null
},
{
"param": "entities",
"type": null
},
{
"param": "num_units",
"type": null
}
] | {
"returns": [],
"raises": [],
"params": [
{
"identifier": "self",
"type": null,
"docstring": null,
"docstring_tokens": [],
"default": null,
"is_optional": null
},
{
"identifier": "branch",
"type": null,
"docstring": null,
"docstring_tokens":... |
059810c3daf85c4d82660c8b92a994e845183ae8 | sed-i/python-libjuju | juju/client/_client4.py | [
"Apache-2.0"
] | Python | AttachmentLife | <not_specific> | async def AttachmentLife(self, ids=None):
'''
AttachmentLife returns the lifecycle state of each specified machine
storage attachment.
ids : typing.Sequence[~MachineStorageId]
Returns -> LifeResults
'''
if ids is not None and not isinstance(ids, (bytes, str, list... |
AttachmentLife returns the lifecycle state of each specified machine
storage attachment.
ids : typing.Sequence[~MachineStorageId]
Returns -> LifeResults
| AttachmentLife returns the lifecycle state of each specified machine
storage attachment.
| [
"AttachmentLife",
"returns",
"the",
"lifecycle",
"state",
"of",
"each",
"specified",
"machine",
"storage",
"attachment",
"."
] | async def AttachmentLife(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='StorageProvisioner',
request='AttachmentLife... | [
"async",
"def",
"AttachmentLife",
"(",
"self",
",",
"ids",
"=",
"None",
")",
":",
"if",
"ids",
"is",
"not",
"None",
"and",
"not",
"isinstance",
"(",
"ids",
",",
"(",
"bytes",
",",
"str",
",",
"list",
")",
")",
":",
"raise",
"Exception",
"(",
"\"Exp... | AttachmentLife returns the lifecycle state of each specified machine
storage attachment. | [
"AttachmentLife",
"returns",
"the",
"lifecycle",
"state",
"of",
"each",
"specified",
"machine",
"storage",
"attachment",
"."
] | [
"'''\n AttachmentLife returns the lifecycle state of each specified machine\n storage attachment.\n\n ids : typing.Sequence[~MachineStorageId]\n Returns -> LifeResults\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": []... |
059810c3daf85c4d82660c8b92a994e845183ae8 | sed-i/python-libjuju | juju/client/_client4.py | [
"Apache-2.0"
] | Python | EnsureDead | <not_specific> | async def EnsureDead(self, entities=None):
'''
EnsureDead calls EnsureDead on each given entity from state. It
will fail if the entity is not present. If it's Alive, nothing will
happen (see state/EnsureDead() for units or machines).
entities : typing.Sequence[~Entity]
R... |
EnsureDead calls EnsureDead on each given entity from state. It
will fail if the entity is not present. If it's Alive, nothing will
happen (see state/EnsureDead() for units or machines).
entities : typing.Sequence[~Entity]
Returns -> ErrorResults
| EnsureDead calls EnsureDead on each given entity from state. It
will fail if the entity is not present. If it's Alive, nothing will
happen for units or machines).
entities : typing.Sequence[~Entity]
Returns -> ErrorResults | [
"EnsureDead",
"calls",
"EnsureDead",
"on",
"each",
"given",
"entity",
"from",
"state",
".",
"It",
"will",
"fail",
"if",
"the",
"entity",
"is",
"not",
"present",
".",
"If",
"it",
"'",
"s",
"Alive",
"nothing",
"will",
"happen",
"for",
"units",
"or",
"machi... | async def EnsureDead(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='StorageProvisioner',
re... | [
"async",
"def",
"EnsureDead",
"(",
"self",
",",
"entities",
"=",
"None",
")",
":",
"if",
"entities",
"is",
"not",
"None",
"and",
"not",
"isinstance",
"(",
"entities",
",",
"(",
"bytes",
",",
"str",
",",
"list",
")",
")",
":",
"raise",
"Exception",
"(... | EnsureDead calls EnsureDead on each given entity from state. | [
"EnsureDead",
"calls",
"EnsureDead",
"on",
"each",
"given",
"entity",
"from",
"state",
"."
] | [
"'''\n EnsureDead calls EnsureDead on each given entity from state. It\n will fail if the entity is not present. If it's Alive, nothing will\n happen (see state/EnsureDead() for units or machines).\n\n entities : typing.Sequence[~Entity]\n Returns -> ErrorResults\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... |
059810c3daf85c4d82660c8b92a994e845183ae8 | sed-i/python-libjuju | juju/client/_client4.py | [
"Apache-2.0"
] | Python | FilesystemAttachmentParams | <not_specific> | async def FilesystemAttachmentParams(self, ids=None):
'''
FilesystemAttachmentParams returns the parameters for creating the filesystem
attachments with the specified IDs.
ids : typing.Sequence[~MachineStorageId]
Returns -> FilesystemAttachmentParamsResults
'''
i... |
FilesystemAttachmentParams returns the parameters for creating the filesystem
attachments with the specified IDs.
ids : typing.Sequence[~MachineStorageId]
Returns -> FilesystemAttachmentParamsResults
| FilesystemAttachmentParams returns the parameters for creating the filesystem
attachments with the specified IDs.
| [
"FilesystemAttachmentParams",
"returns",
"the",
"parameters",
"for",
"creating",
"the",
"filesystem",
"attachments",
"with",
"the",
"specified",
"IDs",
"."
] | async def FilesystemAttachmentParams(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='StorageProvisioner',
request='Fi... | [
"async",
"def",
"FilesystemAttachmentParams",
"(",
"self",
",",
"ids",
"=",
"None",
")",
":",
"if",
"ids",
"is",
"not",
"None",
"and",
"not",
"isinstance",
"(",
"ids",
",",
"(",
"bytes",
",",
"str",
",",
"list",
")",
")",
":",
"raise",
"Exception",
"... | FilesystemAttachmentParams returns the parameters for creating the filesystem
attachments with the specified IDs. | [
"FilesystemAttachmentParams",
"returns",
"the",
"parameters",
"for",
"creating",
"the",
"filesystem",
"attachments",
"with",
"the",
"specified",
"IDs",
"."
] | [
"'''\n FilesystemAttachmentParams returns the parameters for creating the filesystem\n attachments with the specified IDs.\n\n ids : typing.Sequence[~MachineStorageId]\n Returns -> FilesystemAttachmentParamsResults\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": []... |
059810c3daf85c4d82660c8b92a994e845183ae8 | sed-i/python-libjuju | juju/client/_client4.py | [
"Apache-2.0"
] | Python | FilesystemAttachments | <not_specific> | async def FilesystemAttachments(self, ids=None):
'''
FilesystemAttachments returns details of filesystem attachments with the specified IDs.
ids : typing.Sequence[~MachineStorageId]
Returns -> FilesystemAttachmentResults
'''
if ids is not None and not isinstance(ids, (by... |
FilesystemAttachments returns details of filesystem attachments with the specified IDs.
ids : typing.Sequence[~MachineStorageId]
Returns -> FilesystemAttachmentResults
| FilesystemAttachments returns details of filesystem attachments with the specified IDs. | [
"FilesystemAttachments",
"returns",
"details",
"of",
"filesystem",
"attachments",
"with",
"the",
"specified",
"IDs",
"."
] | async def FilesystemAttachments(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='StorageProvisioner',
request='Filesys... | [
"async",
"def",
"FilesystemAttachments",
"(",
"self",
",",
"ids",
"=",
"None",
")",
":",
"if",
"ids",
"is",
"not",
"None",
"and",
"not",
"isinstance",
"(",
"ids",
",",
"(",
"bytes",
",",
"str",
",",
"list",
")",
")",
":",
"raise",
"Exception",
"(",
... | FilesystemAttachments returns details of filesystem attachments with the specified IDs. | [
"FilesystemAttachments",
"returns",
"details",
"of",
"filesystem",
"attachments",
"with",
"the",
"specified",
"IDs",
"."
] | [
"'''\n FilesystemAttachments returns details of filesystem attachments with the specified IDs.\n\n ids : typing.Sequence[~MachineStorageId]\n Returns -> FilesystemAttachmentResults\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": []... |
059810c3daf85c4d82660c8b92a994e845183ae8 | sed-i/python-libjuju | juju/client/_client4.py | [
"Apache-2.0"
] | Python | FilesystemParams | <not_specific> | async def FilesystemParams(self, entities=None):
'''
FilesystemParams returns the parameters for creating the filesystems
with the specified tags.
entities : typing.Sequence[~Entity]
Returns -> FilesystemParamsResults
'''
if entities is not None and not isinstanc... |
FilesystemParams returns the parameters for creating the filesystems
with the specified tags.
entities : typing.Sequence[~Entity]
Returns -> FilesystemParamsResults
| FilesystemParams returns the parameters for creating the filesystems
with the specified tags.
entities : typing.Sequence[~Entity]
Returns -> FilesystemParamsResults | [
"FilesystemParams",
"returns",
"the",
"parameters",
"for",
"creating",
"the",
"filesystems",
"with",
"the",
"specified",
"tags",
".",
"entities",
":",
"typing",
".",
"Sequence",
"[",
"~Entity",
"]",
"Returns",
"-",
">",
"FilesystemParamsResults"
] | async def FilesystemParams(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='StorageProvisioner',
... | [
"async",
"def",
"FilesystemParams",
"(",
"self",
",",
"entities",
"=",
"None",
")",
":",
"if",
"entities",
"is",
"not",
"None",
"and",
"not",
"isinstance",
"(",
"entities",
",",
"(",
"bytes",
",",
"str",
",",
"list",
")",
")",
":",
"raise",
"Exception"... | FilesystemParams returns the parameters for creating the filesystems
with the specified tags. | [
"FilesystemParams",
"returns",
"the",
"parameters",
"for",
"creating",
"the",
"filesystems",
"with",
"the",
"specified",
"tags",
"."
] | [
"'''\n FilesystemParams returns the parameters for creating the filesystems\n with the specified tags.\n\n entities : typing.Sequence[~Entity]\n Returns -> FilesystemParamsResults\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... |
059810c3daf85c4d82660c8b92a994e845183ae8 | sed-i/python-libjuju | juju/client/_client4.py | [
"Apache-2.0"
] | Python | Filesystems | <not_specific> | async def Filesystems(self, entities=None):
'''
Filesystems returns details of filesystems with the specified tags.
entities : typing.Sequence[~Entity]
Returns -> FilesystemResults
'''
if entities is not None and not isinstance(entities, (bytes, str, list)):
... |
Filesystems returns details of filesystems with the specified tags.
entities : typing.Sequence[~Entity]
Returns -> FilesystemResults
| Filesystems returns details of filesystems with the specified tags.
entities : typing.Sequence[~Entity]
Returns -> FilesystemResults | [
"Filesystems",
"returns",
"details",
"of",
"filesystems",
"with",
"the",
"specified",
"tags",
".",
"entities",
":",
"typing",
".",
"Sequence",
"[",
"~Entity",
"]",
"Returns",
"-",
">",
"FilesystemResults"
] | async def Filesystems(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='StorageProvisioner',
r... | [
"async",
"def",
"Filesystems",
"(",
"self",
",",
"entities",
"=",
"None",
")",
":",
"if",
"entities",
"is",
"not",
"None",
"and",
"not",
"isinstance",
"(",
"entities",
",",
"(",
"bytes",
",",
"str",
",",
"list",
")",
")",
":",
"raise",
"Exception",
"... | Filesystems returns details of filesystems with the specified tags. | [
"Filesystems",
"returns",
"details",
"of",
"filesystems",
"with",
"the",
"specified",
"tags",
"."
] | [
"'''\n Filesystems returns details of filesystems with the specified tags.\n\n entities : typing.Sequence[~Entity]\n Returns -> FilesystemResults\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... |
059810c3daf85c4d82660c8b92a994e845183ae8 | sed-i/python-libjuju | juju/client/_client4.py | [
"Apache-2.0"
] | Python | InstanceId | <not_specific> | async def InstanceId(self, entities=None):
'''
InstanceId returns the provider specific instance id for each given
machine or an CodeNotProvisioned error, if not set.
entities : typing.Sequence[~Entity]
Returns -> StringResults
'''
if entities is not None and not... |
InstanceId returns the provider specific instance id for each given
machine or an CodeNotProvisioned error, if not set.
entities : typing.Sequence[~Entity]
Returns -> StringResults
| InstanceId returns the provider specific instance id for each given
machine or an CodeNotProvisioned error, if not set.
entities : typing.Sequence[~Entity]
Returns -> StringResults | [
"InstanceId",
"returns",
"the",
"provider",
"specific",
"instance",
"id",
"for",
"each",
"given",
"machine",
"or",
"an",
"CodeNotProvisioned",
"error",
"if",
"not",
"set",
".",
"entities",
":",
"typing",
".",
"Sequence",
"[",
"~Entity",
"]",
"Returns",
"-",
... | async def InstanceId(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='StorageProvisioner',
re... | [
"async",
"def",
"InstanceId",
"(",
"self",
",",
"entities",
"=",
"None",
")",
":",
"if",
"entities",
"is",
"not",
"None",
"and",
"not",
"isinstance",
"(",
"entities",
",",
"(",
"bytes",
",",
"str",
",",
"list",
")",
")",
":",
"raise",
"Exception",
"(... | InstanceId returns the provider specific instance id for each given
machine or an CodeNotProvisioned error, if not set. | [
"InstanceId",
"returns",
"the",
"provider",
"specific",
"instance",
"id",
"for",
"each",
"given",
"machine",
"or",
"an",
"CodeNotProvisioned",
"error",
"if",
"not",
"set",
"."
] | [
"'''\n InstanceId returns the provider specific instance id for each given\n machine or an CodeNotProvisioned error, if not set.\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... |
059810c3daf85c4d82660c8b92a994e845183ae8 | sed-i/python-libjuju | juju/client/_client4.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='StorageProvisioner',
request=... | [
"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... |
059810c3daf85c4d82660c8b92a994e845183ae8 | sed-i/python-libjuju | juju/client/_client4.py | [
"Apache-2.0"
] | Python | RemoveAttachment | <not_specific> | async def RemoveAttachment(self, ids=None):
'''
RemoveAttachments removes the specified machine storage attachments
from state.
ids : typing.Sequence[~MachineStorageId]
Returns -> ErrorResults
'''
if ids is not None and not isinstance(ids, (bytes, str, list)):
... |
RemoveAttachments removes the specified machine storage attachments
from state.
ids : typing.Sequence[~MachineStorageId]
Returns -> ErrorResults
| RemoveAttachments removes the specified machine storage attachments
from state.
| [
"RemoveAttachments",
"removes",
"the",
"specified",
"machine",
"storage",
"attachments",
"from",
"state",
"."
] | async def RemoveAttachment(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='StorageProvisioner',
request='RemoveAttach... | [
"async",
"def",
"RemoveAttachment",
"(",
"self",
",",
"ids",
"=",
"None",
")",
":",
"if",
"ids",
"is",
"not",
"None",
"and",
"not",
"isinstance",
"(",
"ids",
",",
"(",
"bytes",
",",
"str",
",",
"list",
")",
")",
":",
"raise",
"Exception",
"(",
"\"E... | RemoveAttachments removes the specified machine storage attachments
from state. | [
"RemoveAttachments",
"removes",
"the",
"specified",
"machine",
"storage",
"attachments",
"from",
"state",
"."
] | [
"'''\n RemoveAttachments removes the specified machine storage attachments\n from state.\n\n ids : typing.Sequence[~MachineStorageId]\n Returns -> ErrorResults\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": []... |
059810c3daf85c4d82660c8b92a994e845183ae8 | sed-i/python-libjuju | juju/client/_client4.py | [
"Apache-2.0"
] | Python | RemoveFilesystemParams | <not_specific> | async def RemoveFilesystemParams(self, entities=None):
'''
RemoveFilesystemParams returns the parameters for destroying or
releasing the filesystems with the specified tags.
entities : typing.Sequence[~Entity]
Returns -> RemoveFilesystemParamsResults
'''
if entit... |
RemoveFilesystemParams returns the parameters for destroying or
releasing the filesystems with the specified tags.
entities : typing.Sequence[~Entity]
Returns -> RemoveFilesystemParamsResults
| RemoveFilesystemParams returns the parameters for destroying or
releasing the filesystems with the specified tags.
entities : typing.Sequence[~Entity]
Returns -> RemoveFilesystemParamsResults | [
"RemoveFilesystemParams",
"returns",
"the",
"parameters",
"for",
"destroying",
"or",
"releasing",
"the",
"filesystems",
"with",
"the",
"specified",
"tags",
".",
"entities",
":",
"typing",
".",
"Sequence",
"[",
"~Entity",
"]",
"Returns",
"-",
">",
"RemoveFilesystem... | async def RemoveFilesystemParams(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='StorageProvisioner',
... | [
"async",
"def",
"RemoveFilesystemParams",
"(",
"self",
",",
"entities",
"=",
"None",
")",
":",
"if",
"entities",
"is",
"not",
"None",
"and",
"not",
"isinstance",
"(",
"entities",
",",
"(",
"bytes",
",",
"str",
",",
"list",
")",
")",
":",
"raise",
"Exce... | RemoveFilesystemParams returns the parameters for destroying or
releasing the filesystems with the specified tags. | [
"RemoveFilesystemParams",
"returns",
"the",
"parameters",
"for",
"destroying",
"or",
"releasing",
"the",
"filesystems",
"with",
"the",
"specified",
"tags",
"."
] | [
"'''\n RemoveFilesystemParams returns the parameters for destroying or\n releasing the filesystems with the specified tags.\n\n entities : typing.Sequence[~Entity]\n Returns -> RemoveFilesystemParamsResults\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... |
059810c3daf85c4d82660c8b92a994e845183ae8 | sed-i/python-libjuju | juju/client/_client4.py | [
"Apache-2.0"
] | Python | RemoveVolumeParams | <not_specific> | async def RemoveVolumeParams(self, entities=None):
'''
RemoveVolumeParams returns the parameters for destroying
or releasing the volumes with the specified tags.
entities : typing.Sequence[~Entity]
Returns -> RemoveVolumeParamsResults
'''
if entities is not None ... |
RemoveVolumeParams returns the parameters for destroying
or releasing the volumes with the specified tags.
entities : typing.Sequence[~Entity]
Returns -> RemoveVolumeParamsResults
| RemoveVolumeParams returns the parameters for destroying
or releasing the volumes with the specified tags.
entities : typing.Sequence[~Entity]
Returns -> RemoveVolumeParamsResults | [
"RemoveVolumeParams",
"returns",
"the",
"parameters",
"for",
"destroying",
"or",
"releasing",
"the",
"volumes",
"with",
"the",
"specified",
"tags",
".",
"entities",
":",
"typing",
".",
"Sequence",
"[",
"~Entity",
"]",
"Returns",
"-",
">",
"RemoveVolumeParamsResult... | async def RemoveVolumeParams(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='StorageProvisioner',
... | [
"async",
"def",
"RemoveVolumeParams",
"(",
"self",
",",
"entities",
"=",
"None",
")",
":",
"if",
"entities",
"is",
"not",
"None",
"and",
"not",
"isinstance",
"(",
"entities",
",",
"(",
"bytes",
",",
"str",
",",
"list",
")",
")",
":",
"raise",
"Exceptio... | RemoveVolumeParams returns the parameters for destroying
or releasing the volumes with the specified tags. | [
"RemoveVolumeParams",
"returns",
"the",
"parameters",
"for",
"destroying",
"or",
"releasing",
"the",
"volumes",
"with",
"the",
"specified",
"tags",
"."
] | [
"'''\n RemoveVolumeParams returns the parameters for destroying\n or releasing the volumes with the specified tags.\n\n entities : typing.Sequence[~Entity]\n Returns -> RemoveVolumeParamsResults\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... |
059810c3daf85c4d82660c8b92a994e845183ae8 | sed-i/python-libjuju | juju/client/_client4.py | [
"Apache-2.0"
] | Python | SetFilesystemAttachmentInfo | <not_specific> | async def SetFilesystemAttachmentInfo(self, filesystem_attachments=None):
'''
SetFilesystemAttachmentInfo records the details of newly provisioned filesystem
attachments.
filesystem_attachments : typing.Sequence[~FilesystemAttachment]
Returns -> ErrorResults
'''
... |
SetFilesystemAttachmentInfo records the details of newly provisioned filesystem
attachments.
filesystem_attachments : typing.Sequence[~FilesystemAttachment]
Returns -> ErrorResults
| SetFilesystemAttachmentInfo records the details of newly provisioned filesystem
attachments.
| [
"SetFilesystemAttachmentInfo",
"records",
"the",
"details",
"of",
"newly",
"provisioned",
"filesystem",
"attachments",
"."
] | async def SetFilesystemAttachmentInfo(self, filesystem_attachments=None):
if filesystem_attachments is not None and not isinstance(filesystem_attachments, (bytes, str, list)):
raise Exception("Expected filesystem_attachments to be a Sequence, received: {}".format(type(filesystem_attachments)))
... | [
"async",
"def",
"SetFilesystemAttachmentInfo",
"(",
"self",
",",
"filesystem_attachments",
"=",
"None",
")",
":",
"if",
"filesystem_attachments",
"is",
"not",
"None",
"and",
"not",
"isinstance",
"(",
"filesystem_attachments",
",",
"(",
"bytes",
",",
"str",
",",
... | SetFilesystemAttachmentInfo records the details of newly provisioned filesystem
attachments. | [
"SetFilesystemAttachmentInfo",
"records",
"the",
"details",
"of",
"newly",
"provisioned",
"filesystem",
"attachments",
"."
] | [
"'''\n SetFilesystemAttachmentInfo records the details of newly provisioned filesystem\n attachments.\n\n filesystem_attachments : typing.Sequence[~FilesystemAttachment]\n Returns -> ErrorResults\n '''",
"# map input types to rpc msg"
] | [
{
"param": "self",
"type": null
},
{
"param": "filesystem_attachments",
"type": null
}
] | {
"returns": [],
"raises": [],
"params": [
{
"identifier": "self",
"type": null,
"docstring": null,
"docstring_tokens": [],
"default": null,
"is_optional": null
},
{
"identifier": "filesystem_attachments",
"type": null,
"docstring": null,
"do... |
059810c3daf85c4d82660c8b92a994e845183ae8 | sed-i/python-libjuju | juju/client/_client4.py | [
"Apache-2.0"
] | Python | SetFilesystemInfo | <not_specific> | async def SetFilesystemInfo(self, filesystems=None):
'''
SetFilesystemInfo records the details of newly provisioned filesystems.
filesystems : typing.Sequence[~Filesystem]
Returns -> ErrorResults
'''
if filesystems is not None and not isinstance(filesystems, (bytes, str,... |
SetFilesystemInfo records the details of newly provisioned filesystems.
filesystems : typing.Sequence[~Filesystem]
Returns -> ErrorResults
| SetFilesystemInfo records the details of newly provisioned filesystems.
filesystems : typing.Sequence[~Filesystem]
Returns -> ErrorResults | [
"SetFilesystemInfo",
"records",
"the",
"details",
"of",
"newly",
"provisioned",
"filesystems",
".",
"filesystems",
":",
"typing",
".",
"Sequence",
"[",
"~Filesystem",
"]",
"Returns",
"-",
">",
"ErrorResults"
] | async def SetFilesystemInfo(self, filesystems=None):
if filesystems is not None and not isinstance(filesystems, (bytes, str, list)):
raise Exception("Expected filesystems to be a Sequence, received: {}".format(type(filesystems)))
_params = dict()
msg = dict(type='StorageProvisioner',... | [
"async",
"def",
"SetFilesystemInfo",
"(",
"self",
",",
"filesystems",
"=",
"None",
")",
":",
"if",
"filesystems",
"is",
"not",
"None",
"and",
"not",
"isinstance",
"(",
"filesystems",
",",
"(",
"bytes",
",",
"str",
",",
"list",
")",
")",
":",
"raise",
"... | SetFilesystemInfo records the details of newly provisioned filesystems. | [
"SetFilesystemInfo",
"records",
"the",
"details",
"of",
"newly",
"provisioned",
"filesystems",
"."
] | [
"'''\n SetFilesystemInfo records the details of newly provisioned filesystems.\n\n filesystems : typing.Sequence[~Filesystem]\n Returns -> ErrorResults\n '''",
"# map input types to rpc msg"
] | [
{
"param": "self",
"type": null
},
{
"param": "filesystems",
"type": null
}
] | {
"returns": [],
"raises": [],
"params": [
{
"identifier": "self",
"type": null,
"docstring": null,
"docstring_tokens": [],
"default": null,
"is_optional": null
},
{
"identifier": "filesystems",
"type": null,
"docstring": null,
"docstring_tok... |
059810c3daf85c4d82660c8b92a994e845183ae8 | sed-i/python-libjuju | juju/client/_client4.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='StorageProvisioner',
req... | [
"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... |
059810c3daf85c4d82660c8b92a994e845183ae8 | sed-i/python-libjuju | juju/client/_client4.py | [
"Apache-2.0"
] | Python | SetVolumeAttachmentInfo | <not_specific> | async def SetVolumeAttachmentInfo(self, volume_attachments=None):
'''
SetVolumeAttachmentInfo records the details of newly provisioned volume
attachments.
volume_attachments : typing.Sequence[~VolumeAttachment]
Returns -> ErrorResults
'''
if volume_attachments is... |
SetVolumeAttachmentInfo records the details of newly provisioned volume
attachments.
volume_attachments : typing.Sequence[~VolumeAttachment]
Returns -> ErrorResults
| SetVolumeAttachmentInfo records the details of newly provisioned volume
attachments.
| [
"SetVolumeAttachmentInfo",
"records",
"the",
"details",
"of",
"newly",
"provisioned",
"volume",
"attachments",
"."
] | async def SetVolumeAttachmentInfo(self, volume_attachments=None):
if volume_attachments is not None and not isinstance(volume_attachments, (bytes, str, list)):
raise Exception("Expected volume_attachments to be a Sequence, received: {}".format(type(volume_attachments)))
_params = dict()
... | [
"async",
"def",
"SetVolumeAttachmentInfo",
"(",
"self",
",",
"volume_attachments",
"=",
"None",
")",
":",
"if",
"volume_attachments",
"is",
"not",
"None",
"and",
"not",
"isinstance",
"(",
"volume_attachments",
",",
"(",
"bytes",
",",
"str",
",",
"list",
")",
... | SetVolumeAttachmentInfo records the details of newly provisioned volume
attachments. | [
"SetVolumeAttachmentInfo",
"records",
"the",
"details",
"of",
"newly",
"provisioned",
"volume",
"attachments",
"."
] | [
"'''\n SetVolumeAttachmentInfo records the details of newly provisioned volume\n attachments.\n\n volume_attachments : typing.Sequence[~VolumeAttachment]\n Returns -> ErrorResults\n '''",
"# map input types to rpc msg"
] | [
{
"param": "self",
"type": null
},
{
"param": "volume_attachments",
"type": null
}
] | {
"returns": [],
"raises": [],
"params": [
{
"identifier": "self",
"type": null,
"docstring": null,
"docstring_tokens": [],
"default": null,
"is_optional": null
},
{
"identifier": "volume_attachments",
"type": null,
"docstring": null,
"docstr... |
059810c3daf85c4d82660c8b92a994e845183ae8 | sed-i/python-libjuju | juju/client/_client4.py | [
"Apache-2.0"
] | Python | SetVolumeInfo | <not_specific> | async def SetVolumeInfo(self, volumes=None):
'''
SetVolumeInfo records the details of newly provisioned volumes.
volumes : typing.Sequence[~Volume]
Returns -> ErrorResults
'''
if volumes is not None and not isinstance(volumes, (bytes, str, list)):
raise Excep... |
SetVolumeInfo records the details of newly provisioned volumes.
volumes : typing.Sequence[~Volume]
Returns -> ErrorResults
| SetVolumeInfo records the details of newly provisioned volumes.
volumes : typing.Sequence[~Volume]
Returns -> ErrorResults | [
"SetVolumeInfo",
"records",
"the",
"details",
"of",
"newly",
"provisioned",
"volumes",
".",
"volumes",
":",
"typing",
".",
"Sequence",
"[",
"~Volume",
"]",
"Returns",
"-",
">",
"ErrorResults"
] | async def SetVolumeInfo(self, volumes=None):
if volumes is not None and not isinstance(volumes, (bytes, str, list)):
raise Exception("Expected volumes to be a Sequence, received: {}".format(type(volumes)))
_params = dict()
msg = dict(type='StorageProvisioner',
requ... | [
"async",
"def",
"SetVolumeInfo",
"(",
"self",
",",
"volumes",
"=",
"None",
")",
":",
"if",
"volumes",
"is",
"not",
"None",
"and",
"not",
"isinstance",
"(",
"volumes",
",",
"(",
"bytes",
",",
"str",
",",
"list",
")",
")",
":",
"raise",
"Exception",
"(... | SetVolumeInfo records the details of newly provisioned volumes. | [
"SetVolumeInfo",
"records",
"the",
"details",
"of",
"newly",
"provisioned",
"volumes",
"."
] | [
"'''\n SetVolumeInfo records the details of newly provisioned volumes.\n\n volumes : typing.Sequence[~Volume]\n Returns -> ErrorResults\n '''",
"# map input types to rpc msg"
] | [
{
"param": "self",
"type": null
},
{
"param": "volumes",
"type": null
}
] | {
"returns": [],
"raises": [],
"params": [
{
"identifier": "self",
"type": null,
"docstring": null,
"docstring_tokens": [],
"default": null,
"is_optional": null
},
{
"identifier": "volumes",
"type": null,
"docstring": null,
"docstring_tokens"... |
059810c3daf85c4d82660c8b92a994e845183ae8 | sed-i/python-libjuju | juju/client/_client4.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='StorageProvisioner',
... | [
"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... |
059810c3daf85c4d82660c8b92a994e845183ae8 | sed-i/python-libjuju | juju/client/_client4.py | [
"Apache-2.0"
] | Python | VolumeAttachmentParams | <not_specific> | async def VolumeAttachmentParams(self, ids=None):
'''
VolumeAttachmentParams returns the parameters for creating the volume
attachments with the specified IDs.
ids : typing.Sequence[~MachineStorageId]
Returns -> VolumeAttachmentParamsResults
'''
if ids is not Non... |
VolumeAttachmentParams returns the parameters for creating the volume
attachments with the specified IDs.
ids : typing.Sequence[~MachineStorageId]
Returns -> VolumeAttachmentParamsResults
| VolumeAttachmentParams returns the parameters for creating the volume
attachments with the specified IDs.
| [
"VolumeAttachmentParams",
"returns",
"the",
"parameters",
"for",
"creating",
"the",
"volume",
"attachments",
"with",
"the",
"specified",
"IDs",
"."
] | async def VolumeAttachmentParams(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='StorageProvisioner',
request='Volume... | [
"async",
"def",
"VolumeAttachmentParams",
"(",
"self",
",",
"ids",
"=",
"None",
")",
":",
"if",
"ids",
"is",
"not",
"None",
"and",
"not",
"isinstance",
"(",
"ids",
",",
"(",
"bytes",
",",
"str",
",",
"list",
")",
")",
":",
"raise",
"Exception",
"(",
... | VolumeAttachmentParams returns the parameters for creating the volume
attachments with the specified IDs. | [
"VolumeAttachmentParams",
"returns",
"the",
"parameters",
"for",
"creating",
"the",
"volume",
"attachments",
"with",
"the",
"specified",
"IDs",
"."
] | [
"'''\n VolumeAttachmentParams returns the parameters for creating the volume\n attachments with the specified IDs.\n\n ids : typing.Sequence[~MachineStorageId]\n Returns -> VolumeAttachmentParamsResults\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": []... |
059810c3daf85c4d82660c8b92a994e845183ae8 | sed-i/python-libjuju | juju/client/_client4.py | [
"Apache-2.0"
] | Python | VolumeAttachmentPlans | <not_specific> | async def VolumeAttachmentPlans(self, ids=None):
'''
VolumeAttachmentPlans returns details of volume attachment plans with the specified IDs.
ids : typing.Sequence[~MachineStorageId]
Returns -> VolumeAttachmentPlanResults
'''
if ids is not None and not isinstance(ids, (b... |
VolumeAttachmentPlans returns details of volume attachment plans with the specified IDs.
ids : typing.Sequence[~MachineStorageId]
Returns -> VolumeAttachmentPlanResults
| VolumeAttachmentPlans returns details of volume attachment plans with the specified IDs. | [
"VolumeAttachmentPlans",
"returns",
"details",
"of",
"volume",
"attachment",
"plans",
"with",
"the",
"specified",
"IDs",
"."
] | async def VolumeAttachmentPlans(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='StorageProvisioner',
request='VolumeA... | [
"async",
"def",
"VolumeAttachmentPlans",
"(",
"self",
",",
"ids",
"=",
"None",
")",
":",
"if",
"ids",
"is",
"not",
"None",
"and",
"not",
"isinstance",
"(",
"ids",
",",
"(",
"bytes",
",",
"str",
",",
"list",
")",
")",
":",
"raise",
"Exception",
"(",
... | VolumeAttachmentPlans returns details of volume attachment plans with the specified IDs. | [
"VolumeAttachmentPlans",
"returns",
"details",
"of",
"volume",
"attachment",
"plans",
"with",
"the",
"specified",
"IDs",
"."
] | [
"'''\n VolumeAttachmentPlans returns details of volume attachment plans with the specified IDs.\n\n ids : typing.Sequence[~MachineStorageId]\n Returns -> VolumeAttachmentPlanResults\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": []... |
059810c3daf85c4d82660c8b92a994e845183ae8 | sed-i/python-libjuju | juju/client/_client4.py | [
"Apache-2.0"
] | Python | VolumeAttachments | <not_specific> | async def VolumeAttachments(self, ids=None):
'''
VolumeAttachments returns details of volume attachments with the specified IDs.
ids : typing.Sequence[~MachineStorageId]
Returns -> VolumeAttachmentResults
'''
if ids is not None and not isinstance(ids, (bytes, str, list))... |
VolumeAttachments returns details of volume attachments with the specified IDs.
ids : typing.Sequence[~MachineStorageId]
Returns -> VolumeAttachmentResults
| VolumeAttachments returns details of volume attachments with the specified IDs. | [
"VolumeAttachments",
"returns",
"details",
"of",
"volume",
"attachments",
"with",
"the",
"specified",
"IDs",
"."
] | async def VolumeAttachments(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='StorageProvisioner',
request='VolumeAttac... | [
"async",
"def",
"VolumeAttachments",
"(",
"self",
",",
"ids",
"=",
"None",
")",
":",
"if",
"ids",
"is",
"not",
"None",
"and",
"not",
"isinstance",
"(",
"ids",
",",
"(",
"bytes",
",",
"str",
",",
"list",
")",
")",
":",
"raise",
"Exception",
"(",
"\"... | VolumeAttachments returns details of volume attachments with the specified IDs. | [
"VolumeAttachments",
"returns",
"details",
"of",
"volume",
"attachments",
"with",
"the",
"specified",
"IDs",
"."
] | [
"'''\n VolumeAttachments returns details of volume attachments with the specified IDs.\n\n ids : typing.Sequence[~MachineStorageId]\n Returns -> VolumeAttachmentResults\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": []... |
059810c3daf85c4d82660c8b92a994e845183ae8 | sed-i/python-libjuju | juju/client/_client4.py | [
"Apache-2.0"
] | Python | VolumeBlockDevices | <not_specific> | async def VolumeBlockDevices(self, ids=None):
'''
VolumeBlockDevices returns details of the block devices corresponding to the
volume attachments with the specified IDs.
ids : typing.Sequence[~MachineStorageId]
Returns -> BlockDeviceResults
'''
if ids is not None... |
VolumeBlockDevices returns details of the block devices corresponding to the
volume attachments with the specified IDs.
ids : typing.Sequence[~MachineStorageId]
Returns -> BlockDeviceResults
| VolumeBlockDevices returns details of the block devices corresponding to the
volume attachments with the specified IDs.
| [
"VolumeBlockDevices",
"returns",
"details",
"of",
"the",
"block",
"devices",
"corresponding",
"to",
"the",
"volume",
"attachments",
"with",
"the",
"specified",
"IDs",
"."
] | async def VolumeBlockDevices(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='StorageProvisioner',
request='VolumeBloc... | [
"async",
"def",
"VolumeBlockDevices",
"(",
"self",
",",
"ids",
"=",
"None",
")",
":",
"if",
"ids",
"is",
"not",
"None",
"and",
"not",
"isinstance",
"(",
"ids",
",",
"(",
"bytes",
",",
"str",
",",
"list",
")",
")",
":",
"raise",
"Exception",
"(",
"\... | VolumeBlockDevices returns details of the block devices corresponding to the
volume attachments with the specified IDs. | [
"VolumeBlockDevices",
"returns",
"details",
"of",
"the",
"block",
"devices",
"corresponding",
"to",
"the",
"volume",
"attachments",
"with",
"the",
"specified",
"IDs",
"."
] | [
"'''\n VolumeBlockDevices returns details of the block devices corresponding to the\n volume attachments with the specified IDs.\n\n ids : typing.Sequence[~MachineStorageId]\n Returns -> BlockDeviceResults\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": []... |
059810c3daf85c4d82660c8b92a994e845183ae8 | sed-i/python-libjuju | juju/client/_client4.py | [
"Apache-2.0"
] | Python | VolumeParams | <not_specific> | async def VolumeParams(self, entities=None):
'''
VolumeParams returns the parameters for creating or destroying
the volumes with the specified tags.
entities : typing.Sequence[~Entity]
Returns -> VolumeParamsResults
'''
if entities is not None and not isinstance(... |
VolumeParams returns the parameters for creating or destroying
the volumes with the specified tags.
entities : typing.Sequence[~Entity]
Returns -> VolumeParamsResults
| VolumeParams returns the parameters for creating or destroying
the volumes with the specified tags.
entities : typing.Sequence[~Entity]
Returns -> VolumeParamsResults | [
"VolumeParams",
"returns",
"the",
"parameters",
"for",
"creating",
"or",
"destroying",
"the",
"volumes",
"with",
"the",
"specified",
"tags",
".",
"entities",
":",
"typing",
".",
"Sequence",
"[",
"~Entity",
"]",
"Returns",
"-",
">",
"VolumeParamsResults"
] | async def VolumeParams(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='StorageProvisioner',
... | [
"async",
"def",
"VolumeParams",
"(",
"self",
",",
"entities",
"=",
"None",
")",
":",
"if",
"entities",
"is",
"not",
"None",
"and",
"not",
"isinstance",
"(",
"entities",
",",
"(",
"bytes",
",",
"str",
",",
"list",
")",
")",
":",
"raise",
"Exception",
... | VolumeParams returns the parameters for creating or destroying
the volumes with the specified tags. | [
"VolumeParams",
"returns",
"the",
"parameters",
"for",
"creating",
"or",
"destroying",
"the",
"volumes",
"with",
"the",
"specified",
"tags",
"."
] | [
"'''\n VolumeParams returns the parameters for creating or destroying\n the volumes with the specified tags.\n\n entities : typing.Sequence[~Entity]\n Returns -> VolumeParamsResults\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... |
059810c3daf85c4d82660c8b92a994e845183ae8 | sed-i/python-libjuju | juju/client/_client4.py | [
"Apache-2.0"
] | Python | Volumes | <not_specific> | async def Volumes(self, entities=None):
'''
Volumes returns details of volumes with the specified tags.
entities : typing.Sequence[~Entity]
Returns -> VolumeResults
'''
if entities is not None and not isinstance(entities, (bytes, str, list)):
raise Exception(... |
Volumes returns details of volumes with the specified tags.
entities : typing.Sequence[~Entity]
Returns -> VolumeResults
| Volumes returns details of volumes with the specified tags.
entities : typing.Sequence[~Entity]
Returns -> VolumeResults | [
"Volumes",
"returns",
"details",
"of",
"volumes",
"with",
"the",
"specified",
"tags",
".",
"entities",
":",
"typing",
".",
"Sequence",
"[",
"~Entity",
"]",
"Returns",
"-",
">",
"VolumeResults"
] | async def Volumes(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='StorageProvisioner',
reque... | [
"async",
"def",
"Volumes",
"(",
"self",
",",
"entities",
"=",
"None",
")",
":",
"if",
"entities",
"is",
"not",
"None",
"and",
"not",
"isinstance",
"(",
"entities",
",",
"(",
"bytes",
",",
"str",
",",
"list",
")",
")",
":",
"raise",
"Exception",
"(",
... | Volumes returns details of volumes with the specified tags. | [
"Volumes",
"returns",
"details",
"of",
"volumes",
"with",
"the",
"specified",
"tags",
"."
] | [
"'''\n Volumes returns details of volumes with the specified tags.\n\n entities : typing.Sequence[~Entity]\n Returns -> VolumeResults\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... |
059810c3daf85c4d82660c8b92a994e845183ae8 | sed-i/python-libjuju | juju/client/_client4.py | [
"Apache-2.0"
] | Python | WatchApplications | <not_specific> | async def WatchApplications(self):
'''
WatchApplications starts a StringsWatcher to watch CAAS applications
deployed to this model.
Returns -> StringsWatchResult
'''
# map input types to rpc msg
_params = dict()
msg = dict(type='StorageProvisioner',
... |
WatchApplications starts a StringsWatcher to watch CAAS applications
deployed to this model.
Returns -> StringsWatchResult
| WatchApplications starts a StringsWatcher to watch CAAS applications
deployed to this model.
| [
"WatchApplications",
"starts",
"a",
"StringsWatcher",
"to",
"watch",
"CAAS",
"applications",
"deployed",
"to",
"this",
"model",
"."
] | async def WatchApplications(self):
_params = dict()
msg = dict(type='StorageProvisioner',
request='WatchApplications',
version=4,
params=_params)
reply = await self.rpc(msg)
return reply | [
"async",
"def",
"WatchApplications",
"(",
"self",
")",
":",
"_params",
"=",
"dict",
"(",
")",
"msg",
"=",
"dict",
"(",
"type",
"=",
"'StorageProvisioner'",
",",
"request",
"=",
"'WatchApplications'",
",",
"version",
"=",
"4",
",",
"params",
"=",
"_params",... | WatchApplications starts a StringsWatcher to watch CAAS applications
deployed to this model. | [
"WatchApplications",
"starts",
"a",
"StringsWatcher",
"to",
"watch",
"CAAS",
"applications",
"deployed",
"to",
"this",
"model",
"."
] | [
"'''\n WatchApplications starts a StringsWatcher to watch CAAS applications\n deployed to this model.\n\n\n Returns -> StringsWatchResult\n '''",
"# map input types to rpc msg"
] | [
{
"param": "self",
"type": null
}
] | {
"returns": [],
"raises": [],
"params": [
{
"identifier": "self",
"type": null,
"docstring": null,
"docstring_tokens": [],
"default": null,
"is_optional": null
}
],
"outlier_params": [],
"others": []
} |
059810c3daf85c4d82660c8b92a994e845183ae8 | sed-i/python-libjuju | juju/client/_client4.py | [
"Apache-2.0"
] | Python | WatchBlockDevices | <not_specific> | async def WatchBlockDevices(self, entities=None):
'''
WatchBlockDevices watches for changes to the specified machines' block devices.
entities : typing.Sequence[~Entity]
Returns -> NotifyWatchResults
'''
if entities is not None and not isinstance(entities, (bytes, str, l... |
WatchBlockDevices watches for changes to the specified machines' block devices.
entities : typing.Sequence[~Entity]
Returns -> NotifyWatchResults
| WatchBlockDevices watches for changes to the specified machines' block devices.
entities : typing.Sequence[~Entity]
Returns -> NotifyWatchResults | [
"WatchBlockDevices",
"watches",
"for",
"changes",
"to",
"the",
"specified",
"machines",
"'",
"block",
"devices",
".",
"entities",
":",
"typing",
".",
"Sequence",
"[",
"~Entity",
"]",
"Returns",
"-",
">",
"NotifyWatchResults"
] | async def WatchBlockDevices(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='StorageProvisioner',
... | [
"async",
"def",
"WatchBlockDevices",
"(",
"self",
",",
"entities",
"=",
"None",
")",
":",
"if",
"entities",
"is",
"not",
"None",
"and",
"not",
"isinstance",
"(",
"entities",
",",
"(",
"bytes",
",",
"str",
",",
"list",
")",
")",
":",
"raise",
"Exception... | WatchBlockDevices watches for changes to the specified machines' block devices. | [
"WatchBlockDevices",
"watches",
"for",
"changes",
"to",
"the",
"specified",
"machines",
"'",
"block",
"devices",
"."
] | [
"'''\n WatchBlockDevices watches for changes to the specified machines' block devices.\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... |
059810c3daf85c4d82660c8b92a994e845183ae8 | sed-i/python-libjuju | juju/client/_client4.py | [
"Apache-2.0"
] | Python | WatchFilesystemAttachments | <not_specific> | async def WatchFilesystemAttachments(self, entities=None):
'''
WatchFilesystemAttachments watches for changes to filesystem attachments
scoped to the entity with the tag passed to NewState.
entities : typing.Sequence[~Entity]
Returns -> MachineStorageIdsWatchResults
'''
... |
WatchFilesystemAttachments watches for changes to filesystem attachments
scoped to the entity with the tag passed to NewState.
entities : typing.Sequence[~Entity]
Returns -> MachineStorageIdsWatchResults
| WatchFilesystemAttachments watches for changes to filesystem attachments
scoped to the entity with the tag passed to NewState.
entities : typing.Sequence[~Entity]
Returns -> MachineStorageIdsWatchResults | [
"WatchFilesystemAttachments",
"watches",
"for",
"changes",
"to",
"filesystem",
"attachments",
"scoped",
"to",
"the",
"entity",
"with",
"the",
"tag",
"passed",
"to",
"NewState",
".",
"entities",
":",
"typing",
".",
"Sequence",
"[",
"~Entity",
"]",
"Returns",
"-",... | async def WatchFilesystemAttachments(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='StorageProvisioner',
... | [
"async",
"def",
"WatchFilesystemAttachments",
"(",
"self",
",",
"entities",
"=",
"None",
")",
":",
"if",
"entities",
"is",
"not",
"None",
"and",
"not",
"isinstance",
"(",
"entities",
",",
"(",
"bytes",
",",
"str",
",",
"list",
")",
")",
":",
"raise",
"... | WatchFilesystemAttachments watches for changes to filesystem attachments
scoped to the entity with the tag passed to NewState. | [
"WatchFilesystemAttachments",
"watches",
"for",
"changes",
"to",
"filesystem",
"attachments",
"scoped",
"to",
"the",
"entity",
"with",
"the",
"tag",
"passed",
"to",
"NewState",
"."
] | [
"'''\n WatchFilesystemAttachments watches for changes to filesystem attachments\n scoped to the entity with the tag passed to NewState.\n\n entities : typing.Sequence[~Entity]\n Returns -> MachineStorageIdsWatchResults\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... |
059810c3daf85c4d82660c8b92a994e845183ae8 | sed-i/python-libjuju | juju/client/_client4.py | [
"Apache-2.0"
] | Python | WatchFilesystems | <not_specific> | async def WatchFilesystems(self, entities=None):
'''
WatchFilesystems watches for changes to filesystems scoped
to the entity with the tag passed to NewState.
entities : typing.Sequence[~Entity]
Returns -> StringsWatchResults
'''
if entities is not None and not i... |
WatchFilesystems watches for changes to filesystems scoped
to the entity with the tag passed to NewState.
entities : typing.Sequence[~Entity]
Returns -> StringsWatchResults
| WatchFilesystems watches for changes to filesystems scoped
to the entity with the tag passed to NewState.
entities : typing.Sequence[~Entity]
Returns -> StringsWatchResults | [
"WatchFilesystems",
"watches",
"for",
"changes",
"to",
"filesystems",
"scoped",
"to",
"the",
"entity",
"with",
"the",
"tag",
"passed",
"to",
"NewState",
".",
"entities",
":",
"typing",
".",
"Sequence",
"[",
"~Entity",
"]",
"Returns",
"-",
">",
"StringsWatchRes... | async def WatchFilesystems(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='StorageProvisioner',
... | [
"async",
"def",
"WatchFilesystems",
"(",
"self",
",",
"entities",
"=",
"None",
")",
":",
"if",
"entities",
"is",
"not",
"None",
"and",
"not",
"isinstance",
"(",
"entities",
",",
"(",
"bytes",
",",
"str",
",",
"list",
")",
")",
":",
"raise",
"Exception"... | WatchFilesystems watches for changes to filesystems scoped
to the entity with the tag passed to NewState. | [
"WatchFilesystems",
"watches",
"for",
"changes",
"to",
"filesystems",
"scoped",
"to",
"the",
"entity",
"with",
"the",
"tag",
"passed",
"to",
"NewState",
"."
] | [
"'''\n WatchFilesystems watches for changes to filesystems scoped\n to the entity with the tag passed to NewState.\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... |
059810c3daf85c4d82660c8b92a994e845183ae8 | sed-i/python-libjuju | juju/client/_client4.py | [
"Apache-2.0"
] | Python | WatchMachines | <not_specific> | async def WatchMachines(self, entities=None):
'''
WatchMachines watches for changes to the specified machines.
entities : typing.Sequence[~Entity]
Returns -> NotifyWatchResults
'''
if entities is not None and not isinstance(entities, (bytes, str, list)):
rais... |
WatchMachines watches for changes to the specified machines.
entities : typing.Sequence[~Entity]
Returns -> NotifyWatchResults
| WatchMachines watches for changes to the specified machines.
entities : typing.Sequence[~Entity]
Returns -> NotifyWatchResults | [
"WatchMachines",
"watches",
"for",
"changes",
"to",
"the",
"specified",
"machines",
".",
"entities",
":",
"typing",
".",
"Sequence",
"[",
"~Entity",
"]",
"Returns",
"-",
">",
"NotifyWatchResults"
] | async def WatchMachines(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='StorageProvisioner',
... | [
"async",
"def",
"WatchMachines",
"(",
"self",
",",
"entities",
"=",
"None",
")",
":",
"if",
"entities",
"is",
"not",
"None",
"and",
"not",
"isinstance",
"(",
"entities",
",",
"(",
"bytes",
",",
"str",
",",
"list",
")",
")",
":",
"raise",
"Exception",
... | WatchMachines watches for changes to the specified machines. | [
"WatchMachines",
"watches",
"for",
"changes",
"to",
"the",
"specified",
"machines",
"."
] | [
"'''\n WatchMachines watches for changes to the specified machines.\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... |
059810c3daf85c4d82660c8b92a994e845183ae8 | sed-i/python-libjuju | juju/client/_client4.py | [
"Apache-2.0"
] | Python | WatchVolumeAttachmentPlans | <not_specific> | async def WatchVolumeAttachmentPlans(self, entities=None):
'''
WatchVolumeAttachmentPlans watches for changes to volume attachments for a machine for the purpose of allowing
that machine to run any initialization needed, for that volume to actually appear as a block device (ie: iSCSI)
e... |
WatchVolumeAttachmentPlans watches for changes to volume attachments for a machine for the purpose of allowing
that machine to run any initialization needed, for that volume to actually appear as a block device (ie: iSCSI)
entities : typing.Sequence[~Entity]
Returns -> MachineStorageId... | WatchVolumeAttachmentPlans watches for changes to volume attachments for a machine for the purpose of allowing
that machine to run any initialization needed, for that volume to actually appear as a block device
entities : typing.Sequence[~Entity]
Returns -> MachineStorageIdsWatchResults | [
"WatchVolumeAttachmentPlans",
"watches",
"for",
"changes",
"to",
"volume",
"attachments",
"for",
"a",
"machine",
"for",
"the",
"purpose",
"of",
"allowing",
"that",
"machine",
"to",
"run",
"any",
"initialization",
"needed",
"for",
"that",
"volume",
"to",
"actually"... | async def WatchVolumeAttachmentPlans(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='StorageProvisioner',
... | [
"async",
"def",
"WatchVolumeAttachmentPlans",
"(",
"self",
",",
"entities",
"=",
"None",
")",
":",
"if",
"entities",
"is",
"not",
"None",
"and",
"not",
"isinstance",
"(",
"entities",
",",
"(",
"bytes",
",",
"str",
",",
"list",
")",
")",
":",
"raise",
"... | WatchVolumeAttachmentPlans watches for changes to volume attachments for a machine for the purpose of allowing
that machine to run any initialization needed, for that volume to actually appear as a block device (ie: iSCSI) | [
"WatchVolumeAttachmentPlans",
"watches",
"for",
"changes",
"to",
"volume",
"attachments",
"for",
"a",
"machine",
"for",
"the",
"purpose",
"of",
"allowing",
"that",
"machine",
"to",
"run",
"any",
"initialization",
"needed",
"for",
"that",
"volume",
"to",
"actually"... | [
"'''\n WatchVolumeAttachmentPlans watches for changes to volume attachments for a machine for the purpose of allowing\n that machine to run any initialization needed, for that volume to actually appear as a block device (ie: iSCSI)\n\n entities : typing.Sequence[~Entity]\n Returns -> Mac... | [
{
"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... |
059810c3daf85c4d82660c8b92a994e845183ae8 | sed-i/python-libjuju | juju/client/_client4.py | [
"Apache-2.0"
] | Python | WatchVolumeAttachments | <not_specific> | async def WatchVolumeAttachments(self, entities=None):
'''
WatchVolumeAttachments watches for changes to volume attachments scoped to
the entity with the tag passed to NewState.
entities : typing.Sequence[~Entity]
Returns -> MachineStorageIdsWatchResults
'''
if e... |
WatchVolumeAttachments watches for changes to volume attachments scoped to
the entity with the tag passed to NewState.
entities : typing.Sequence[~Entity]
Returns -> MachineStorageIdsWatchResults
| WatchVolumeAttachments watches for changes to volume attachments scoped to
the entity with the tag passed to NewState.
entities : typing.Sequence[~Entity]
Returns -> MachineStorageIdsWatchResults | [
"WatchVolumeAttachments",
"watches",
"for",
"changes",
"to",
"volume",
"attachments",
"scoped",
"to",
"the",
"entity",
"with",
"the",
"tag",
"passed",
"to",
"NewState",
".",
"entities",
":",
"typing",
".",
"Sequence",
"[",
"~Entity",
"]",
"Returns",
"-",
">",
... | async def WatchVolumeAttachments(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='StorageProvisioner',
... | [
"async",
"def",
"WatchVolumeAttachments",
"(",
"self",
",",
"entities",
"=",
"None",
")",
":",
"if",
"entities",
"is",
"not",
"None",
"and",
"not",
"isinstance",
"(",
"entities",
",",
"(",
"bytes",
",",
"str",
",",
"list",
")",
")",
":",
"raise",
"Exce... | WatchVolumeAttachments watches for changes to volume attachments scoped to
the entity with the tag passed to NewState. | [
"WatchVolumeAttachments",
"watches",
"for",
"changes",
"to",
"volume",
"attachments",
"scoped",
"to",
"the",
"entity",
"with",
"the",
"tag",
"passed",
"to",
"NewState",
"."
] | [
"'''\n WatchVolumeAttachments watches for changes to volume attachments scoped to\n the entity with the tag passed to NewState.\n\n entities : typing.Sequence[~Entity]\n Returns -> MachineStorageIdsWatchResults\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... |
059810c3daf85c4d82660c8b92a994e845183ae8 | sed-i/python-libjuju | juju/client/_client4.py | [
"Apache-2.0"
] | Python | WatchVolumes | <not_specific> | async def WatchVolumes(self, entities=None):
'''
WatchVolumes watches for changes to volumes scoped to the
entity with the tag passed to NewState.
entities : typing.Sequence[~Entity]
Returns -> StringsWatchResults
'''
if entities is not None and not isinstance(en... |
WatchVolumes watches for changes to volumes scoped to the
entity with the tag passed to NewState.
entities : typing.Sequence[~Entity]
Returns -> StringsWatchResults
| WatchVolumes watches for changes to volumes scoped to the
entity with the tag passed to NewState.
entities : typing.Sequence[~Entity]
Returns -> StringsWatchResults | [
"WatchVolumes",
"watches",
"for",
"changes",
"to",
"volumes",
"scoped",
"to",
"the",
"entity",
"with",
"the",
"tag",
"passed",
"to",
"NewState",
".",
"entities",
":",
"typing",
".",
"Sequence",
"[",
"~Entity",
"]",
"Returns",
"-",
">",
"StringsWatchResults"
] | async def WatchVolumes(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='StorageProvisioner',
... | [
"async",
"def",
"WatchVolumes",
"(",
"self",
",",
"entities",
"=",
"None",
")",
":",
"if",
"entities",
"is",
"not",
"None",
"and",
"not",
"isinstance",
"(",
"entities",
",",
"(",
"bytes",
",",
"str",
",",
"list",
")",
")",
":",
"raise",
"Exception",
... | WatchVolumes watches for changes to volumes scoped to the
entity with the tag passed to NewState. | [
"WatchVolumes",
"watches",
"for",
"changes",
"to",
"volumes",
"scoped",
"to",
"the",
"entity",
"with",
"the",
"tag",
"passed",
"to",
"NewState",
"."
] | [
"'''\n WatchVolumes watches for changes to volumes scoped to the\n entity with the tag passed to NewState.\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... |
059810c3daf85c4d82660c8b92a994e845183ae8 | sed-i/python-libjuju | juju/client/_client4.py | [
"Apache-2.0"
] | Python | AddSubnets | <not_specific> | async def AddSubnets(self, subnets=None):
'''
AddSubnets adds existing subnets to Juju.
subnets : typing.Sequence[~AddSubnetParams]
Returns -> ErrorResults
'''
if subnets is not None and not isinstance(subnets, (bytes, str, list)):
raise Exception("Expected s... |
AddSubnets adds existing subnets to Juju.
subnets : typing.Sequence[~AddSubnetParams]
Returns -> ErrorResults
| AddSubnets adds existing subnets to Juju. | [
"AddSubnets",
"adds",
"existing",
"subnets",
"to",
"Juju",
"."
] | async def AddSubnets(self, subnets=None):
if subnets is not None and not isinstance(subnets, (bytes, str, list)):
raise Exception("Expected subnets to be a Sequence, received: {}".format(type(subnets)))
_params = dict()
msg = dict(type='Subnets',
request='AddSubnet... | [
"async",
"def",
"AddSubnets",
"(",
"self",
",",
"subnets",
"=",
"None",
")",
":",
"if",
"subnets",
"is",
"not",
"None",
"and",
"not",
"isinstance",
"(",
"subnets",
",",
"(",
"bytes",
",",
"str",
",",
"list",
")",
")",
":",
"raise",
"Exception",
"(",
... | AddSubnets adds existing subnets to Juju. | [
"AddSubnets",
"adds",
"existing",
"subnets",
"to",
"Juju",
"."
] | [
"'''\n AddSubnets adds existing subnets to Juju.\n\n subnets : typing.Sequence[~AddSubnetParams]\n Returns -> ErrorResults\n '''",
"# map input types to rpc msg"
] | [
{
"param": "self",
"type": null
},
{
"param": "subnets",
"type": null
}
] | {
"returns": [],
"raises": [],
"params": [
{
"identifier": "self",
"type": null,
"docstring": null,
"docstring_tokens": [],
"default": null,
"is_optional": null
},
{
"identifier": "subnets",
"type": null,
"docstring": null,
"docstring_tokens"... |
059810c3daf85c4d82660c8b92a994e845183ae8 | sed-i/python-libjuju | juju/client/_client4.py | [
"Apache-2.0"
] | Python | AllZones | <not_specific> | async def AllZones(self):
'''
AllZones returns all availability zones known to Juju. If a
zone is unusable, unavailable, or deprecated the Available
field will be false.
Returns -> ZoneResults
'''
# map input types to rpc msg
_params = dict()
ms... |
AllZones returns all availability zones known to Juju. If a
zone is unusable, unavailable, or deprecated the Available
field will be false.
Returns -> ZoneResults
| AllZones returns all availability zones known to Juju. If a
zone is unusable, unavailable, or deprecated the Available
field will be false.
| [
"AllZones",
"returns",
"all",
"availability",
"zones",
"known",
"to",
"Juju",
".",
"If",
"a",
"zone",
"is",
"unusable",
"unavailable",
"or",
"deprecated",
"the",
"Available",
"field",
"will",
"be",
"false",
"."
] | async def AllZones(self):
_params = dict()
msg = dict(type='Subnets',
request='AllZones',
version=4,
params=_params)
reply = await self.rpc(msg)
return reply | [
"async",
"def",
"AllZones",
"(",
"self",
")",
":",
"_params",
"=",
"dict",
"(",
")",
"msg",
"=",
"dict",
"(",
"type",
"=",
"'Subnets'",
",",
"request",
"=",
"'AllZones'",
",",
"version",
"=",
"4",
",",
"params",
"=",
"_params",
")",
"reply",
"=",
"... | AllZones returns all availability zones known to Juju. | [
"AllZones",
"returns",
"all",
"availability",
"zones",
"known",
"to",
"Juju",
"."
] | [
"'''\n AllZones returns all availability zones known to Juju. If a\n zone is unusable, unavailable, or deprecated the Available\n field will be false.\n\n\n Returns -> ZoneResults\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": []
} |
059810c3daf85c4d82660c8b92a994e845183ae8 | sed-i/python-libjuju | juju/client/_client4.py | [
"Apache-2.0"
] | Python | ListSubnets | <not_specific> | async def ListSubnets(self, space_tag=None, zone=None):
'''
ListSubnets returns the matching subnets after applying
optional filters.
space_tag : str
zone : str
Returns -> ListSubnetsResults
'''
if space_tag is not None and not isinstance(space_tag, (byte... |
ListSubnets returns the matching subnets after applying
optional filters.
space_tag : str
zone : str
Returns -> ListSubnetsResults
| ListSubnets returns the matching subnets after applying
optional filters.
space_tag : str
zone : str
Returns -> ListSubnetsResults | [
"ListSubnets",
"returns",
"the",
"matching",
"subnets",
"after",
"applying",
"optional",
"filters",
".",
"space_tag",
":",
"str",
"zone",
":",
"str",
"Returns",
"-",
">",
"ListSubnetsResults"
] | async def ListSubnets(self, space_tag=None, zone=None):
if space_tag is not None and not isinstance(space_tag, (bytes, str)):
raise Exception("Expected space_tag to be a str, received: {}".format(type(space_tag)))
if zone is not None and not isinstance(zone, (bytes, str)):
raise ... | [
"async",
"def",
"ListSubnets",
"(",
"self",
",",
"space_tag",
"=",
"None",
",",
"zone",
"=",
"None",
")",
":",
"if",
"space_tag",
"is",
"not",
"None",
"and",
"not",
"isinstance",
"(",
"space_tag",
",",
"(",
"bytes",
",",
"str",
")",
")",
":",
"raise"... | ListSubnets returns the matching subnets after applying
optional filters. | [
"ListSubnets",
"returns",
"the",
"matching",
"subnets",
"after",
"applying",
"optional",
"filters",
"."
] | [
"'''\n ListSubnets returns the matching subnets after applying\n optional filters.\n\n space_tag : str\n zone : str\n Returns -> ListSubnetsResults\n '''",
"# map input types to rpc msg"
] | [
{
"param": "self",
"type": null
},
{
"param": "space_tag",
"type": null
},
{
"param": "zone",
"type": null
}
] | {
"returns": [],
"raises": [],
"params": [
{
"identifier": "self",
"type": null,
"docstring": null,
"docstring_tokens": [],
"default": null,
"is_optional": null
},
{
"identifier": "space_tag",
"type": null,
"docstring": null,
"docstring_token... |
059810c3daf85c4d82660c8b92a994e845183ae8 | sed-i/python-libjuju | juju/client/_client4.py | [
"Apache-2.0"
] | Python | SubnetsByCIDR | <not_specific> | async def SubnetsByCIDR(self, cidrs=None):
'''
SubnetsByCIDR returns the collection of subnets matching each CIDR in the input.
cidrs : typing.Sequence[str]
Returns -> SubnetsResults
'''
if cidrs is not None and not isinstance(cidrs, (bytes, str, list)):
rais... |
SubnetsByCIDR returns the collection of subnets matching each CIDR in the input.
cidrs : typing.Sequence[str]
Returns -> SubnetsResults
| SubnetsByCIDR returns the collection of subnets matching each CIDR in the input.
cidrs : typing.Sequence[str]
Returns -> SubnetsResults | [
"SubnetsByCIDR",
"returns",
"the",
"collection",
"of",
"subnets",
"matching",
"each",
"CIDR",
"in",
"the",
"input",
".",
"cidrs",
":",
"typing",
".",
"Sequence",
"[",
"str",
"]",
"Returns",
"-",
">",
"SubnetsResults"
] | async def SubnetsByCIDR(self, cidrs=None):
if cidrs is not None and not isinstance(cidrs, (bytes, str, list)):
raise Exception("Expected cidrs to be a Sequence, received: {}".format(type(cidrs)))
_params = dict()
msg = dict(type='Subnets',
request='SubnetsByCIDR',
... | [
"async",
"def",
"SubnetsByCIDR",
"(",
"self",
",",
"cidrs",
"=",
"None",
")",
":",
"if",
"cidrs",
"is",
"not",
"None",
"and",
"not",
"isinstance",
"(",
"cidrs",
",",
"(",
"bytes",
",",
"str",
",",
"list",
")",
")",
":",
"raise",
"Exception",
"(",
"... | SubnetsByCIDR returns the collection of subnets matching each CIDR in the input. | [
"SubnetsByCIDR",
"returns",
"the",
"collection",
"of",
"subnets",
"matching",
"each",
"CIDR",
"in",
"the",
"input",
"."
] | [
"'''\n SubnetsByCIDR returns the collection of subnets matching each CIDR in the input.\n\n cidrs : typing.Sequence[str]\n Returns -> SubnetsResults\n '''",
"# map input types to rpc msg"
] | [
{
"param": "self",
"type": null
},
{
"param": "cidrs",
"type": null
}
] | {
"returns": [],
"raises": [],
"params": [
{
"identifier": "self",
"type": null,
"docstring": null,
"docstring_tokens": [],
"default": null,
"is_optional": null
},
{
"identifier": "cidrs",
"type": null,
"docstring": null,
"docstring_tokens": ... |
cdb853d5c657e372b41b5c9a194af9835cef1cc1 | sed-i/python-libjuju | juju/client/_client6.py | [
"Apache-2.0"
] | Python | ApplicationsCharmsActions | <not_specific> | async def ApplicationsCharmsActions(self, entities=None):
'''
ApplicationsCharmsActions returns a slice of charm Actions for a slice of
services.
entities : typing.Sequence[~Entity]
Returns -> ApplicationsCharmActionsResults
'''
if entities is not None and not is... |
ApplicationsCharmsActions returns a slice of charm Actions for a slice of
services.
entities : typing.Sequence[~Entity]
Returns -> ApplicationsCharmActionsResults
| ApplicationsCharmsActions returns a slice of charm Actions for a slice of
services.
entities : typing.Sequence[~Entity]
Returns -> ApplicationsCharmActionsResults | [
"ApplicationsCharmsActions",
"returns",
"a",
"slice",
"of",
"charm",
"Actions",
"for",
"a",
"slice",
"of",
"services",
".",
"entities",
":",
"typing",
".",
"Sequence",
"[",
"~Entity",
"]",
"Returns",
"-",
">",
"ApplicationsCharmActionsResults"
] | async def ApplicationsCharmsActions(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='Action',
... | [
"async",
"def",
"ApplicationsCharmsActions",
"(",
"self",
",",
"entities",
"=",
"None",
")",
":",
"if",
"entities",
"is",
"not",
"None",
"and",
"not",
"isinstance",
"(",
"entities",
",",
"(",
"bytes",
",",
"str",
",",
"list",
")",
")",
":",
"raise",
"E... | ApplicationsCharmsActions returns a slice of charm Actions for a slice of
services. | [
"ApplicationsCharmsActions",
"returns",
"a",
"slice",
"of",
"charm",
"Actions",
"for",
"a",
"slice",
"of",
"services",
"."
] | [
"'''\n ApplicationsCharmsActions returns a slice of charm Actions for a slice of\n services.\n\n entities : typing.Sequence[~Entity]\n Returns -> ApplicationsCharmActionsResults\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... |
cdb853d5c657e372b41b5c9a194af9835cef1cc1 | sed-i/python-libjuju | juju/client/_client6.py | [
"Apache-2.0"
] | Python | Cancel | <not_specific> | async def Cancel(self, entities=None):
'''
Cancel attempts to cancel enqueued Actions from running.
entities : typing.Sequence[~Entity]
Returns -> ActionResults
'''
if entities is not None and not isinstance(entities, (bytes, str, list)):
raise Exception("Exp... |
Cancel attempts to cancel enqueued Actions from running.
entities : typing.Sequence[~Entity]
Returns -> ActionResults
| Cancel attempts to cancel enqueued Actions from running.
entities : typing.Sequence[~Entity]
Returns -> ActionResults | [
"Cancel",
"attempts",
"to",
"cancel",
"enqueued",
"Actions",
"from",
"running",
".",
"entities",
":",
"typing",
".",
"Sequence",
"[",
"~Entity",
"]",
"Returns",
"-",
">",
"ActionResults"
] | async def Cancel(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='Action',
request='Cancel',
... | [
"async",
"def",
"Cancel",
"(",
"self",
",",
"entities",
"=",
"None",
")",
":",
"if",
"entities",
"is",
"not",
"None",
"and",
"not",
"isinstance",
"(",
"entities",
",",
"(",
"bytes",
",",
"str",
",",
"list",
")",
")",
":",
"raise",
"Exception",
"(",
... | Cancel attempts to cancel enqueued Actions from running. | [
"Cancel",
"attempts",
"to",
"cancel",
"enqueued",
"Actions",
"from",
"running",
"."
] | [
"'''\n Cancel attempts to cancel enqueued Actions from running.\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... |
cdb853d5c657e372b41b5c9a194af9835cef1cc1 | sed-i/python-libjuju | juju/client/_client6.py | [
"Apache-2.0"
] | Python | Enqueue | <not_specific> | async def Enqueue(self, actions=None):
'''
Enqueue takes a list of Actions and queues them up to be executed by
the designated ActionReceiver, returning the params.Action for each
enqueued Action, or an error if there was a problem enqueueing the
Action.
actions : typing... |
Enqueue takes a list of Actions and queues them up to be executed by
the designated ActionReceiver, returning the params.Action for each
enqueued Action, or an error if there was a problem enqueueing the
Action.
actions : typing.Sequence[~Action]
Returns -> ActionResult... | Enqueue takes a list of Actions and queues them up to be executed by
the designated ActionReceiver, returning the params.Action for each
enqueued Action, or an error if there was a problem enqueueing the
Action.
actions : typing.Sequence[~Action]
Returns -> ActionResults | [
"Enqueue",
"takes",
"a",
"list",
"of",
"Actions",
"and",
"queues",
"them",
"up",
"to",
"be",
"executed",
"by",
"the",
"designated",
"ActionReceiver",
"returning",
"the",
"params",
".",
"Action",
"for",
"each",
"enqueued",
"Action",
"or",
"an",
"error",
"if",... | async def Enqueue(self, actions=None):
if actions is not None and not isinstance(actions, (bytes, str, list)):
raise Exception("Expected actions to be a Sequence, received: {}".format(type(actions)))
_params = dict()
msg = dict(type='Action',
request='Enqueue',
... | [
"async",
"def",
"Enqueue",
"(",
"self",
",",
"actions",
"=",
"None",
")",
":",
"if",
"actions",
"is",
"not",
"None",
"and",
"not",
"isinstance",
"(",
"actions",
",",
"(",
"bytes",
",",
"str",
",",
"list",
")",
")",
":",
"raise",
"Exception",
"(",
"... | Enqueue takes a list of Actions and queues them up to be executed by
the designated ActionReceiver, returning the params.Action for each
enqueued Action, or an error if there was a problem enqueueing the
Action. | [
"Enqueue",
"takes",
"a",
"list",
"of",
"Actions",
"and",
"queues",
"them",
"up",
"to",
"be",
"executed",
"by",
"the",
"designated",
"ActionReceiver",
"returning",
"the",
"params",
".",
"Action",
"for",
"each",
"enqueued",
"Action",
"or",
"an",
"error",
"if",... | [
"'''\n Enqueue takes a list of Actions and queues them up to be executed by\n the designated ActionReceiver, returning the params.Action for each\n enqueued Action, or an error if there was a problem enqueueing the\n Action.\n\n actions : typing.Sequence[~Action]\n Returns ... | [
{
"param": "self",
"type": null
},
{
"param": "actions",
"type": null
}
] | {
"returns": [],
"raises": [],
"params": [
{
"identifier": "self",
"type": null,
"docstring": null,
"docstring_tokens": [],
"default": null,
"is_optional": null
},
{
"identifier": "actions",
"type": null,
"docstring": null,
"docstring_tokens"... |
cdb853d5c657e372b41b5c9a194af9835cef1cc1 | sed-i/python-libjuju | juju/client/_client6.py | [
"Apache-2.0"
] | Python | EnqueueOperation | <not_specific> | async def EnqueueOperation(self, actions=None):
'''
EnqueueOperation takes a list of Actions and queues them up to be executed as
an operation, each action running as a task on the the designated ActionReceiver.
We return the ID of the overall operation and each individual task.
... |
EnqueueOperation takes a list of Actions and queues them up to be executed as
an operation, each action running as a task on the the designated ActionReceiver.
We return the ID of the overall operation and each individual task.
actions : typing.Sequence[~Action]
Returns -> Enqu... | EnqueueOperation takes a list of Actions and queues them up to be executed as
an operation, each action running as a task on the the designated ActionReceiver.
We return the ID of the overall operation and each individual task.
actions : typing.Sequence[~Action]
Returns -> EnqueuedActions | [
"EnqueueOperation",
"takes",
"a",
"list",
"of",
"Actions",
"and",
"queues",
"them",
"up",
"to",
"be",
"executed",
"as",
"an",
"operation",
"each",
"action",
"running",
"as",
"a",
"task",
"on",
"the",
"the",
"designated",
"ActionReceiver",
".",
"We",
"return"... | async def EnqueueOperation(self, actions=None):
if actions is not None and not isinstance(actions, (bytes, str, list)):
raise Exception("Expected actions to be a Sequence, received: {}".format(type(actions)))
_params = dict()
msg = dict(type='Action',
request='Enqu... | [
"async",
"def",
"EnqueueOperation",
"(",
"self",
",",
"actions",
"=",
"None",
")",
":",
"if",
"actions",
"is",
"not",
"None",
"and",
"not",
"isinstance",
"(",
"actions",
",",
"(",
"bytes",
",",
"str",
",",
"list",
")",
")",
":",
"raise",
"Exception",
... | EnqueueOperation takes a list of Actions and queues them up to be executed as
an operation, each action running as a task on the the designated ActionReceiver. | [
"EnqueueOperation",
"takes",
"a",
"list",
"of",
"Actions",
"and",
"queues",
"them",
"up",
"to",
"be",
"executed",
"as",
"an",
"operation",
"each",
"action",
"running",
"as",
"a",
"task",
"on",
"the",
"the",
"designated",
"ActionReceiver",
"."
] | [
"'''\n EnqueueOperation takes a list of Actions and queues them up to be executed as\n an operation, each action running as a task on the the designated ActionReceiver.\n We return the ID of the overall operation and each individual task.\n\n actions : typing.Sequence[~Action]\n R... | [
{
"param": "self",
"type": null
},
{
"param": "actions",
"type": null
}
] | {
"returns": [],
"raises": [],
"params": [
{
"identifier": "self",
"type": null,
"docstring": null,
"docstring_tokens": [],
"default": null,
"is_optional": null
},
{
"identifier": "actions",
"type": null,
"docstring": null,
"docstring_tokens"... |
cdb853d5c657e372b41b5c9a194af9835cef1cc1 | sed-i/python-libjuju | juju/client/_client6.py | [
"Apache-2.0"
] | Python | FindActionTagsByPrefix | <not_specific> | async def FindActionTagsByPrefix(self, prefixes=None):
'''
FindActionTagsByPrefix takes a list of string prefixes and finds
corresponding ActionTags that match that prefix.
TODO(juju3) - rename API method since we only need prefix matching for UUIDs
prefixes : typing.Sequence[st... |
FindActionTagsByPrefix takes a list of string prefixes and finds
corresponding ActionTags that match that prefix.
TODO(juju3) - rename API method since we only need prefix matching for UUIDs
prefixes : typing.Sequence[str]
Returns -> FindTagsResults
| FindActionTagsByPrefix takes a list of string prefixes and finds
corresponding ActionTags that match that prefix.
TODO(juju3) - rename API method since we only need prefix matching for UUIDs
prefixes : typing.Sequence[str]
Returns -> FindTagsResults | [
"FindActionTagsByPrefix",
"takes",
"a",
"list",
"of",
"string",
"prefixes",
"and",
"finds",
"corresponding",
"ActionTags",
"that",
"match",
"that",
"prefix",
".",
"TODO",
"(",
"juju3",
")",
"-",
"rename",
"API",
"method",
"since",
"we",
"only",
"need",
"prefix... | async def FindActionTagsByPrefix(self, prefixes=None):
if prefixes is not None and not isinstance(prefixes, (bytes, str, list)):
raise Exception("Expected prefixes to be a Sequence, received: {}".format(type(prefixes)))
_params = dict()
msg = dict(type='Action',
re... | [
"async",
"def",
"FindActionTagsByPrefix",
"(",
"self",
",",
"prefixes",
"=",
"None",
")",
":",
"if",
"prefixes",
"is",
"not",
"None",
"and",
"not",
"isinstance",
"(",
"prefixes",
",",
"(",
"bytes",
",",
"str",
",",
"list",
")",
")",
":",
"raise",
"Exce... | FindActionTagsByPrefix takes a list of string prefixes and finds
corresponding ActionTags that match that prefix. | [
"FindActionTagsByPrefix",
"takes",
"a",
"list",
"of",
"string",
"prefixes",
"and",
"finds",
"corresponding",
"ActionTags",
"that",
"match",
"that",
"prefix",
"."
] | [
"'''\n FindActionTagsByPrefix takes a list of string prefixes and finds\n corresponding ActionTags that match that prefix.\n TODO(juju3) - rename API method since we only need prefix matching for UUIDs\n\n prefixes : typing.Sequence[str]\n Returns -> FindTagsResults\n '''",... | [
{
"param": "self",
"type": null
},
{
"param": "prefixes",
"type": null
}
] | {
"returns": [],
"raises": [],
"params": [
{
"identifier": "self",
"type": null,
"docstring": null,
"docstring_tokens": [],
"default": null,
"is_optional": null
},
{
"identifier": "prefixes",
"type": null,
"docstring": null,
"docstring_tokens... |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.