id
int32 0
252k
| repo
stringlengths 7
55
| path
stringlengths 4
127
| func_name
stringlengths 1
88
| original_string
stringlengths 75
19.8k
| language
stringclasses 1
value | code
stringlengths 75
19.8k
| code_tokens
list | docstring
stringlengths 3
17.3k
| docstring_tokens
list | sha
stringlengths 40
40
| url
stringlengths 87
242
|
|---|---|---|---|---|---|---|---|---|---|---|---|
10,900
|
soravux/scoop
|
scoop/utils.py
|
getHostsFromPBS
|
def getHostsFromPBS():
"""Return a host list in a PBS environment"""
# See above comment about Counter
with open(os.environ["PBS_NODEFILE"], 'r') as hosts:
hostlist = groupTogether(hosts.read().split())
retVal = []
for key, group in groupby(hostlist):
retVal.append((key, len(list(group))))
return retVal
|
python
|
def getHostsFromPBS():
"""Return a host list in a PBS environment"""
# See above comment about Counter
with open(os.environ["PBS_NODEFILE"], 'r') as hosts:
hostlist = groupTogether(hosts.read().split())
retVal = []
for key, group in groupby(hostlist):
retVal.append((key, len(list(group))))
return retVal
|
[
"def",
"getHostsFromPBS",
"(",
")",
":",
"# See above comment about Counter",
"with",
"open",
"(",
"os",
".",
"environ",
"[",
"\"PBS_NODEFILE\"",
"]",
",",
"'r'",
")",
"as",
"hosts",
":",
"hostlist",
"=",
"groupTogether",
"(",
"hosts",
".",
"read",
"(",
")",
".",
"split",
"(",
")",
")",
"retVal",
"=",
"[",
"]",
"for",
"key",
",",
"group",
"in",
"groupby",
"(",
"hostlist",
")",
":",
"retVal",
".",
"append",
"(",
"(",
"key",
",",
"len",
"(",
"list",
"(",
"group",
")",
")",
")",
")",
"return",
"retVal"
] |
Return a host list in a PBS environment
|
[
"Return",
"a",
"host",
"list",
"in",
"a",
"PBS",
"environment"
] |
d391dfa62f47e49d48328ee9cf08aa114256fd33
|
https://github.com/soravux/scoop/blob/d391dfa62f47e49d48328ee9cf08aa114256fd33/scoop/utils.py#L225-L233
|
10,901
|
soravux/scoop
|
scoop/utils.py
|
getHostsFromSGE
|
def getHostsFromSGE():
"""Return a host list in a SGE environment"""
with open(os.environ["PE_HOSTFILE"], 'r') as hosts:
return [(host.split()[0], int(host.split()[1])) for host in hosts]
|
python
|
def getHostsFromSGE():
"""Return a host list in a SGE environment"""
with open(os.environ["PE_HOSTFILE"], 'r') as hosts:
return [(host.split()[0], int(host.split()[1])) for host in hosts]
|
[
"def",
"getHostsFromSGE",
"(",
")",
":",
"with",
"open",
"(",
"os",
".",
"environ",
"[",
"\"PE_HOSTFILE\"",
"]",
",",
"'r'",
")",
"as",
"hosts",
":",
"return",
"[",
"(",
"host",
".",
"split",
"(",
")",
"[",
"0",
"]",
",",
"int",
"(",
"host",
".",
"split",
"(",
")",
"[",
"1",
"]",
")",
")",
"for",
"host",
"in",
"hosts",
"]"
] |
Return a host list in a SGE environment
|
[
"Return",
"a",
"host",
"list",
"in",
"a",
"SGE",
"environment"
] |
d391dfa62f47e49d48328ee9cf08aa114256fd33
|
https://github.com/soravux/scoop/blob/d391dfa62f47e49d48328ee9cf08aa114256fd33/scoop/utils.py#L236-L239
|
10,902
|
soravux/scoop
|
scoop/utils.py
|
getWorkerQte
|
def getWorkerQte(hosts):
"""Return the number of workers to launch depending on the environment"""
if "SLURM_NTASKS" in os.environ:
return int(os.environ["SLURM_NTASKS"])
elif "PBS_NP" in os.environ:
return int(os.environ["PBS_NP"])
elif "NSLOTS" in os.environ:
return int(os.environ["NSLOTS"])
else:
return sum(host[1] for host in hosts)
|
python
|
def getWorkerQte(hosts):
"""Return the number of workers to launch depending on the environment"""
if "SLURM_NTASKS" in os.environ:
return int(os.environ["SLURM_NTASKS"])
elif "PBS_NP" in os.environ:
return int(os.environ["PBS_NP"])
elif "NSLOTS" in os.environ:
return int(os.environ["NSLOTS"])
else:
return sum(host[1] for host in hosts)
|
[
"def",
"getWorkerQte",
"(",
"hosts",
")",
":",
"if",
"\"SLURM_NTASKS\"",
"in",
"os",
".",
"environ",
":",
"return",
"int",
"(",
"os",
".",
"environ",
"[",
"\"SLURM_NTASKS\"",
"]",
")",
"elif",
"\"PBS_NP\"",
"in",
"os",
".",
"environ",
":",
"return",
"int",
"(",
"os",
".",
"environ",
"[",
"\"PBS_NP\"",
"]",
")",
"elif",
"\"NSLOTS\"",
"in",
"os",
".",
"environ",
":",
"return",
"int",
"(",
"os",
".",
"environ",
"[",
"\"NSLOTS\"",
"]",
")",
"else",
":",
"return",
"sum",
"(",
"host",
"[",
"1",
"]",
"for",
"host",
"in",
"hosts",
")"
] |
Return the number of workers to launch depending on the environment
|
[
"Return",
"the",
"number",
"of",
"workers",
"to",
"launch",
"depending",
"on",
"the",
"environment"
] |
d391dfa62f47e49d48328ee9cf08aa114256fd33
|
https://github.com/soravux/scoop/blob/d391dfa62f47e49d48328ee9cf08aa114256fd33/scoop/utils.py#L242-L251
|
10,903
|
soravux/scoop
|
scoop/encapsulation.py
|
functionFactory
|
def functionFactory(in_code, name, defaults, globals_, imports):
"""Creates a function at runtime using binary compiled inCode"""
def generatedFunction():
pass
generatedFunction.__code__ = marshal.loads(in_code)
generatedFunction.__name__ = name
generatedFunction.__defaults = defaults
generatedFunction.__globals__.update(pickle.loads(globals_))
for key, value in imports.items():
imported_module = __import__(value)
scoop.logger.debug("Dynamically loaded module {0}".format(value))
generatedFunction.__globals__.update({key: imported_module})
return generatedFunction
|
python
|
def functionFactory(in_code, name, defaults, globals_, imports):
"""Creates a function at runtime using binary compiled inCode"""
def generatedFunction():
pass
generatedFunction.__code__ = marshal.loads(in_code)
generatedFunction.__name__ = name
generatedFunction.__defaults = defaults
generatedFunction.__globals__.update(pickle.loads(globals_))
for key, value in imports.items():
imported_module = __import__(value)
scoop.logger.debug("Dynamically loaded module {0}".format(value))
generatedFunction.__globals__.update({key: imported_module})
return generatedFunction
|
[
"def",
"functionFactory",
"(",
"in_code",
",",
"name",
",",
"defaults",
",",
"globals_",
",",
"imports",
")",
":",
"def",
"generatedFunction",
"(",
")",
":",
"pass",
"generatedFunction",
".",
"__code__",
"=",
"marshal",
".",
"loads",
"(",
"in_code",
")",
"generatedFunction",
".",
"__name__",
"=",
"name",
"generatedFunction",
".",
"__defaults",
"=",
"defaults",
"generatedFunction",
".",
"__globals__",
".",
"update",
"(",
"pickle",
".",
"loads",
"(",
"globals_",
")",
")",
"for",
"key",
",",
"value",
"in",
"imports",
".",
"items",
"(",
")",
":",
"imported_module",
"=",
"__import__",
"(",
"value",
")",
"scoop",
".",
"logger",
".",
"debug",
"(",
"\"Dynamically loaded module {0}\"",
".",
"format",
"(",
"value",
")",
")",
"generatedFunction",
".",
"__globals__",
".",
"update",
"(",
"{",
"key",
":",
"imported_module",
"}",
")",
"return",
"generatedFunction"
] |
Creates a function at runtime using binary compiled inCode
|
[
"Creates",
"a",
"function",
"at",
"runtime",
"using",
"binary",
"compiled",
"inCode"
] |
d391dfa62f47e49d48328ee9cf08aa114256fd33
|
https://github.com/soravux/scoop/blob/d391dfa62f47e49d48328ee9cf08aa114256fd33/scoop/encapsulation.py#L41-L53
|
10,904
|
soravux/scoop
|
scoop/encapsulation.py
|
makeLambdaPicklable
|
def makeLambdaPicklable(lambda_function):
"""Take input lambda function l and makes it picklable."""
if isinstance(lambda_function,
type(lambda: None)) and lambda_function.__name__ == '<lambda>':
def __reduce_ex__(proto):
# TODO: argdefs, closure
return unpickleLambda, (marshal.dumps(lambda_function.__code__), )
lambda_function.__reduce_ex__ = __reduce_ex__
return lambda_function
|
python
|
def makeLambdaPicklable(lambda_function):
"""Take input lambda function l and makes it picklable."""
if isinstance(lambda_function,
type(lambda: None)) and lambda_function.__name__ == '<lambda>':
def __reduce_ex__(proto):
# TODO: argdefs, closure
return unpickleLambda, (marshal.dumps(lambda_function.__code__), )
lambda_function.__reduce_ex__ = __reduce_ex__
return lambda_function
|
[
"def",
"makeLambdaPicklable",
"(",
"lambda_function",
")",
":",
"if",
"isinstance",
"(",
"lambda_function",
",",
"type",
"(",
"lambda",
":",
"None",
")",
")",
"and",
"lambda_function",
".",
"__name__",
"==",
"'<lambda>'",
":",
"def",
"__reduce_ex__",
"(",
"proto",
")",
":",
"# TODO: argdefs, closure",
"return",
"unpickleLambda",
",",
"(",
"marshal",
".",
"dumps",
"(",
"lambda_function",
".",
"__code__",
")",
",",
")",
"lambda_function",
".",
"__reduce_ex__",
"=",
"__reduce_ex__",
"return",
"lambda_function"
] |
Take input lambda function l and makes it picklable.
|
[
"Take",
"input",
"lambda",
"function",
"l",
"and",
"makes",
"it",
"picklable",
"."
] |
d391dfa62f47e49d48328ee9cf08aa114256fd33
|
https://github.com/soravux/scoop/blob/d391dfa62f47e49d48328ee9cf08aa114256fd33/scoop/encapsulation.py#L143-L151
|
10,905
|
soravux/scoop
|
examples/dependency/sortingnetwork.py
|
SortingNetwork.addConnector
|
def addConnector(self, wire1, wire2):
"""Add a connector between wire1 and wire2 in the network."""
if wire1 == wire2:
return
if wire1 > wire2:
wire1, wire2 = wire2, wire1
try:
last_level = self[-1]
except IndexError:
# Empty network, create new level and connector
self.append([(wire1, wire2)])
return
for wires in last_level:
if wires[1] >= wire1 and wires[0] <= wire2:
self.append([(wire1, wire2)])
return
last_level.append((wire1, wire2))
|
python
|
def addConnector(self, wire1, wire2):
"""Add a connector between wire1 and wire2 in the network."""
if wire1 == wire2:
return
if wire1 > wire2:
wire1, wire2 = wire2, wire1
try:
last_level = self[-1]
except IndexError:
# Empty network, create new level and connector
self.append([(wire1, wire2)])
return
for wires in last_level:
if wires[1] >= wire1 and wires[0] <= wire2:
self.append([(wire1, wire2)])
return
last_level.append((wire1, wire2))
|
[
"def",
"addConnector",
"(",
"self",
",",
"wire1",
",",
"wire2",
")",
":",
"if",
"wire1",
"==",
"wire2",
":",
"return",
"if",
"wire1",
">",
"wire2",
":",
"wire1",
",",
"wire2",
"=",
"wire2",
",",
"wire1",
"try",
":",
"last_level",
"=",
"self",
"[",
"-",
"1",
"]",
"except",
"IndexError",
":",
"# Empty network, create new level and connector",
"self",
".",
"append",
"(",
"[",
"(",
"wire1",
",",
"wire2",
")",
"]",
")",
"return",
"for",
"wires",
"in",
"last_level",
":",
"if",
"wires",
"[",
"1",
"]",
">=",
"wire1",
"and",
"wires",
"[",
"0",
"]",
"<=",
"wire2",
":",
"self",
".",
"append",
"(",
"[",
"(",
"wire1",
",",
"wire2",
")",
"]",
")",
"return",
"last_level",
".",
"append",
"(",
"(",
"wire1",
",",
"wire2",
")",
")"
] |
Add a connector between wire1 and wire2 in the network.
|
[
"Add",
"a",
"connector",
"between",
"wire1",
"and",
"wire2",
"in",
"the",
"network",
"."
] |
d391dfa62f47e49d48328ee9cf08aa114256fd33
|
https://github.com/soravux/scoop/blob/d391dfa62f47e49d48328ee9cf08aa114256fd33/examples/dependency/sortingnetwork.py#L43-L63
|
10,906
|
soravux/scoop
|
examples/dependency/sortingnetwork.py
|
SortingNetwork.sort
|
def sort(self, values):
"""Sort the values in-place based on the connectors in the network."""
for level in self:
for wire1, wire2 in level:
if values[wire1] > values[wire2]:
values[wire1], values[wire2] = values[wire2], values[wire1]
|
python
|
def sort(self, values):
"""Sort the values in-place based on the connectors in the network."""
for level in self:
for wire1, wire2 in level:
if values[wire1] > values[wire2]:
values[wire1], values[wire2] = values[wire2], values[wire1]
|
[
"def",
"sort",
"(",
"self",
",",
"values",
")",
":",
"for",
"level",
"in",
"self",
":",
"for",
"wire1",
",",
"wire2",
"in",
"level",
":",
"if",
"values",
"[",
"wire1",
"]",
">",
"values",
"[",
"wire2",
"]",
":",
"values",
"[",
"wire1",
"]",
",",
"values",
"[",
"wire2",
"]",
"=",
"values",
"[",
"wire2",
"]",
",",
"values",
"[",
"wire1",
"]"
] |
Sort the values in-place based on the connectors in the network.
|
[
"Sort",
"the",
"values",
"in",
"-",
"place",
"based",
"on",
"the",
"connectors",
"in",
"the",
"network",
"."
] |
d391dfa62f47e49d48328ee9cf08aa114256fd33
|
https://github.com/soravux/scoop/blob/d391dfa62f47e49d48328ee9cf08aa114256fd33/examples/dependency/sortingnetwork.py#L65-L70
|
10,907
|
soravux/scoop
|
examples/dependency/sortingnetwork.py
|
SortingNetwork.draw
|
def draw(self):
"""Return an ASCII representation of the network."""
str_wires = [["-"]*7 * self.depth]
str_wires[0][0] = "0"
str_wires[0][1] = " o"
str_spaces = []
for i in range(1, self.dimension):
str_wires.append(["-"]*7 * self.depth)
str_spaces.append([" "]*7 * self.depth)
str_wires[i][0] = str(i)
str_wires[i][1] = " o"
for index, level in enumerate(self):
for wire1, wire2 in level:
str_wires[wire1][(index+1)*6] = "x"
str_wires[wire2][(index+1)*6] = "x"
for i in range(wire1, wire2):
str_spaces[i][(index+1)*6+1] = "|"
for i in range(wire1+1, wire2):
str_wires[i][(index+1)*6] = "|"
network_draw = "".join(str_wires[0])
for line, space in zip(str_wires[1:], str_spaces):
network_draw += "\n"
network_draw += "".join(space)
network_draw += "\n"
network_draw += "".join(line)
return network_draw
|
python
|
def draw(self):
"""Return an ASCII representation of the network."""
str_wires = [["-"]*7 * self.depth]
str_wires[0][0] = "0"
str_wires[0][1] = " o"
str_spaces = []
for i in range(1, self.dimension):
str_wires.append(["-"]*7 * self.depth)
str_spaces.append([" "]*7 * self.depth)
str_wires[i][0] = str(i)
str_wires[i][1] = " o"
for index, level in enumerate(self):
for wire1, wire2 in level:
str_wires[wire1][(index+1)*6] = "x"
str_wires[wire2][(index+1)*6] = "x"
for i in range(wire1, wire2):
str_spaces[i][(index+1)*6+1] = "|"
for i in range(wire1+1, wire2):
str_wires[i][(index+1)*6] = "|"
network_draw = "".join(str_wires[0])
for line, space in zip(str_wires[1:], str_spaces):
network_draw += "\n"
network_draw += "".join(space)
network_draw += "\n"
network_draw += "".join(line)
return network_draw
|
[
"def",
"draw",
"(",
"self",
")",
":",
"str_wires",
"=",
"[",
"[",
"\"-\"",
"]",
"*",
"7",
"*",
"self",
".",
"depth",
"]",
"str_wires",
"[",
"0",
"]",
"[",
"0",
"]",
"=",
"\"0\"",
"str_wires",
"[",
"0",
"]",
"[",
"1",
"]",
"=",
"\" o\"",
"str_spaces",
"=",
"[",
"]",
"for",
"i",
"in",
"range",
"(",
"1",
",",
"self",
".",
"dimension",
")",
":",
"str_wires",
".",
"append",
"(",
"[",
"\"-\"",
"]",
"*",
"7",
"*",
"self",
".",
"depth",
")",
"str_spaces",
".",
"append",
"(",
"[",
"\" \"",
"]",
"*",
"7",
"*",
"self",
".",
"depth",
")",
"str_wires",
"[",
"i",
"]",
"[",
"0",
"]",
"=",
"str",
"(",
"i",
")",
"str_wires",
"[",
"i",
"]",
"[",
"1",
"]",
"=",
"\" o\"",
"for",
"index",
",",
"level",
"in",
"enumerate",
"(",
"self",
")",
":",
"for",
"wire1",
",",
"wire2",
"in",
"level",
":",
"str_wires",
"[",
"wire1",
"]",
"[",
"(",
"index",
"+",
"1",
")",
"*",
"6",
"]",
"=",
"\"x\"",
"str_wires",
"[",
"wire2",
"]",
"[",
"(",
"index",
"+",
"1",
")",
"*",
"6",
"]",
"=",
"\"x\"",
"for",
"i",
"in",
"range",
"(",
"wire1",
",",
"wire2",
")",
":",
"str_spaces",
"[",
"i",
"]",
"[",
"(",
"index",
"+",
"1",
")",
"*",
"6",
"+",
"1",
"]",
"=",
"\"|\"",
"for",
"i",
"in",
"range",
"(",
"wire1",
"+",
"1",
",",
"wire2",
")",
":",
"str_wires",
"[",
"i",
"]",
"[",
"(",
"index",
"+",
"1",
")",
"*",
"6",
"]",
"=",
"\"|\"",
"network_draw",
"=",
"\"\"",
".",
"join",
"(",
"str_wires",
"[",
"0",
"]",
")",
"for",
"line",
",",
"space",
"in",
"zip",
"(",
"str_wires",
"[",
"1",
":",
"]",
",",
"str_spaces",
")",
":",
"network_draw",
"+=",
"\"\\n\"",
"network_draw",
"+=",
"\"\"",
".",
"join",
"(",
"space",
")",
"network_draw",
"+=",
"\"\\n\"",
"network_draw",
"+=",
"\"\"",
".",
"join",
"(",
"line",
")",
"return",
"network_draw"
] |
Return an ASCII representation of the network.
|
[
"Return",
"an",
"ASCII",
"representation",
"of",
"the",
"network",
"."
] |
d391dfa62f47e49d48328ee9cf08aa114256fd33
|
https://github.com/soravux/scoop/blob/d391dfa62f47e49d48328ee9cf08aa114256fd33/examples/dependency/sortingnetwork.py#L88-L116
|
10,908
|
soravux/scoop
|
bench/process_debug.py
|
getWorkersName
|
def getWorkersName(data):
"""Returns the list of the names of the workers sorted alphabetically"""
names = [fichier for fichier in data.keys()]
names.sort()
try:
names.remove("broker")
except ValueError:
pass
return names
|
python
|
def getWorkersName(data):
"""Returns the list of the names of the workers sorted alphabetically"""
names = [fichier for fichier in data.keys()]
names.sort()
try:
names.remove("broker")
except ValueError:
pass
return names
|
[
"def",
"getWorkersName",
"(",
"data",
")",
":",
"names",
"=",
"[",
"fichier",
"for",
"fichier",
"in",
"data",
".",
"keys",
"(",
")",
"]",
"names",
".",
"sort",
"(",
")",
"try",
":",
"names",
".",
"remove",
"(",
"\"broker\"",
")",
"except",
"ValueError",
":",
"pass",
"return",
"names"
] |
Returns the list of the names of the workers sorted alphabetically
|
[
"Returns",
"the",
"list",
"of",
"the",
"names",
"of",
"the",
"workers",
"sorted",
"alphabetically"
] |
d391dfa62f47e49d48328ee9cf08aa114256fd33
|
https://github.com/soravux/scoop/blob/d391dfa62f47e49d48328ee9cf08aa114256fd33/bench/process_debug.py#L41-L49
|
10,909
|
soravux/scoop
|
bench/process_debug.py
|
importData
|
def importData(directory):
"""Parse the input files and return two dictionnaries"""
dataTask = OrderedDict()
dataQueue = OrderedDict()
for fichier in sorted(os.listdir(directory)):
try:
with open("{directory}/{fichier}".format(**locals()), 'rb') as f:
fileName, fileType = fichier.rsplit('-', 1)
if fileType == "QUEUE":
dataQueue[fileName] = pickle.load(f)
else:
dataTask[fileName] = pickle.load(f)
except:
# Can be a directory
pass
return dataTask, dataQueue
|
python
|
def importData(directory):
"""Parse the input files and return two dictionnaries"""
dataTask = OrderedDict()
dataQueue = OrderedDict()
for fichier in sorted(os.listdir(directory)):
try:
with open("{directory}/{fichier}".format(**locals()), 'rb') as f:
fileName, fileType = fichier.rsplit('-', 1)
if fileType == "QUEUE":
dataQueue[fileName] = pickle.load(f)
else:
dataTask[fileName] = pickle.load(f)
except:
# Can be a directory
pass
return dataTask, dataQueue
|
[
"def",
"importData",
"(",
"directory",
")",
":",
"dataTask",
"=",
"OrderedDict",
"(",
")",
"dataQueue",
"=",
"OrderedDict",
"(",
")",
"for",
"fichier",
"in",
"sorted",
"(",
"os",
".",
"listdir",
"(",
"directory",
")",
")",
":",
"try",
":",
"with",
"open",
"(",
"\"{directory}/{fichier}\"",
".",
"format",
"(",
"*",
"*",
"locals",
"(",
")",
")",
",",
"'rb'",
")",
"as",
"f",
":",
"fileName",
",",
"fileType",
"=",
"fichier",
".",
"rsplit",
"(",
"'-'",
",",
"1",
")",
"if",
"fileType",
"==",
"\"QUEUE\"",
":",
"dataQueue",
"[",
"fileName",
"]",
"=",
"pickle",
".",
"load",
"(",
"f",
")",
"else",
":",
"dataTask",
"[",
"fileName",
"]",
"=",
"pickle",
".",
"load",
"(",
"f",
")",
"except",
":",
"# Can be a directory",
"pass",
"return",
"dataTask",
",",
"dataQueue"
] |
Parse the input files and return two dictionnaries
|
[
"Parse",
"the",
"input",
"files",
"and",
"return",
"two",
"dictionnaries"
] |
d391dfa62f47e49d48328ee9cf08aa114256fd33
|
https://github.com/soravux/scoop/blob/d391dfa62f47e49d48328ee9cf08aa114256fd33/bench/process_debug.py#L51-L66
|
10,910
|
soravux/scoop
|
bench/process_debug.py
|
getTimes
|
def getTimes(dataTasks):
"""Get the start time and the end time of data in milliseconds"""
global begin_time
start_time, end_time = float('inf'), 0
for fichier, vals in dataTask.items():
try:
if hasattr(vals, 'values'):
tmp_start_time = min([a['start_time'] for a in vals.values()])[0]
if tmp_start_time < start_time:
start_time = tmp_start_time
tmp_end_time = max([a['end_time'] for a in vals.values()])[0]
if tmp_end_time > end_time:
end_time = tmp_end_time
except ValueError:
continue
begin_time = 1000 * start_time
return 1000 * start_time, 1000 * end_time
|
python
|
def getTimes(dataTasks):
"""Get the start time and the end time of data in milliseconds"""
global begin_time
start_time, end_time = float('inf'), 0
for fichier, vals in dataTask.items():
try:
if hasattr(vals, 'values'):
tmp_start_time = min([a['start_time'] for a in vals.values()])[0]
if tmp_start_time < start_time:
start_time = tmp_start_time
tmp_end_time = max([a['end_time'] for a in vals.values()])[0]
if tmp_end_time > end_time:
end_time = tmp_end_time
except ValueError:
continue
begin_time = 1000 * start_time
return 1000 * start_time, 1000 * end_time
|
[
"def",
"getTimes",
"(",
"dataTasks",
")",
":",
"global",
"begin_time",
"start_time",
",",
"end_time",
"=",
"float",
"(",
"'inf'",
")",
",",
"0",
"for",
"fichier",
",",
"vals",
"in",
"dataTask",
".",
"items",
"(",
")",
":",
"try",
":",
"if",
"hasattr",
"(",
"vals",
",",
"'values'",
")",
":",
"tmp_start_time",
"=",
"min",
"(",
"[",
"a",
"[",
"'start_time'",
"]",
"for",
"a",
"in",
"vals",
".",
"values",
"(",
")",
"]",
")",
"[",
"0",
"]",
"if",
"tmp_start_time",
"<",
"start_time",
":",
"start_time",
"=",
"tmp_start_time",
"tmp_end_time",
"=",
"max",
"(",
"[",
"a",
"[",
"'end_time'",
"]",
"for",
"a",
"in",
"vals",
".",
"values",
"(",
")",
"]",
")",
"[",
"0",
"]",
"if",
"tmp_end_time",
">",
"end_time",
":",
"end_time",
"=",
"tmp_end_time",
"except",
"ValueError",
":",
"continue",
"begin_time",
"=",
"1000",
"*",
"start_time",
"return",
"1000",
"*",
"start_time",
",",
"1000",
"*",
"end_time"
] |
Get the start time and the end time of data in milliseconds
|
[
"Get",
"the",
"start",
"time",
"and",
"the",
"end",
"time",
"of",
"data",
"in",
"milliseconds"
] |
d391dfa62f47e49d48328ee9cf08aa114256fd33
|
https://github.com/soravux/scoop/blob/d391dfa62f47e49d48328ee9cf08aa114256fd33/bench/process_debug.py#L79-L95
|
10,911
|
soravux/scoop
|
bench/process_debug.py
|
WorkersDensity
|
def WorkersDensity(dataTasks):
"""Return the worker density data for the graph."""
start_time, end_time = getTimes(dataTasks)
graphdata = []
for name in getWorkersName(dataTasks):
vals = dataTasks[name]
if hasattr(vals, 'values'):
# Data from worker
workerdata = []
print("Plotting density map for {}".format(name))
# We only have 800 pixels
try:
for graphtime in timeRange(start_time, end_time, DENSITY_MAP_TIME_AXIS_LENGTH):
for a in vals.values():
if not all((a['start_time'], a['end_time'])):
print("Invalid data:", a['start_time'], a['end_time'])
#print(a['start_time'], a['end_time'])
workerdata.append(sum([a['start_time'][0] <= float(graphtime) /
1000. <= a['end_time'][0] for a in vals.values()
if a['start_time'] and a['end_time']])
)
except OverflowError:
print("Error processing {0} or {1}".format(start_time, end_time))
graphdata.append(workerdata)
if args.binarydensity:
# Normalize [...]
maxval = max(graphdata[-1])
if maxval > 1:
maxval = maxval - 1
graphdata[-1] = [x - maxval for x in graphdata[-1]]
return graphdata
|
python
|
def WorkersDensity(dataTasks):
"""Return the worker density data for the graph."""
start_time, end_time = getTimes(dataTasks)
graphdata = []
for name in getWorkersName(dataTasks):
vals = dataTasks[name]
if hasattr(vals, 'values'):
# Data from worker
workerdata = []
print("Plotting density map for {}".format(name))
# We only have 800 pixels
try:
for graphtime in timeRange(start_time, end_time, DENSITY_MAP_TIME_AXIS_LENGTH):
for a in vals.values():
if not all((a['start_time'], a['end_time'])):
print("Invalid data:", a['start_time'], a['end_time'])
#print(a['start_time'], a['end_time'])
workerdata.append(sum([a['start_time'][0] <= float(graphtime) /
1000. <= a['end_time'][0] for a in vals.values()
if a['start_time'] and a['end_time']])
)
except OverflowError:
print("Error processing {0} or {1}".format(start_time, end_time))
graphdata.append(workerdata)
if args.binarydensity:
# Normalize [...]
maxval = max(graphdata[-1])
if maxval > 1:
maxval = maxval - 1
graphdata[-1] = [x - maxval for x in graphdata[-1]]
return graphdata
|
[
"def",
"WorkersDensity",
"(",
"dataTasks",
")",
":",
"start_time",
",",
"end_time",
"=",
"getTimes",
"(",
"dataTasks",
")",
"graphdata",
"=",
"[",
"]",
"for",
"name",
"in",
"getWorkersName",
"(",
"dataTasks",
")",
":",
"vals",
"=",
"dataTasks",
"[",
"name",
"]",
"if",
"hasattr",
"(",
"vals",
",",
"'values'",
")",
":",
"# Data from worker",
"workerdata",
"=",
"[",
"]",
"print",
"(",
"\"Plotting density map for {}\"",
".",
"format",
"(",
"name",
")",
")",
"# We only have 800 pixels",
"try",
":",
"for",
"graphtime",
"in",
"timeRange",
"(",
"start_time",
",",
"end_time",
",",
"DENSITY_MAP_TIME_AXIS_LENGTH",
")",
":",
"for",
"a",
"in",
"vals",
".",
"values",
"(",
")",
":",
"if",
"not",
"all",
"(",
"(",
"a",
"[",
"'start_time'",
"]",
",",
"a",
"[",
"'end_time'",
"]",
")",
")",
":",
"print",
"(",
"\"Invalid data:\"",
",",
"a",
"[",
"'start_time'",
"]",
",",
"a",
"[",
"'end_time'",
"]",
")",
"#print(a['start_time'], a['end_time'])",
"workerdata",
".",
"append",
"(",
"sum",
"(",
"[",
"a",
"[",
"'start_time'",
"]",
"[",
"0",
"]",
"<=",
"float",
"(",
"graphtime",
")",
"/",
"1000.",
"<=",
"a",
"[",
"'end_time'",
"]",
"[",
"0",
"]",
"for",
"a",
"in",
"vals",
".",
"values",
"(",
")",
"if",
"a",
"[",
"'start_time'",
"]",
"and",
"a",
"[",
"'end_time'",
"]",
"]",
")",
")",
"except",
"OverflowError",
":",
"print",
"(",
"\"Error processing {0} or {1}\"",
".",
"format",
"(",
"start_time",
",",
"end_time",
")",
")",
"graphdata",
".",
"append",
"(",
"workerdata",
")",
"if",
"args",
".",
"binarydensity",
":",
"# Normalize [...]",
"maxval",
"=",
"max",
"(",
"graphdata",
"[",
"-",
"1",
"]",
")",
"if",
"maxval",
">",
"1",
":",
"maxval",
"=",
"maxval",
"-",
"1",
"graphdata",
"[",
"-",
"1",
"]",
"=",
"[",
"x",
"-",
"maxval",
"for",
"x",
"in",
"graphdata",
"[",
"-",
"1",
"]",
"]",
"return",
"graphdata"
] |
Return the worker density data for the graph.
|
[
"Return",
"the",
"worker",
"density",
"data",
"for",
"the",
"graph",
"."
] |
d391dfa62f47e49d48328ee9cf08aa114256fd33
|
https://github.com/soravux/scoop/blob/d391dfa62f47e49d48328ee9cf08aa114256fd33/bench/process_debug.py#L97-L130
|
10,912
|
soravux/scoop
|
bench/process_debug.py
|
plotDensity
|
def plotDensity(dataTask, filename):
"""Plot the worker density graph"""
#def format_worker(x, pos=None):
# """Formats the worker name"""
# #workers = filter (lambda a: a[:6] != "broker", dataTask.keys())
# workers = [a for a in dataTask.keys() if a[:6] != "broker"]
# return workers[x]
def format_time(x, pos=None):
"""Formats the time"""
start_time, end_time = [(a - begin_time) / 1000 for a in getTimes(dataTask)]
return int(end_time * x / DENSITY_MAP_TIME_AXIS_LENGTH)
graphdata = WorkersDensity(dataTask)
if len(graphdata):
fig = plt.figure()
ax = fig.add_subplot(111)
box = ax.get_position()
ax.set_position([box.x0 + 0.15 * box.width, box.y0, box.width, box.height])
#cax = ax.imshow(graphdata, interpolation='nearest', aspect='auto')
if args.binarydensity:
cmap = ListedColormap(['r', 'g'])
norm = BoundaryNorm([0, 0.5, 1], cmap.N)
cax = ax.imshow(graphdata, interpolation='nearest', aspect='auto', cmap=cmap, norm=norm)
else:
cax = ax.imshow(graphdata, interpolation='nearest', aspect='auto')
plt.xlabel('time (s)'); plt.ylabel('Worker'); ax.set_title('Work density')
ax.yaxis.set_ticks(range(len(graphdata)))
ax.tick_params(axis='both', which='major', labelsize=6)
#ax.yaxis.set_major_formatter(ticker.FuncFormatter(format_worker))
interval_size = DENSITY_MAP_TIME_AXIS_LENGTH // 4
ax.xaxis.set_ticks(range(0,
DENSITY_MAP_TIME_AXIS_LENGTH + interval_size,
interval_size))
ax.xaxis.set_major_formatter(ticker.FuncFormatter(format_time))
if args.binarydensity:
cax.set_clim(0, 1)
cbar = fig.colorbar(cax, ticks=[0, 1])
else:
cbar = fig.colorbar(cax)
fig.savefig(filename)
|
python
|
def plotDensity(dataTask, filename):
"""Plot the worker density graph"""
#def format_worker(x, pos=None):
# """Formats the worker name"""
# #workers = filter (lambda a: a[:6] != "broker", dataTask.keys())
# workers = [a for a in dataTask.keys() if a[:6] != "broker"]
# return workers[x]
def format_time(x, pos=None):
"""Formats the time"""
start_time, end_time = [(a - begin_time) / 1000 for a in getTimes(dataTask)]
return int(end_time * x / DENSITY_MAP_TIME_AXIS_LENGTH)
graphdata = WorkersDensity(dataTask)
if len(graphdata):
fig = plt.figure()
ax = fig.add_subplot(111)
box = ax.get_position()
ax.set_position([box.x0 + 0.15 * box.width, box.y0, box.width, box.height])
#cax = ax.imshow(graphdata, interpolation='nearest', aspect='auto')
if args.binarydensity:
cmap = ListedColormap(['r', 'g'])
norm = BoundaryNorm([0, 0.5, 1], cmap.N)
cax = ax.imshow(graphdata, interpolation='nearest', aspect='auto', cmap=cmap, norm=norm)
else:
cax = ax.imshow(graphdata, interpolation='nearest', aspect='auto')
plt.xlabel('time (s)'); plt.ylabel('Worker'); ax.set_title('Work density')
ax.yaxis.set_ticks(range(len(graphdata)))
ax.tick_params(axis='both', which='major', labelsize=6)
#ax.yaxis.set_major_formatter(ticker.FuncFormatter(format_worker))
interval_size = DENSITY_MAP_TIME_AXIS_LENGTH // 4
ax.xaxis.set_ticks(range(0,
DENSITY_MAP_TIME_AXIS_LENGTH + interval_size,
interval_size))
ax.xaxis.set_major_formatter(ticker.FuncFormatter(format_time))
if args.binarydensity:
cax.set_clim(0, 1)
cbar = fig.colorbar(cax, ticks=[0, 1])
else:
cbar = fig.colorbar(cax)
fig.savefig(filename)
|
[
"def",
"plotDensity",
"(",
"dataTask",
",",
"filename",
")",
":",
"#def format_worker(x, pos=None):",
"# \"\"\"Formats the worker name\"\"\"",
"# #workers = filter (lambda a: a[:6] != \"broker\", dataTask.keys())",
"# workers = [a for a in dataTask.keys() if a[:6] != \"broker\"]",
"# return workers[x]",
"def",
"format_time",
"(",
"x",
",",
"pos",
"=",
"None",
")",
":",
"\"\"\"Formats the time\"\"\"",
"start_time",
",",
"end_time",
"=",
"[",
"(",
"a",
"-",
"begin_time",
")",
"/",
"1000",
"for",
"a",
"in",
"getTimes",
"(",
"dataTask",
")",
"]",
"return",
"int",
"(",
"end_time",
"*",
"x",
"/",
"DENSITY_MAP_TIME_AXIS_LENGTH",
")",
"graphdata",
"=",
"WorkersDensity",
"(",
"dataTask",
")",
"if",
"len",
"(",
"graphdata",
")",
":",
"fig",
"=",
"plt",
".",
"figure",
"(",
")",
"ax",
"=",
"fig",
".",
"add_subplot",
"(",
"111",
")",
"box",
"=",
"ax",
".",
"get_position",
"(",
")",
"ax",
".",
"set_position",
"(",
"[",
"box",
".",
"x0",
"+",
"0.15",
"*",
"box",
".",
"width",
",",
"box",
".",
"y0",
",",
"box",
".",
"width",
",",
"box",
".",
"height",
"]",
")",
"#cax = ax.imshow(graphdata, interpolation='nearest', aspect='auto')",
"if",
"args",
".",
"binarydensity",
":",
"cmap",
"=",
"ListedColormap",
"(",
"[",
"'r'",
",",
"'g'",
"]",
")",
"norm",
"=",
"BoundaryNorm",
"(",
"[",
"0",
",",
"0.5",
",",
"1",
"]",
",",
"cmap",
".",
"N",
")",
"cax",
"=",
"ax",
".",
"imshow",
"(",
"graphdata",
",",
"interpolation",
"=",
"'nearest'",
",",
"aspect",
"=",
"'auto'",
",",
"cmap",
"=",
"cmap",
",",
"norm",
"=",
"norm",
")",
"else",
":",
"cax",
"=",
"ax",
".",
"imshow",
"(",
"graphdata",
",",
"interpolation",
"=",
"'nearest'",
",",
"aspect",
"=",
"'auto'",
")",
"plt",
".",
"xlabel",
"(",
"'time (s)'",
")",
"plt",
".",
"ylabel",
"(",
"'Worker'",
")",
"ax",
".",
"set_title",
"(",
"'Work density'",
")",
"ax",
".",
"yaxis",
".",
"set_ticks",
"(",
"range",
"(",
"len",
"(",
"graphdata",
")",
")",
")",
"ax",
".",
"tick_params",
"(",
"axis",
"=",
"'both'",
",",
"which",
"=",
"'major'",
",",
"labelsize",
"=",
"6",
")",
"#ax.yaxis.set_major_formatter(ticker.FuncFormatter(format_worker))",
"interval_size",
"=",
"DENSITY_MAP_TIME_AXIS_LENGTH",
"//",
"4",
"ax",
".",
"xaxis",
".",
"set_ticks",
"(",
"range",
"(",
"0",
",",
"DENSITY_MAP_TIME_AXIS_LENGTH",
"+",
"interval_size",
",",
"interval_size",
")",
")",
"ax",
".",
"xaxis",
".",
"set_major_formatter",
"(",
"ticker",
".",
"FuncFormatter",
"(",
"format_time",
")",
")",
"if",
"args",
".",
"binarydensity",
":",
"cax",
".",
"set_clim",
"(",
"0",
",",
"1",
")",
"cbar",
"=",
"fig",
".",
"colorbar",
"(",
"cax",
",",
"ticks",
"=",
"[",
"0",
",",
"1",
"]",
")",
"else",
":",
"cbar",
"=",
"fig",
".",
"colorbar",
"(",
"cax",
")",
"fig",
".",
"savefig",
"(",
"filename",
")"
] |
Plot the worker density graph
|
[
"Plot",
"the",
"worker",
"density",
"graph"
] |
d391dfa62f47e49d48328ee9cf08aa114256fd33
|
https://github.com/soravux/scoop/blob/d391dfa62f47e49d48328ee9cf08aa114256fd33/bench/process_debug.py#L132-L173
|
10,913
|
soravux/scoop
|
bench/process_debug.py
|
plotBrokerQueue
|
def plotBrokerQueue(dataTask, filename):
"""Generates the broker queue length graphic."""
print("Plotting broker queue length for {0}.".format(filename))
plt.figure()
# Queue length
plt.subplot(211)
for fichier, vals in dataTask.items():
if type(vals) == list:
timestamps = list(map(datetime.fromtimestamp, map(int, list(zip(*vals))[0])))
# Data is from broker
plt.plot_date(timestamps, list(zip(*vals))[2],
linewidth=1.0,
marker='o',
markersize=2,
label=fichier)
plt.title('Broker queue length')
plt.ylabel('Tasks')
# Requests received
plt.subplot(212)
for fichier, vals in dataTask.items():
if type(vals) == list:
timestamps = list(map(datetime.fromtimestamp, map(int, list(zip(*vals))[0])))
# Data is from broker
plt.plot_date(timestamps, list(zip(*vals))[3],
linewidth=1.0,
marker='o',
markersize=2,
label=fichier)
plt.title('Broker pending requests')
plt.xlabel('time (s)')
plt.ylabel('Requests')
plt.savefig(filename)
|
python
|
def plotBrokerQueue(dataTask, filename):
"""Generates the broker queue length graphic."""
print("Plotting broker queue length for {0}.".format(filename))
plt.figure()
# Queue length
plt.subplot(211)
for fichier, vals in dataTask.items():
if type(vals) == list:
timestamps = list(map(datetime.fromtimestamp, map(int, list(zip(*vals))[0])))
# Data is from broker
plt.plot_date(timestamps, list(zip(*vals))[2],
linewidth=1.0,
marker='o',
markersize=2,
label=fichier)
plt.title('Broker queue length')
plt.ylabel('Tasks')
# Requests received
plt.subplot(212)
for fichier, vals in dataTask.items():
if type(vals) == list:
timestamps = list(map(datetime.fromtimestamp, map(int, list(zip(*vals))[0])))
# Data is from broker
plt.plot_date(timestamps, list(zip(*vals))[3],
linewidth=1.0,
marker='o',
markersize=2,
label=fichier)
plt.title('Broker pending requests')
plt.xlabel('time (s)')
plt.ylabel('Requests')
plt.savefig(filename)
|
[
"def",
"plotBrokerQueue",
"(",
"dataTask",
",",
"filename",
")",
":",
"print",
"(",
"\"Plotting broker queue length for {0}.\"",
".",
"format",
"(",
"filename",
")",
")",
"plt",
".",
"figure",
"(",
")",
"# Queue length",
"plt",
".",
"subplot",
"(",
"211",
")",
"for",
"fichier",
",",
"vals",
"in",
"dataTask",
".",
"items",
"(",
")",
":",
"if",
"type",
"(",
"vals",
")",
"==",
"list",
":",
"timestamps",
"=",
"list",
"(",
"map",
"(",
"datetime",
".",
"fromtimestamp",
",",
"map",
"(",
"int",
",",
"list",
"(",
"zip",
"(",
"*",
"vals",
")",
")",
"[",
"0",
"]",
")",
")",
")",
"# Data is from broker",
"plt",
".",
"plot_date",
"(",
"timestamps",
",",
"list",
"(",
"zip",
"(",
"*",
"vals",
")",
")",
"[",
"2",
"]",
",",
"linewidth",
"=",
"1.0",
",",
"marker",
"=",
"'o'",
",",
"markersize",
"=",
"2",
",",
"label",
"=",
"fichier",
")",
"plt",
".",
"title",
"(",
"'Broker queue length'",
")",
"plt",
".",
"ylabel",
"(",
"'Tasks'",
")",
"# Requests received",
"plt",
".",
"subplot",
"(",
"212",
")",
"for",
"fichier",
",",
"vals",
"in",
"dataTask",
".",
"items",
"(",
")",
":",
"if",
"type",
"(",
"vals",
")",
"==",
"list",
":",
"timestamps",
"=",
"list",
"(",
"map",
"(",
"datetime",
".",
"fromtimestamp",
",",
"map",
"(",
"int",
",",
"list",
"(",
"zip",
"(",
"*",
"vals",
")",
")",
"[",
"0",
"]",
")",
")",
")",
"# Data is from broker",
"plt",
".",
"plot_date",
"(",
"timestamps",
",",
"list",
"(",
"zip",
"(",
"*",
"vals",
")",
")",
"[",
"3",
"]",
",",
"linewidth",
"=",
"1.0",
",",
"marker",
"=",
"'o'",
",",
"markersize",
"=",
"2",
",",
"label",
"=",
"fichier",
")",
"plt",
".",
"title",
"(",
"'Broker pending requests'",
")",
"plt",
".",
"xlabel",
"(",
"'time (s)'",
")",
"plt",
".",
"ylabel",
"(",
"'Requests'",
")",
"plt",
".",
"savefig",
"(",
"filename",
")"
] |
Generates the broker queue length graphic.
|
[
"Generates",
"the",
"broker",
"queue",
"length",
"graphic",
"."
] |
d391dfa62f47e49d48328ee9cf08aa114256fd33
|
https://github.com/soravux/scoop/blob/d391dfa62f47e49d48328ee9cf08aa114256fd33/bench/process_debug.py#L175-L209
|
10,914
|
soravux/scoop
|
bench/process_debug.py
|
getWorkerInfo
|
def getWorkerInfo(dataTask):
"""Returns the total execution time and task quantity by worker"""
workertime = []
workertasks = []
for fichier, vals in dataTask.items():
if hasattr(vals, 'values'):
#workers_names.append(fichier)
# Data from worker
totaltime = sum([a['executionTime'] for a in vals.values()])
totaltasks = sum([1 for a in vals.values()])
workertime.append(totaltime)
workertasks.append(totaltasks)
return workertime, workertasks
|
python
|
def getWorkerInfo(dataTask):
"""Returns the total execution time and task quantity by worker"""
workertime = []
workertasks = []
for fichier, vals in dataTask.items():
if hasattr(vals, 'values'):
#workers_names.append(fichier)
# Data from worker
totaltime = sum([a['executionTime'] for a in vals.values()])
totaltasks = sum([1 for a in vals.values()])
workertime.append(totaltime)
workertasks.append(totaltasks)
return workertime, workertasks
|
[
"def",
"getWorkerInfo",
"(",
"dataTask",
")",
":",
"workertime",
"=",
"[",
"]",
"workertasks",
"=",
"[",
"]",
"for",
"fichier",
",",
"vals",
"in",
"dataTask",
".",
"items",
"(",
")",
":",
"if",
"hasattr",
"(",
"vals",
",",
"'values'",
")",
":",
"#workers_names.append(fichier)",
"# Data from worker",
"totaltime",
"=",
"sum",
"(",
"[",
"a",
"[",
"'executionTime'",
"]",
"for",
"a",
"in",
"vals",
".",
"values",
"(",
")",
"]",
")",
"totaltasks",
"=",
"sum",
"(",
"[",
"1",
"for",
"a",
"in",
"vals",
".",
"values",
"(",
")",
"]",
")",
"workertime",
".",
"append",
"(",
"totaltime",
")",
"workertasks",
".",
"append",
"(",
"totaltasks",
")",
"return",
"workertime",
",",
"workertasks"
] |
Returns the total execution time and task quantity by worker
|
[
"Returns",
"the",
"total",
"execution",
"time",
"and",
"task",
"quantity",
"by",
"worker"
] |
d391dfa62f47e49d48328ee9cf08aa114256fd33
|
https://github.com/soravux/scoop/blob/d391dfa62f47e49d48328ee9cf08aa114256fd33/bench/process_debug.py#L234-L246
|
10,915
|
soravux/scoop
|
bench/process_debug.py
|
timelines
|
def timelines(fig, y, xstart, xstop, color='b'):
"""Plot timelines at y from xstart to xstop with given color."""
fig.hlines(y, xstart, xstop, color, lw=4)
fig.vlines(xstart, y+0.03, y-0.03, color, lw=2)
fig.vlines(xstop, y+0.03, y-0.03, color, lw=2)
|
python
|
def timelines(fig, y, xstart, xstop, color='b'):
"""Plot timelines at y from xstart to xstop with given color."""
fig.hlines(y, xstart, xstop, color, lw=4)
fig.vlines(xstart, y+0.03, y-0.03, color, lw=2)
fig.vlines(xstop, y+0.03, y-0.03, color, lw=2)
|
[
"def",
"timelines",
"(",
"fig",
",",
"y",
",",
"xstart",
",",
"xstop",
",",
"color",
"=",
"'b'",
")",
":",
"fig",
".",
"hlines",
"(",
"y",
",",
"xstart",
",",
"xstop",
",",
"color",
",",
"lw",
"=",
"4",
")",
"fig",
".",
"vlines",
"(",
"xstart",
",",
"y",
"+",
"0.03",
",",
"y",
"-",
"0.03",
",",
"color",
",",
"lw",
"=",
"2",
")",
"fig",
".",
"vlines",
"(",
"xstop",
",",
"y",
"+",
"0.03",
",",
"y",
"-",
"0.03",
",",
"color",
",",
"lw",
"=",
"2",
")"
] |
Plot timelines at y from xstart to xstop with given color.
|
[
"Plot",
"timelines",
"at",
"y",
"from",
"xstart",
"to",
"xstop",
"with",
"given",
"color",
"."
] |
d391dfa62f47e49d48328ee9cf08aa114256fd33
|
https://github.com/soravux/scoop/blob/d391dfa62f47e49d48328ee9cf08aa114256fd33/bench/process_debug.py#L331-L335
|
10,916
|
soravux/scoop
|
bench/process_debug.py
|
plotTimeline
|
def plotTimeline(dataTask, filename):
"""Build a timeline"""
fig = plt.figure()
ax = fig.gca()
worker_names = [x for x in dataTask.keys() if "broker" not in x]
min_time = getMinimumTime(dataTask)
ystep = 1. / (len(worker_names) + 1)
y = 0
for worker, vals in dataTask.items():
if "broker" in worker:
continue
y += ystep
if hasattr(vals, 'values'):
for future in vals.values():
start_time = [future['start_time'][0] - min_time]
end_time = [future['end_time'][0] - min_time]
timelines(ax, y, start_time, end_time)
#ax.xaxis_date()
#myFmt = DateFormatter('%H:%M:%S')
#ax.xaxis.set_major_formatter(myFmt)
#ax.xaxis.set_major_locator(SecondLocator(0, interval=20))
#delta = (stop.max() - start.min())/10
ax.set_yticks(np.arange(ystep, 1, ystep))
ax.set_yticklabels(worker_names)
ax.set_ylim(0, 1)
#fig.xlim()
ax.set_xlabel('Time')
fig.savefig(filename)
|
python
|
def plotTimeline(dataTask, filename):
"""Build a timeline"""
fig = plt.figure()
ax = fig.gca()
worker_names = [x for x in dataTask.keys() if "broker" not in x]
min_time = getMinimumTime(dataTask)
ystep = 1. / (len(worker_names) + 1)
y = 0
for worker, vals in dataTask.items():
if "broker" in worker:
continue
y += ystep
if hasattr(vals, 'values'):
for future in vals.values():
start_time = [future['start_time'][0] - min_time]
end_time = [future['end_time'][0] - min_time]
timelines(ax, y, start_time, end_time)
#ax.xaxis_date()
#myFmt = DateFormatter('%H:%M:%S')
#ax.xaxis.set_major_formatter(myFmt)
#ax.xaxis.set_major_locator(SecondLocator(0, interval=20))
#delta = (stop.max() - start.min())/10
ax.set_yticks(np.arange(ystep, 1, ystep))
ax.set_yticklabels(worker_names)
ax.set_ylim(0, 1)
#fig.xlim()
ax.set_xlabel('Time')
fig.savefig(filename)
|
[
"def",
"plotTimeline",
"(",
"dataTask",
",",
"filename",
")",
":",
"fig",
"=",
"plt",
".",
"figure",
"(",
")",
"ax",
"=",
"fig",
".",
"gca",
"(",
")",
"worker_names",
"=",
"[",
"x",
"for",
"x",
"in",
"dataTask",
".",
"keys",
"(",
")",
"if",
"\"broker\"",
"not",
"in",
"x",
"]",
"min_time",
"=",
"getMinimumTime",
"(",
"dataTask",
")",
"ystep",
"=",
"1.",
"/",
"(",
"len",
"(",
"worker_names",
")",
"+",
"1",
")",
"y",
"=",
"0",
"for",
"worker",
",",
"vals",
"in",
"dataTask",
".",
"items",
"(",
")",
":",
"if",
"\"broker\"",
"in",
"worker",
":",
"continue",
"y",
"+=",
"ystep",
"if",
"hasattr",
"(",
"vals",
",",
"'values'",
")",
":",
"for",
"future",
"in",
"vals",
".",
"values",
"(",
")",
":",
"start_time",
"=",
"[",
"future",
"[",
"'start_time'",
"]",
"[",
"0",
"]",
"-",
"min_time",
"]",
"end_time",
"=",
"[",
"future",
"[",
"'end_time'",
"]",
"[",
"0",
"]",
"-",
"min_time",
"]",
"timelines",
"(",
"ax",
",",
"y",
",",
"start_time",
",",
"end_time",
")",
"#ax.xaxis_date()",
"#myFmt = DateFormatter('%H:%M:%S')",
"#ax.xaxis.set_major_formatter(myFmt)",
"#ax.xaxis.set_major_locator(SecondLocator(0, interval=20))",
"#delta = (stop.max() - start.min())/10",
"ax",
".",
"set_yticks",
"(",
"np",
".",
"arange",
"(",
"ystep",
",",
"1",
",",
"ystep",
")",
")",
"ax",
".",
"set_yticklabels",
"(",
"worker_names",
")",
"ax",
".",
"set_ylim",
"(",
"0",
",",
"1",
")",
"#fig.xlim()",
"ax",
".",
"set_xlabel",
"(",
"'Time'",
")",
"fig",
".",
"savefig",
"(",
"filename",
")"
] |
Build a timeline
|
[
"Build",
"a",
"timeline"
] |
d391dfa62f47e49d48328ee9cf08aa114256fd33
|
https://github.com/soravux/scoop/blob/d391dfa62f47e49d48328ee9cf08aa114256fd33/bench/process_debug.py#L350-L383
|
10,917
|
soravux/scoop
|
scoop/launch/workerLaunch.py
|
Host.setWorker
|
def setWorker(self, *args, **kwargs):
"""Add a worker assignation
Arguments and order to pass are defined in LAUNCHING_ARGUMENTS
Using named args is advised.
"""
try:
la = self.LAUNCHING_ARGUMENTS(*args, **kwargs)
except TypeError as e:
scoop.logger.error(("addWorker failed to convert args %s and kwargs %s "
"to namedtuple (requires %s arguments (names %s)") %
(args, kwargs, len(self.LAUNCHING_ARGUMENTS._fields),
self.LAUNCHING_ARGUMENTS._fields))
self.workersArguments = la
|
python
|
def setWorker(self, *args, **kwargs):
"""Add a worker assignation
Arguments and order to pass are defined in LAUNCHING_ARGUMENTS
Using named args is advised.
"""
try:
la = self.LAUNCHING_ARGUMENTS(*args, **kwargs)
except TypeError as e:
scoop.logger.error(("addWorker failed to convert args %s and kwargs %s "
"to namedtuple (requires %s arguments (names %s)") %
(args, kwargs, len(self.LAUNCHING_ARGUMENTS._fields),
self.LAUNCHING_ARGUMENTS._fields))
self.workersArguments = la
|
[
"def",
"setWorker",
"(",
"self",
",",
"*",
"args",
",",
"*",
"*",
"kwargs",
")",
":",
"try",
":",
"la",
"=",
"self",
".",
"LAUNCHING_ARGUMENTS",
"(",
"*",
"args",
",",
"*",
"*",
"kwargs",
")",
"except",
"TypeError",
"as",
"e",
":",
"scoop",
".",
"logger",
".",
"error",
"(",
"(",
"\"addWorker failed to convert args %s and kwargs %s \"",
"\"to namedtuple (requires %s arguments (names %s)\"",
")",
"%",
"(",
"args",
",",
"kwargs",
",",
"len",
"(",
"self",
".",
"LAUNCHING_ARGUMENTS",
".",
"_fields",
")",
",",
"self",
".",
"LAUNCHING_ARGUMENTS",
".",
"_fields",
")",
")",
"self",
".",
"workersArguments",
"=",
"la"
] |
Add a worker assignation
Arguments and order to pass are defined in LAUNCHING_ARGUMENTS
Using named args is advised.
|
[
"Add",
"a",
"worker",
"assignation",
"Arguments",
"and",
"order",
"to",
"pass",
"are",
"defined",
"in",
"LAUNCHING_ARGUMENTS",
"Using",
"named",
"args",
"is",
"advised",
"."
] |
d391dfa62f47e49d48328ee9cf08aa114256fd33
|
https://github.com/soravux/scoop/blob/d391dfa62f47e49d48328ee9cf08aa114256fd33/scoop/launch/workerLaunch.py#L61-L74
|
10,918
|
soravux/scoop
|
scoop/launch/workerLaunch.py
|
Host._WorkerCommand_environment
|
def _WorkerCommand_environment(self):
"""Return list of shell commands to prepare the environment for
bootstrap."""
worker = self.workersArguments
c = []
if worker.prolog:
c.extend([
"source",
worker.prolog,
"&&",
])
if worker.pythonPath and not self.isLocal():
# Tried to make it compliant to all shell variants.
c.extend([
"env",
"PYTHONPATH={0}:$PYTHONPATH".format(worker.pythonPath),
])
elif worker.pythonPath and self.isLocal():
# Tried to make it compliant to all shell variants.
c.extend([
"env",
"PYTHONPATH={0}:{1}".format(
worker.pythonPath,
os.environ.get("PYTHONPATH", ""),
),
])
return c
|
python
|
def _WorkerCommand_environment(self):
"""Return list of shell commands to prepare the environment for
bootstrap."""
worker = self.workersArguments
c = []
if worker.prolog:
c.extend([
"source",
worker.prolog,
"&&",
])
if worker.pythonPath and not self.isLocal():
# Tried to make it compliant to all shell variants.
c.extend([
"env",
"PYTHONPATH={0}:$PYTHONPATH".format(worker.pythonPath),
])
elif worker.pythonPath and self.isLocal():
# Tried to make it compliant to all shell variants.
c.extend([
"env",
"PYTHONPATH={0}:{1}".format(
worker.pythonPath,
os.environ.get("PYTHONPATH", ""),
),
])
return c
|
[
"def",
"_WorkerCommand_environment",
"(",
"self",
")",
":",
"worker",
"=",
"self",
".",
"workersArguments",
"c",
"=",
"[",
"]",
"if",
"worker",
".",
"prolog",
":",
"c",
".",
"extend",
"(",
"[",
"\"source\"",
",",
"worker",
".",
"prolog",
",",
"\"&&\"",
",",
"]",
")",
"if",
"worker",
".",
"pythonPath",
"and",
"not",
"self",
".",
"isLocal",
"(",
")",
":",
"# Tried to make it compliant to all shell variants.",
"c",
".",
"extend",
"(",
"[",
"\"env\"",
",",
"\"PYTHONPATH={0}:$PYTHONPATH\"",
".",
"format",
"(",
"worker",
".",
"pythonPath",
")",
",",
"]",
")",
"elif",
"worker",
".",
"pythonPath",
"and",
"self",
".",
"isLocal",
"(",
")",
":",
"# Tried to make it compliant to all shell variants.",
"c",
".",
"extend",
"(",
"[",
"\"env\"",
",",
"\"PYTHONPATH={0}:{1}\"",
".",
"format",
"(",
"worker",
".",
"pythonPath",
",",
"os",
".",
"environ",
".",
"get",
"(",
"\"PYTHONPATH\"",
",",
"\"\"",
")",
",",
")",
",",
"]",
")",
"return",
"c"
] |
Return list of shell commands to prepare the environment for
bootstrap.
|
[
"Return",
"list",
"of",
"shell",
"commands",
"to",
"prepare",
"the",
"environment",
"for",
"bootstrap",
"."
] |
d391dfa62f47e49d48328ee9cf08aa114256fd33
|
https://github.com/soravux/scoop/blob/d391dfa62f47e49d48328ee9cf08aa114256fd33/scoop/launch/workerLaunch.py#L80-L106
|
10,919
|
soravux/scoop
|
scoop/launch/workerLaunch.py
|
Host._WorkerCommand_launcher
|
def _WorkerCommand_launcher(self):
"""Return list commands to start the bootstrap process"""
return [
self.workersArguments.pythonExecutable,
'-m',
'scoop.launch.__main__',
str(self.workerAmount),
str(self.workersArguments.verbose),
]
|
python
|
def _WorkerCommand_launcher(self):
"""Return list commands to start the bootstrap process"""
return [
self.workersArguments.pythonExecutable,
'-m',
'scoop.launch.__main__',
str(self.workerAmount),
str(self.workersArguments.verbose),
]
|
[
"def",
"_WorkerCommand_launcher",
"(",
"self",
")",
":",
"return",
"[",
"self",
".",
"workersArguments",
".",
"pythonExecutable",
",",
"'-m'",
",",
"'scoop.launch.__main__'",
",",
"str",
"(",
"self",
".",
"workerAmount",
")",
",",
"str",
"(",
"self",
".",
"workersArguments",
".",
"verbose",
")",
",",
"]"
] |
Return list commands to start the bootstrap process
|
[
"Return",
"list",
"commands",
"to",
"start",
"the",
"bootstrap",
"process"
] |
d391dfa62f47e49d48328ee9cf08aa114256fd33
|
https://github.com/soravux/scoop/blob/d391dfa62f47e49d48328ee9cf08aa114256fd33/scoop/launch/workerLaunch.py#L108-L116
|
10,920
|
soravux/scoop
|
scoop/launch/workerLaunch.py
|
Host._WorkerCommand_options
|
def _WorkerCommand_options(self):
"""Return list of options for bootstrap"""
worker = self.workersArguments
c = []
# If broker is on localhost
if self.hostname == worker.brokerHostname:
broker = "127.0.0.1"
else:
broker = worker.brokerHostname
if worker.nice is not None:
c.extend(['--nice', str(worker.nice)])
c.extend(['--size', str(worker.size)])
if self.isLocal():
c.extend(['--workingDirectory', str(worker.path)])
else:
c.extend(['--workingDirectory', '"{0}"'.format(str(worker.path))])
c.extend(['--brokerHostname', broker])
c.extend(['--externalBrokerHostname', worker.brokerHostname])
c.extend(['--taskPort', str(worker.brokerPorts[0])])
c.extend(['--metaPort', str(worker.brokerPorts[1])])
if worker.origin and worker.executable:
c.append('--origin')
if worker.debug:
c.append('--debug')
if worker.profiling:
c.append('--profile')
if worker.backend:
c.append('--backend={0}'.format(worker.backend))
if worker.verbose >= 1:
c.append('-' + 'v' * worker.verbose)
return c
|
python
|
def _WorkerCommand_options(self):
"""Return list of options for bootstrap"""
worker = self.workersArguments
c = []
# If broker is on localhost
if self.hostname == worker.brokerHostname:
broker = "127.0.0.1"
else:
broker = worker.brokerHostname
if worker.nice is not None:
c.extend(['--nice', str(worker.nice)])
c.extend(['--size', str(worker.size)])
if self.isLocal():
c.extend(['--workingDirectory', str(worker.path)])
else:
c.extend(['--workingDirectory', '"{0}"'.format(str(worker.path))])
c.extend(['--brokerHostname', broker])
c.extend(['--externalBrokerHostname', worker.brokerHostname])
c.extend(['--taskPort', str(worker.brokerPorts[0])])
c.extend(['--metaPort', str(worker.brokerPorts[1])])
if worker.origin and worker.executable:
c.append('--origin')
if worker.debug:
c.append('--debug')
if worker.profiling:
c.append('--profile')
if worker.backend:
c.append('--backend={0}'.format(worker.backend))
if worker.verbose >= 1:
c.append('-' + 'v' * worker.verbose)
return c
|
[
"def",
"_WorkerCommand_options",
"(",
"self",
")",
":",
"worker",
"=",
"self",
".",
"workersArguments",
"c",
"=",
"[",
"]",
"# If broker is on localhost",
"if",
"self",
".",
"hostname",
"==",
"worker",
".",
"brokerHostname",
":",
"broker",
"=",
"\"127.0.0.1\"",
"else",
":",
"broker",
"=",
"worker",
".",
"brokerHostname",
"if",
"worker",
".",
"nice",
"is",
"not",
"None",
":",
"c",
".",
"extend",
"(",
"[",
"'--nice'",
",",
"str",
"(",
"worker",
".",
"nice",
")",
"]",
")",
"c",
".",
"extend",
"(",
"[",
"'--size'",
",",
"str",
"(",
"worker",
".",
"size",
")",
"]",
")",
"if",
"self",
".",
"isLocal",
"(",
")",
":",
"c",
".",
"extend",
"(",
"[",
"'--workingDirectory'",
",",
"str",
"(",
"worker",
".",
"path",
")",
"]",
")",
"else",
":",
"c",
".",
"extend",
"(",
"[",
"'--workingDirectory'",
",",
"'\"{0}\"'",
".",
"format",
"(",
"str",
"(",
"worker",
".",
"path",
")",
")",
"]",
")",
"c",
".",
"extend",
"(",
"[",
"'--brokerHostname'",
",",
"broker",
"]",
")",
"c",
".",
"extend",
"(",
"[",
"'--externalBrokerHostname'",
",",
"worker",
".",
"brokerHostname",
"]",
")",
"c",
".",
"extend",
"(",
"[",
"'--taskPort'",
",",
"str",
"(",
"worker",
".",
"brokerPorts",
"[",
"0",
"]",
")",
"]",
")",
"c",
".",
"extend",
"(",
"[",
"'--metaPort'",
",",
"str",
"(",
"worker",
".",
"brokerPorts",
"[",
"1",
"]",
")",
"]",
")",
"if",
"worker",
".",
"origin",
"and",
"worker",
".",
"executable",
":",
"c",
".",
"append",
"(",
"'--origin'",
")",
"if",
"worker",
".",
"debug",
":",
"c",
".",
"append",
"(",
"'--debug'",
")",
"if",
"worker",
".",
"profiling",
":",
"c",
".",
"append",
"(",
"'--profile'",
")",
"if",
"worker",
".",
"backend",
":",
"c",
".",
"append",
"(",
"'--backend={0}'",
".",
"format",
"(",
"worker",
".",
"backend",
")",
")",
"if",
"worker",
".",
"verbose",
">=",
"1",
":",
"c",
".",
"append",
"(",
"'-'",
"+",
"'v'",
"*",
"worker",
".",
"verbose",
")",
"return",
"c"
] |
Return list of options for bootstrap
|
[
"Return",
"list",
"of",
"options",
"for",
"bootstrap"
] |
d391dfa62f47e49d48328ee9cf08aa114256fd33
|
https://github.com/soravux/scoop/blob/d391dfa62f47e49d48328ee9cf08aa114256fd33/scoop/launch/workerLaunch.py#L118-L150
|
10,921
|
soravux/scoop
|
scoop/launch/workerLaunch.py
|
Host._WorkerCommand_executable
|
def _WorkerCommand_executable(self):
"""Return executable and any options to be executed by bootstrap"""
worker = self.workersArguments
c = []
if worker.executable:
c.append(worker.executable)
# This trick is used to parse correctly quotes
# (ie. myScript.py 'arg1 "arg2" arg3')
# Because it is parsed by a shell, every quote gets re-interpreted.
# It replaces simple quotation marks with \\\" which gets evaluated to
# \" by the second shell which prints it out as a double quote.
if worker.args:
if self.isLocal():
# If local, no shell is used so no escaping needed
c.extend([
'{0}'.format(a) for a in worker.args
])
else:
c.extend([
'"{0}"'.format(a.replace('"', '\\\"')) for a in worker.args
])
return c
|
python
|
def _WorkerCommand_executable(self):
"""Return executable and any options to be executed by bootstrap"""
worker = self.workersArguments
c = []
if worker.executable:
c.append(worker.executable)
# This trick is used to parse correctly quotes
# (ie. myScript.py 'arg1 "arg2" arg3')
# Because it is parsed by a shell, every quote gets re-interpreted.
# It replaces simple quotation marks with \\\" which gets evaluated to
# \" by the second shell which prints it out as a double quote.
if worker.args:
if self.isLocal():
# If local, no shell is used so no escaping needed
c.extend([
'{0}'.format(a) for a in worker.args
])
else:
c.extend([
'"{0}"'.format(a.replace('"', '\\\"')) for a in worker.args
])
return c
|
[
"def",
"_WorkerCommand_executable",
"(",
"self",
")",
":",
"worker",
"=",
"self",
".",
"workersArguments",
"c",
"=",
"[",
"]",
"if",
"worker",
".",
"executable",
":",
"c",
".",
"append",
"(",
"worker",
".",
"executable",
")",
"# This trick is used to parse correctly quotes",
"# (ie. myScript.py 'arg1 \"arg2\" arg3')",
"# Because it is parsed by a shell, every quote gets re-interpreted.",
"# It replaces simple quotation marks with \\\\\\\" which gets evaluated to",
"# \\\" by the second shell which prints it out as a double quote.",
"if",
"worker",
".",
"args",
":",
"if",
"self",
".",
"isLocal",
"(",
")",
":",
"# If local, no shell is used so no escaping needed",
"c",
".",
"extend",
"(",
"[",
"'{0}'",
".",
"format",
"(",
"a",
")",
"for",
"a",
"in",
"worker",
".",
"args",
"]",
")",
"else",
":",
"c",
".",
"extend",
"(",
"[",
"'\"{0}\"'",
".",
"format",
"(",
"a",
".",
"replace",
"(",
"'\"'",
",",
"'\\\\\\\"'",
")",
")",
"for",
"a",
"in",
"worker",
".",
"args",
"]",
")",
"return",
"c"
] |
Return executable and any options to be executed by bootstrap
|
[
"Return",
"executable",
"and",
"any",
"options",
"to",
"be",
"executed",
"by",
"bootstrap"
] |
d391dfa62f47e49d48328ee9cf08aa114256fd33
|
https://github.com/soravux/scoop/blob/d391dfa62f47e49d48328ee9cf08aa114256fd33/scoop/launch/workerLaunch.py#L152-L174
|
10,922
|
soravux/scoop
|
scoop/launch/workerLaunch.py
|
Host._getWorkerCommandList
|
def _getWorkerCommandList(self):
"""Generate the workerCommand as list"""
c = []
c.extend(self._WorkerCommand_environment())
c.extend(self._WorkerCommand_launcher())
c.extend(self._WorkerCommand_options())
c.extend(self._WorkerCommand_executable())
return c
|
python
|
def _getWorkerCommandList(self):
"""Generate the workerCommand as list"""
c = []
c.extend(self._WorkerCommand_environment())
c.extend(self._WorkerCommand_launcher())
c.extend(self._WorkerCommand_options())
c.extend(self._WorkerCommand_executable())
return c
|
[
"def",
"_getWorkerCommandList",
"(",
"self",
")",
":",
"c",
"=",
"[",
"]",
"c",
".",
"extend",
"(",
"self",
".",
"_WorkerCommand_environment",
"(",
")",
")",
"c",
".",
"extend",
"(",
"self",
".",
"_WorkerCommand_launcher",
"(",
")",
")",
"c",
".",
"extend",
"(",
"self",
".",
"_WorkerCommand_options",
"(",
")",
")",
"c",
".",
"extend",
"(",
"self",
".",
"_WorkerCommand_executable",
"(",
")",
")",
"return",
"c"
] |
Generate the workerCommand as list
|
[
"Generate",
"the",
"workerCommand",
"as",
"list"
] |
d391dfa62f47e49d48328ee9cf08aa114256fd33
|
https://github.com/soravux/scoop/blob/d391dfa62f47e49d48328ee9cf08aa114256fd33/scoop/launch/workerLaunch.py#L176-L184
|
10,923
|
soravux/scoop
|
scoop/launch/workerLaunch.py
|
Host.launch
|
def launch(self, tunnelPorts=None):
"""Launch every worker assigned on this host."""
if self.isLocal():
# Launching local workers
c = self._getWorkerCommandList()
self.subprocesses.append(subprocess.Popen(c))
else:
# Launching remotely
BASE_SSH[0] = self.ssh_executable
sshCmd = BASE_SSH if not self.rsh else BASE_RSH
if tunnelPorts is not None:
sshCmd += [
'-R {0}:127.0.0.1:{0}'.format(tunnelPorts[0]),
'-R {0}:127.0.0.1:{0}'.format(tunnelPorts[1]),
]
self.subprocesses.append(
subprocess.Popen(sshCmd + [self.hostname, self.getCommand()],
bufsize=-1,
stdout=None,
stderr=None,
stdin=subprocess.PIPE
)
)
return self.subprocesses
|
python
|
def launch(self, tunnelPorts=None):
"""Launch every worker assigned on this host."""
if self.isLocal():
# Launching local workers
c = self._getWorkerCommandList()
self.subprocesses.append(subprocess.Popen(c))
else:
# Launching remotely
BASE_SSH[0] = self.ssh_executable
sshCmd = BASE_SSH if not self.rsh else BASE_RSH
if tunnelPorts is not None:
sshCmd += [
'-R {0}:127.0.0.1:{0}'.format(tunnelPorts[0]),
'-R {0}:127.0.0.1:{0}'.format(tunnelPorts[1]),
]
self.subprocesses.append(
subprocess.Popen(sshCmd + [self.hostname, self.getCommand()],
bufsize=-1,
stdout=None,
stderr=None,
stdin=subprocess.PIPE
)
)
return self.subprocesses
|
[
"def",
"launch",
"(",
"self",
",",
"tunnelPorts",
"=",
"None",
")",
":",
"if",
"self",
".",
"isLocal",
"(",
")",
":",
"# Launching local workers",
"c",
"=",
"self",
".",
"_getWorkerCommandList",
"(",
")",
"self",
".",
"subprocesses",
".",
"append",
"(",
"subprocess",
".",
"Popen",
"(",
"c",
")",
")",
"else",
":",
"# Launching remotely",
"BASE_SSH",
"[",
"0",
"]",
"=",
"self",
".",
"ssh_executable",
"sshCmd",
"=",
"BASE_SSH",
"if",
"not",
"self",
".",
"rsh",
"else",
"BASE_RSH",
"if",
"tunnelPorts",
"is",
"not",
"None",
":",
"sshCmd",
"+=",
"[",
"'-R {0}:127.0.0.1:{0}'",
".",
"format",
"(",
"tunnelPorts",
"[",
"0",
"]",
")",
",",
"'-R {0}:127.0.0.1:{0}'",
".",
"format",
"(",
"tunnelPorts",
"[",
"1",
"]",
")",
",",
"]",
"self",
".",
"subprocesses",
".",
"append",
"(",
"subprocess",
".",
"Popen",
"(",
"sshCmd",
"+",
"[",
"self",
".",
"hostname",
",",
"self",
".",
"getCommand",
"(",
")",
"]",
",",
"bufsize",
"=",
"-",
"1",
",",
"stdout",
"=",
"None",
",",
"stderr",
"=",
"None",
",",
"stdin",
"=",
"subprocess",
".",
"PIPE",
")",
")",
"return",
"self",
".",
"subprocesses"
] |
Launch every worker assigned on this host.
|
[
"Launch",
"every",
"worker",
"assigned",
"on",
"this",
"host",
"."
] |
d391dfa62f47e49d48328ee9cf08aa114256fd33
|
https://github.com/soravux/scoop/blob/d391dfa62f47e49d48328ee9cf08aa114256fd33/scoop/launch/workerLaunch.py#L190-L214
|
10,924
|
soravux/scoop
|
scoop/_types.py
|
Future._switch
|
def _switch(self, future):
"""Switch greenlet."""
scoop._control.current = self
assert self.greenlet is not None, ("No greenlet to switch to:"
"\n{0}".format(self.__dict__))
return self.greenlet.switch(future)
|
python
|
def _switch(self, future):
"""Switch greenlet."""
scoop._control.current = self
assert self.greenlet is not None, ("No greenlet to switch to:"
"\n{0}".format(self.__dict__))
return self.greenlet.switch(future)
|
[
"def",
"_switch",
"(",
"self",
",",
"future",
")",
":",
"scoop",
".",
"_control",
".",
"current",
"=",
"self",
"assert",
"self",
".",
"greenlet",
"is",
"not",
"None",
",",
"(",
"\"No greenlet to switch to:\"",
"\"\\n{0}\"",
".",
"format",
"(",
"self",
".",
"__dict__",
")",
")",
"return",
"self",
".",
"greenlet",
".",
"switch",
"(",
"future",
")"
] |
Switch greenlet.
|
[
"Switch",
"greenlet",
"."
] |
d391dfa62f47e49d48328ee9cf08aa114256fd33
|
https://github.com/soravux/scoop/blob/d391dfa62f47e49d48328ee9cf08aa114256fd33/scoop/_types.py#L134-L139
|
10,925
|
soravux/scoop
|
scoop/_types.py
|
Future.cancel
|
def cancel(self):
"""If the call is currently being executed or sent for remote
execution, then it cannot be cancelled and the method will return
False, otherwise the call will be cancelled and the method will
return True."""
if self in scoop._control.execQueue.movable:
self.exceptionValue = CancelledError()
scoop._control.futureDict[self.id]._delete()
scoop._control.execQueue.remove(self)
return True
return False
|
python
|
def cancel(self):
"""If the call is currently being executed or sent for remote
execution, then it cannot be cancelled and the method will return
False, otherwise the call will be cancelled and the method will
return True."""
if self in scoop._control.execQueue.movable:
self.exceptionValue = CancelledError()
scoop._control.futureDict[self.id]._delete()
scoop._control.execQueue.remove(self)
return True
return False
|
[
"def",
"cancel",
"(",
"self",
")",
":",
"if",
"self",
"in",
"scoop",
".",
"_control",
".",
"execQueue",
".",
"movable",
":",
"self",
".",
"exceptionValue",
"=",
"CancelledError",
"(",
")",
"scoop",
".",
"_control",
".",
"futureDict",
"[",
"self",
".",
"id",
"]",
".",
"_delete",
"(",
")",
"scoop",
".",
"_control",
".",
"execQueue",
".",
"remove",
"(",
"self",
")",
"return",
"True",
"return",
"False"
] |
If the call is currently being executed or sent for remote
execution, then it cannot be cancelled and the method will return
False, otherwise the call will be cancelled and the method will
return True.
|
[
"If",
"the",
"call",
"is",
"currently",
"being",
"executed",
"or",
"sent",
"for",
"remote",
"execution",
"then",
"it",
"cannot",
"be",
"cancelled",
"and",
"the",
"method",
"will",
"return",
"False",
"otherwise",
"the",
"call",
"will",
"be",
"cancelled",
"and",
"the",
"method",
"will",
"return",
"True",
"."
] |
d391dfa62f47e49d48328ee9cf08aa114256fd33
|
https://github.com/soravux/scoop/blob/d391dfa62f47e49d48328ee9cf08aa114256fd33/scoop/_types.py#L141-L151
|
10,926
|
soravux/scoop
|
scoop/_types.py
|
Future.done
|
def done(self):
"""Returns True if the call was successfully cancelled or finished
running, False otherwise. This function updates the executionQueue
so it receives all the awaiting message."""
# Flush the current future in the local buffer (potential deadlock
# otherwise)
try:
scoop._control.execQueue.remove(self)
scoop._control.execQueue.socket.sendFuture(self)
except ValueError as e:
# Future was not in the local queue, everything is fine
pass
# Process buffers
scoop._control.execQueue.updateQueue()
return self._ended()
|
python
|
def done(self):
"""Returns True if the call was successfully cancelled or finished
running, False otherwise. This function updates the executionQueue
so it receives all the awaiting message."""
# Flush the current future in the local buffer (potential deadlock
# otherwise)
try:
scoop._control.execQueue.remove(self)
scoop._control.execQueue.socket.sendFuture(self)
except ValueError as e:
# Future was not in the local queue, everything is fine
pass
# Process buffers
scoop._control.execQueue.updateQueue()
return self._ended()
|
[
"def",
"done",
"(",
"self",
")",
":",
"# Flush the current future in the local buffer (potential deadlock",
"# otherwise)",
"try",
":",
"scoop",
".",
"_control",
".",
"execQueue",
".",
"remove",
"(",
"self",
")",
"scoop",
".",
"_control",
".",
"execQueue",
".",
"socket",
".",
"sendFuture",
"(",
"self",
")",
"except",
"ValueError",
"as",
"e",
":",
"# Future was not in the local queue, everything is fine",
"pass",
"# Process buffers",
"scoop",
".",
"_control",
".",
"execQueue",
".",
"updateQueue",
"(",
")",
"return",
"self",
".",
"_ended",
"(",
")"
] |
Returns True if the call was successfully cancelled or finished
running, False otherwise. This function updates the executionQueue
so it receives all the awaiting message.
|
[
"Returns",
"True",
"if",
"the",
"call",
"was",
"successfully",
"cancelled",
"or",
"finished",
"running",
"False",
"otherwise",
".",
"This",
"function",
"updates",
"the",
"executionQueue",
"so",
"it",
"receives",
"all",
"the",
"awaiting",
"message",
"."
] |
d391dfa62f47e49d48328ee9cf08aa114256fd33
|
https://github.com/soravux/scoop/blob/d391dfa62f47e49d48328ee9cf08aa114256fd33/scoop/_types.py#L163-L177
|
10,927
|
soravux/scoop
|
scoop/_types.py
|
Future.add_done_callback
|
def add_done_callback(self, callable_,
inCallbackType=CallbackType.standard,
inCallbackGroup=None):
"""Attach a callable to the future that will be called when the future
is cancelled or finishes running. Callable will be called with the
future as its only argument.
Added callables are called in the order that they were added and are
always called in a thread belonging to the process that added them. If
the callable raises an Exception then it will be logged and ignored. If
the callable raises another BaseException then behavior is not defined.
If the future has already completed or been cancelled then callable will
be called immediately."""
self.callback.append(callbackEntry(callable_,
inCallbackType,
inCallbackGroup))
# If already completed or cancelled, execute it immediately
if self._ended():
self.callback[-1].func(self)
|
python
|
def add_done_callback(self, callable_,
inCallbackType=CallbackType.standard,
inCallbackGroup=None):
"""Attach a callable to the future that will be called when the future
is cancelled or finishes running. Callable will be called with the
future as its only argument.
Added callables are called in the order that they were added and are
always called in a thread belonging to the process that added them. If
the callable raises an Exception then it will be logged and ignored. If
the callable raises another BaseException then behavior is not defined.
If the future has already completed or been cancelled then callable will
be called immediately."""
self.callback.append(callbackEntry(callable_,
inCallbackType,
inCallbackGroup))
# If already completed or cancelled, execute it immediately
if self._ended():
self.callback[-1].func(self)
|
[
"def",
"add_done_callback",
"(",
"self",
",",
"callable_",
",",
"inCallbackType",
"=",
"CallbackType",
".",
"standard",
",",
"inCallbackGroup",
"=",
"None",
")",
":",
"self",
".",
"callback",
".",
"append",
"(",
"callbackEntry",
"(",
"callable_",
",",
"inCallbackType",
",",
"inCallbackGroup",
")",
")",
"# If already completed or cancelled, execute it immediately",
"if",
"self",
".",
"_ended",
"(",
")",
":",
"self",
".",
"callback",
"[",
"-",
"1",
"]",
".",
"func",
"(",
"self",
")"
] |
Attach a callable to the future that will be called when the future
is cancelled or finishes running. Callable will be called with the
future as its only argument.
Added callables are called in the order that they were added and are
always called in a thread belonging to the process that added them. If
the callable raises an Exception then it will be logged and ignored. If
the callable raises another BaseException then behavior is not defined.
If the future has already completed or been cancelled then callable will
be called immediately.
|
[
"Attach",
"a",
"callable",
"to",
"the",
"future",
"that",
"will",
"be",
"called",
"when",
"the",
"future",
"is",
"cancelled",
"or",
"finishes",
"running",
".",
"Callable",
"will",
"be",
"called",
"with",
"the",
"future",
"as",
"its",
"only",
"argument",
"."
] |
d391dfa62f47e49d48328ee9cf08aa114256fd33
|
https://github.com/soravux/scoop/blob/d391dfa62f47e49d48328ee9cf08aa114256fd33/scoop/_types.py#L221-L241
|
10,928
|
soravux/scoop
|
scoop/_types.py
|
FutureQueue.append
|
def append(self, future):
"""Append a future to the queue."""
if future._ended() and future.index is None:
self.inprogress.add(future)
elif future._ended() and future.index is not None:
self.ready.append(future)
elif future.greenlet is not None:
self.inprogress.add(future)
else:
self.movable.append(future)
# Send the oldest future in the movable deque until under the hwm
over_hwm = self.timelen(self.movable) > self.highwatermark
while over_hwm and len(self.movable) > 1:
sending_future = self.movable.popleft()
if sending_future.id[0] != scoop.worker:
sending_future._delete()
self.socket.sendFuture(sending_future)
over_hwm = self.timelen(self.movable) > self.highwatermark
|
python
|
def append(self, future):
"""Append a future to the queue."""
if future._ended() and future.index is None:
self.inprogress.add(future)
elif future._ended() and future.index is not None:
self.ready.append(future)
elif future.greenlet is not None:
self.inprogress.add(future)
else:
self.movable.append(future)
# Send the oldest future in the movable deque until under the hwm
over_hwm = self.timelen(self.movable) > self.highwatermark
while over_hwm and len(self.movable) > 1:
sending_future = self.movable.popleft()
if sending_future.id[0] != scoop.worker:
sending_future._delete()
self.socket.sendFuture(sending_future)
over_hwm = self.timelen(self.movable) > self.highwatermark
|
[
"def",
"append",
"(",
"self",
",",
"future",
")",
":",
"if",
"future",
".",
"_ended",
"(",
")",
"and",
"future",
".",
"index",
"is",
"None",
":",
"self",
".",
"inprogress",
".",
"add",
"(",
"future",
")",
"elif",
"future",
".",
"_ended",
"(",
")",
"and",
"future",
".",
"index",
"is",
"not",
"None",
":",
"self",
".",
"ready",
".",
"append",
"(",
"future",
")",
"elif",
"future",
".",
"greenlet",
"is",
"not",
"None",
":",
"self",
".",
"inprogress",
".",
"add",
"(",
"future",
")",
"else",
":",
"self",
".",
"movable",
".",
"append",
"(",
"future",
")",
"# Send the oldest future in the movable deque until under the hwm",
"over_hwm",
"=",
"self",
".",
"timelen",
"(",
"self",
".",
"movable",
")",
">",
"self",
".",
"highwatermark",
"while",
"over_hwm",
"and",
"len",
"(",
"self",
".",
"movable",
")",
">",
"1",
":",
"sending_future",
"=",
"self",
".",
"movable",
".",
"popleft",
"(",
")",
"if",
"sending_future",
".",
"id",
"[",
"0",
"]",
"!=",
"scoop",
".",
"worker",
":",
"sending_future",
".",
"_delete",
"(",
")",
"self",
".",
"socket",
".",
"sendFuture",
"(",
"sending_future",
")",
"over_hwm",
"=",
"self",
".",
"timelen",
"(",
"self",
".",
"movable",
")",
">",
"self",
".",
"highwatermark"
] |
Append a future to the queue.
|
[
"Append",
"a",
"future",
"to",
"the",
"queue",
"."
] |
d391dfa62f47e49d48328ee9cf08aa114256fd33
|
https://github.com/soravux/scoop/blob/d391dfa62f47e49d48328ee9cf08aa114256fd33/scoop/_types.py#L299-L317
|
10,929
|
soravux/scoop
|
scoop/_types.py
|
FutureQueue.askForPreviousFutures
|
def askForPreviousFutures(self):
"""Request a status for every future to the broker."""
# Don't request it too often (otherwise it ping-pongs because)
# the broker answer triggers the _poll of pop()
if time.time() < self.lastStatus + POLLING_TIME / 1000:
return
self.lastStatus = time.time()
for future in scoop._control.futureDict.values():
# Skip the root future
if scoop.IS_ORIGIN and future.id == (scoop.worker, 0):
continue
if future not in self.inprogress:
self.socket.sendStatusRequest(future)
|
python
|
def askForPreviousFutures(self):
"""Request a status for every future to the broker."""
# Don't request it too often (otherwise it ping-pongs because)
# the broker answer triggers the _poll of pop()
if time.time() < self.lastStatus + POLLING_TIME / 1000:
return
self.lastStatus = time.time()
for future in scoop._control.futureDict.values():
# Skip the root future
if scoop.IS_ORIGIN and future.id == (scoop.worker, 0):
continue
if future not in self.inprogress:
self.socket.sendStatusRequest(future)
|
[
"def",
"askForPreviousFutures",
"(",
"self",
")",
":",
"# Don't request it too often (otherwise it ping-pongs because)",
"# the broker answer triggers the _poll of pop()",
"if",
"time",
".",
"time",
"(",
")",
"<",
"self",
".",
"lastStatus",
"+",
"POLLING_TIME",
"/",
"1000",
":",
"return",
"self",
".",
"lastStatus",
"=",
"time",
".",
"time",
"(",
")",
"for",
"future",
"in",
"scoop",
".",
"_control",
".",
"futureDict",
".",
"values",
"(",
")",
":",
"# Skip the root future",
"if",
"scoop",
".",
"IS_ORIGIN",
"and",
"future",
".",
"id",
"==",
"(",
"scoop",
".",
"worker",
",",
"0",
")",
":",
"continue",
"if",
"future",
"not",
"in",
"self",
".",
"inprogress",
":",
"self",
".",
"socket",
".",
"sendStatusRequest",
"(",
"future",
")"
] |
Request a status for every future to the broker.
|
[
"Request",
"a",
"status",
"for",
"every",
"future",
"to",
"the",
"broker",
"."
] |
d391dfa62f47e49d48328ee9cf08aa114256fd33
|
https://github.com/soravux/scoop/blob/d391dfa62f47e49d48328ee9cf08aa114256fd33/scoop/_types.py#L319-L333
|
10,930
|
soravux/scoop
|
scoop/_types.py
|
FutureQueue.pop
|
def pop(self):
"""Pop the next future from the queue;
in progress futures have priority over those that have not yet started;
higher level futures have priority over lower level ones; """
self.updateQueue()
# If our buffer is underflowing, request more Futures
if self.timelen(self) < self.lowwatermark:
self.requestFuture()
# If an unmovable Future is ready to be executed, return it
if len(self.ready) != 0:
return self.ready.popleft()
# Then, use Futures in the movable queue
elif len(self.movable) != 0:
return self.movable.popleft()
else:
# Otherwise, block until a new task arrives
self.lastStatus = time.time()
while len(self) == 0:
# Block until message arrives
self.askForPreviousFutures()
self.socket._poll(POLLING_TIME)
self.updateQueue()
if len(self.ready) != 0:
return self.ready.popleft()
elif len(self.movable) != 0:
return self.movable.popleft()
|
python
|
def pop(self):
"""Pop the next future from the queue;
in progress futures have priority over those that have not yet started;
higher level futures have priority over lower level ones; """
self.updateQueue()
# If our buffer is underflowing, request more Futures
if self.timelen(self) < self.lowwatermark:
self.requestFuture()
# If an unmovable Future is ready to be executed, return it
if len(self.ready) != 0:
return self.ready.popleft()
# Then, use Futures in the movable queue
elif len(self.movable) != 0:
return self.movable.popleft()
else:
# Otherwise, block until a new task arrives
self.lastStatus = time.time()
while len(self) == 0:
# Block until message arrives
self.askForPreviousFutures()
self.socket._poll(POLLING_TIME)
self.updateQueue()
if len(self.ready) != 0:
return self.ready.popleft()
elif len(self.movable) != 0:
return self.movable.popleft()
|
[
"def",
"pop",
"(",
"self",
")",
":",
"self",
".",
"updateQueue",
"(",
")",
"# If our buffer is underflowing, request more Futures",
"if",
"self",
".",
"timelen",
"(",
"self",
")",
"<",
"self",
".",
"lowwatermark",
":",
"self",
".",
"requestFuture",
"(",
")",
"# If an unmovable Future is ready to be executed, return it",
"if",
"len",
"(",
"self",
".",
"ready",
")",
"!=",
"0",
":",
"return",
"self",
".",
"ready",
".",
"popleft",
"(",
")",
"# Then, use Futures in the movable queue",
"elif",
"len",
"(",
"self",
".",
"movable",
")",
"!=",
"0",
":",
"return",
"self",
".",
"movable",
".",
"popleft",
"(",
")",
"else",
":",
"# Otherwise, block until a new task arrives",
"self",
".",
"lastStatus",
"=",
"time",
".",
"time",
"(",
")",
"while",
"len",
"(",
"self",
")",
"==",
"0",
":",
"# Block until message arrives",
"self",
".",
"askForPreviousFutures",
"(",
")",
"self",
".",
"socket",
".",
"_poll",
"(",
"POLLING_TIME",
")",
"self",
".",
"updateQueue",
"(",
")",
"if",
"len",
"(",
"self",
".",
"ready",
")",
"!=",
"0",
":",
"return",
"self",
".",
"ready",
".",
"popleft",
"(",
")",
"elif",
"len",
"(",
"self",
".",
"movable",
")",
"!=",
"0",
":",
"return",
"self",
".",
"movable",
".",
"popleft",
"(",
")"
] |
Pop the next future from the queue;
in progress futures have priority over those that have not yet started;
higher level futures have priority over lower level ones;
|
[
"Pop",
"the",
"next",
"future",
"from",
"the",
"queue",
";",
"in",
"progress",
"futures",
"have",
"priority",
"over",
"those",
"that",
"have",
"not",
"yet",
"started",
";",
"higher",
"level",
"futures",
"have",
"priority",
"over",
"lower",
"level",
"ones",
";"
] |
d391dfa62f47e49d48328ee9cf08aa114256fd33
|
https://github.com/soravux/scoop/blob/d391dfa62f47e49d48328ee9cf08aa114256fd33/scoop/_types.py#L335-L363
|
10,931
|
soravux/scoop
|
scoop/_types.py
|
FutureQueue.flush
|
def flush(self):
"""Empty the local queue and send its elements to be executed remotely.
"""
for elem in self:
if elem.id[0] != scoop.worker:
elem._delete()
self.socket.sendFuture(elem)
self.ready.clear()
self.movable.clear()
|
python
|
def flush(self):
"""Empty the local queue and send its elements to be executed remotely.
"""
for elem in self:
if elem.id[0] != scoop.worker:
elem._delete()
self.socket.sendFuture(elem)
self.ready.clear()
self.movable.clear()
|
[
"def",
"flush",
"(",
"self",
")",
":",
"for",
"elem",
"in",
"self",
":",
"if",
"elem",
".",
"id",
"[",
"0",
"]",
"!=",
"scoop",
".",
"worker",
":",
"elem",
".",
"_delete",
"(",
")",
"self",
".",
"socket",
".",
"sendFuture",
"(",
"elem",
")",
"self",
".",
"ready",
".",
"clear",
"(",
")",
"self",
".",
"movable",
".",
"clear",
"(",
")"
] |
Empty the local queue and send its elements to be executed remotely.
|
[
"Empty",
"the",
"local",
"queue",
"and",
"send",
"its",
"elements",
"to",
"be",
"executed",
"remotely",
"."
] |
d391dfa62f47e49d48328ee9cf08aa114256fd33
|
https://github.com/soravux/scoop/blob/d391dfa62f47e49d48328ee9cf08aa114256fd33/scoop/_types.py#L365-L373
|
10,932
|
soravux/scoop
|
scoop/_types.py
|
FutureQueue.updateQueue
|
def updateQueue(self):
"""Process inbound communication buffer.
Updates the local queue with elements from the broker."""
for future in self.socket.recvFuture():
if future._ended():
# If the answer is coming back, update its entry
try:
thisFuture = scoop._control.futureDict[future.id]
except KeyError:
# Already received?
scoop.logger.warn('{0}: Received an unexpected future: '
'{1}'.format(scoop.worker, future.id))
continue
thisFuture.resultValue = future.resultValue
thisFuture.exceptionValue = future.exceptionValue
thisFuture.executor = future.executor
thisFuture.isDone = future.isDone
# Execute standard callbacks here (on parent)
thisFuture._execute_callbacks(CallbackType.standard)
self.append(thisFuture)
future._delete()
elif future.id not in scoop._control.futureDict:
scoop._control.futureDict[future.id] = future
self.append(scoop._control.futureDict[future.id])
else:
self.append(scoop._control.futureDict[future.id])
|
python
|
def updateQueue(self):
"""Process inbound communication buffer.
Updates the local queue with elements from the broker."""
for future in self.socket.recvFuture():
if future._ended():
# If the answer is coming back, update its entry
try:
thisFuture = scoop._control.futureDict[future.id]
except KeyError:
# Already received?
scoop.logger.warn('{0}: Received an unexpected future: '
'{1}'.format(scoop.worker, future.id))
continue
thisFuture.resultValue = future.resultValue
thisFuture.exceptionValue = future.exceptionValue
thisFuture.executor = future.executor
thisFuture.isDone = future.isDone
# Execute standard callbacks here (on parent)
thisFuture._execute_callbacks(CallbackType.standard)
self.append(thisFuture)
future._delete()
elif future.id not in scoop._control.futureDict:
scoop._control.futureDict[future.id] = future
self.append(scoop._control.futureDict[future.id])
else:
self.append(scoop._control.futureDict[future.id])
|
[
"def",
"updateQueue",
"(",
"self",
")",
":",
"for",
"future",
"in",
"self",
".",
"socket",
".",
"recvFuture",
"(",
")",
":",
"if",
"future",
".",
"_ended",
"(",
")",
":",
"# If the answer is coming back, update its entry",
"try",
":",
"thisFuture",
"=",
"scoop",
".",
"_control",
".",
"futureDict",
"[",
"future",
".",
"id",
"]",
"except",
"KeyError",
":",
"# Already received?",
"scoop",
".",
"logger",
".",
"warn",
"(",
"'{0}: Received an unexpected future: '",
"'{1}'",
".",
"format",
"(",
"scoop",
".",
"worker",
",",
"future",
".",
"id",
")",
")",
"continue",
"thisFuture",
".",
"resultValue",
"=",
"future",
".",
"resultValue",
"thisFuture",
".",
"exceptionValue",
"=",
"future",
".",
"exceptionValue",
"thisFuture",
".",
"executor",
"=",
"future",
".",
"executor",
"thisFuture",
".",
"isDone",
"=",
"future",
".",
"isDone",
"# Execute standard callbacks here (on parent)",
"thisFuture",
".",
"_execute_callbacks",
"(",
"CallbackType",
".",
"standard",
")",
"self",
".",
"append",
"(",
"thisFuture",
")",
"future",
".",
"_delete",
"(",
")",
"elif",
"future",
".",
"id",
"not",
"in",
"scoop",
".",
"_control",
".",
"futureDict",
":",
"scoop",
".",
"_control",
".",
"futureDict",
"[",
"future",
".",
"id",
"]",
"=",
"future",
"self",
".",
"append",
"(",
"scoop",
".",
"_control",
".",
"futureDict",
"[",
"future",
".",
"id",
"]",
")",
"else",
":",
"self",
".",
"append",
"(",
"scoop",
".",
"_control",
".",
"futureDict",
"[",
"future",
".",
"id",
"]",
")"
] |
Process inbound communication buffer.
Updates the local queue with elements from the broker.
|
[
"Process",
"inbound",
"communication",
"buffer",
".",
"Updates",
"the",
"local",
"queue",
"with",
"elements",
"from",
"the",
"broker",
"."
] |
d391dfa62f47e49d48328ee9cf08aa114256fd33
|
https://github.com/soravux/scoop/blob/d391dfa62f47e49d48328ee9cf08aa114256fd33/scoop/_types.py#L379-L404
|
10,933
|
soravux/scoop
|
scoop/_types.py
|
FutureQueue.sendResult
|
def sendResult(self, future):
"""Send back results to broker for distribution to parent task."""
# Greenlets cannot be pickled
future.greenlet = None
assert future._ended(), "The results are not valid"
self.socket.sendResult(future)
|
python
|
def sendResult(self, future):
"""Send back results to broker for distribution to parent task."""
# Greenlets cannot be pickled
future.greenlet = None
assert future._ended(), "The results are not valid"
self.socket.sendResult(future)
|
[
"def",
"sendResult",
"(",
"self",
",",
"future",
")",
":",
"# Greenlets cannot be pickled",
"future",
".",
"greenlet",
"=",
"None",
"assert",
"future",
".",
"_ended",
"(",
")",
",",
"\"The results are not valid\"",
"self",
".",
"socket",
".",
"sendResult",
"(",
"future",
")"
] |
Send back results to broker for distribution to parent task.
|
[
"Send",
"back",
"results",
"to",
"broker",
"for",
"distribution",
"to",
"parent",
"task",
"."
] |
d391dfa62f47e49d48328ee9cf08aa114256fd33
|
https://github.com/soravux/scoop/blob/d391dfa62f47e49d48328ee9cf08aa114256fd33/scoop/_types.py#L411-L416
|
10,934
|
soravux/scoop
|
scoop/_types.py
|
FutureQueue.shutdown
|
def shutdown(self):
"""Shutdown the ressources used by the queue"""
self.socket.shutdown()
if scoop:
if scoop.DEBUG:
from scoop import _debug
_debug.writeWorkerDebug(
scoop._control.debug_stats,
scoop._control.QueueLength,
)
|
python
|
def shutdown(self):
"""Shutdown the ressources used by the queue"""
self.socket.shutdown()
if scoop:
if scoop.DEBUG:
from scoop import _debug
_debug.writeWorkerDebug(
scoop._control.debug_stats,
scoop._control.QueueLength,
)
|
[
"def",
"shutdown",
"(",
"self",
")",
":",
"self",
".",
"socket",
".",
"shutdown",
"(",
")",
"if",
"scoop",
":",
"if",
"scoop",
".",
"DEBUG",
":",
"from",
"scoop",
"import",
"_debug",
"_debug",
".",
"writeWorkerDebug",
"(",
"scoop",
".",
"_control",
".",
"debug_stats",
",",
"scoop",
".",
"_control",
".",
"QueueLength",
",",
")"
] |
Shutdown the ressources used by the queue
|
[
"Shutdown",
"the",
"ressources",
"used",
"by",
"the",
"queue"
] |
d391dfa62f47e49d48328ee9cf08aa114256fd33
|
https://github.com/soravux/scoop/blob/d391dfa62f47e49d48328ee9cf08aa114256fd33/scoop/_types.py#L418-L428
|
10,935
|
soravux/scoop
|
scoop/_debug.py
|
redirectSTDOUTtoDebugFile
|
def redirectSTDOUTtoDebugFile():
"""Redirects the stdout and stderr of the current process to a file."""
import sys
kwargs = {}
if sys.version_info >= (3,):
kwargs["encoding"] = "utf8"
sys.stdout = open(
os.path.join(
getDebugDirectory(),
"{0}.stdout".format(getDebugIdentifier()),
),
"w",
1, # Buffering by line
**kwargs
)
sys.stderr = open(
os.path.join(
getDebugDirectory(),
"{0}.stderr".format(getDebugIdentifier()),
),
"w",
1, # Buffering by line
**kwargs
)
|
python
|
def redirectSTDOUTtoDebugFile():
"""Redirects the stdout and stderr of the current process to a file."""
import sys
kwargs = {}
if sys.version_info >= (3,):
kwargs["encoding"] = "utf8"
sys.stdout = open(
os.path.join(
getDebugDirectory(),
"{0}.stdout".format(getDebugIdentifier()),
),
"w",
1, # Buffering by line
**kwargs
)
sys.stderr = open(
os.path.join(
getDebugDirectory(),
"{0}.stderr".format(getDebugIdentifier()),
),
"w",
1, # Buffering by line
**kwargs
)
|
[
"def",
"redirectSTDOUTtoDebugFile",
"(",
")",
":",
"import",
"sys",
"kwargs",
"=",
"{",
"}",
"if",
"sys",
".",
"version_info",
">=",
"(",
"3",
",",
")",
":",
"kwargs",
"[",
"\"encoding\"",
"]",
"=",
"\"utf8\"",
"sys",
".",
"stdout",
"=",
"open",
"(",
"os",
".",
"path",
".",
"join",
"(",
"getDebugDirectory",
"(",
")",
",",
"\"{0}.stdout\"",
".",
"format",
"(",
"getDebugIdentifier",
"(",
")",
")",
",",
")",
",",
"\"w\"",
",",
"1",
",",
"# Buffering by line",
"*",
"*",
"kwargs",
")",
"sys",
".",
"stderr",
"=",
"open",
"(",
"os",
".",
"path",
".",
"join",
"(",
"getDebugDirectory",
"(",
")",
",",
"\"{0}.stderr\"",
".",
"format",
"(",
"getDebugIdentifier",
"(",
")",
")",
",",
")",
",",
"\"w\"",
",",
"1",
",",
"# Buffering by line",
"*",
"*",
"kwargs",
")"
] |
Redirects the stdout and stderr of the current process to a file.
|
[
"Redirects",
"the",
"stdout",
"and",
"stderr",
"of",
"the",
"current",
"process",
"to",
"a",
"file",
"."
] |
d391dfa62f47e49d48328ee9cf08aa114256fd33
|
https://github.com/soravux/scoop/blob/d391dfa62f47e49d48328ee9cf08aa114256fd33/scoop/_debug.py#L46-L69
|
10,936
|
soravux/scoop
|
scoop/_debug.py
|
writeWorkerDebug
|
def writeWorkerDebug(debugStats, queueLength, path_suffix=""):
"""Serialize the execution data using pickle and writes it into the debug
directory."""
createDirectory(path_suffix)
origin_prefix = "origin-" if scoop.IS_ORIGIN else ""
statsFilename = os.path.join(
getDebugDirectory(),
path_suffix,
"{1}worker-{0}-STATS".format(getDebugIdentifier(), origin_prefix)
)
lengthFilename = os.path.join(
getDebugDirectory(),
path_suffix,
"{1}worker-{0}-QUEUE".format(getDebugIdentifier(), origin_prefix)
)
with open(statsFilename, 'wb') as f:
pickle.dump(debugStats, f)
with open(lengthFilename, 'wb') as f:
pickle.dump(queueLength, f)
|
python
|
def writeWorkerDebug(debugStats, queueLength, path_suffix=""):
"""Serialize the execution data using pickle and writes it into the debug
directory."""
createDirectory(path_suffix)
origin_prefix = "origin-" if scoop.IS_ORIGIN else ""
statsFilename = os.path.join(
getDebugDirectory(),
path_suffix,
"{1}worker-{0}-STATS".format(getDebugIdentifier(), origin_prefix)
)
lengthFilename = os.path.join(
getDebugDirectory(),
path_suffix,
"{1}worker-{0}-QUEUE".format(getDebugIdentifier(), origin_prefix)
)
with open(statsFilename, 'wb') as f:
pickle.dump(debugStats, f)
with open(lengthFilename, 'wb') as f:
pickle.dump(queueLength, f)
|
[
"def",
"writeWorkerDebug",
"(",
"debugStats",
",",
"queueLength",
",",
"path_suffix",
"=",
"\"\"",
")",
":",
"createDirectory",
"(",
"path_suffix",
")",
"origin_prefix",
"=",
"\"origin-\"",
"if",
"scoop",
".",
"IS_ORIGIN",
"else",
"\"\"",
"statsFilename",
"=",
"os",
".",
"path",
".",
"join",
"(",
"getDebugDirectory",
"(",
")",
",",
"path_suffix",
",",
"\"{1}worker-{0}-STATS\"",
".",
"format",
"(",
"getDebugIdentifier",
"(",
")",
",",
"origin_prefix",
")",
")",
"lengthFilename",
"=",
"os",
".",
"path",
".",
"join",
"(",
"getDebugDirectory",
"(",
")",
",",
"path_suffix",
",",
"\"{1}worker-{0}-QUEUE\"",
".",
"format",
"(",
"getDebugIdentifier",
"(",
")",
",",
"origin_prefix",
")",
")",
"with",
"open",
"(",
"statsFilename",
",",
"'wb'",
")",
"as",
"f",
":",
"pickle",
".",
"dump",
"(",
"debugStats",
",",
"f",
")",
"with",
"open",
"(",
"lengthFilename",
",",
"'wb'",
")",
"as",
"f",
":",
"pickle",
".",
"dump",
"(",
"queueLength",
",",
"f",
")"
] |
Serialize the execution data using pickle and writes it into the debug
directory.
|
[
"Serialize",
"the",
"execution",
"data",
"using",
"pickle",
"and",
"writes",
"it",
"into",
"the",
"debug",
"directory",
"."
] |
d391dfa62f47e49d48328ee9cf08aa114256fd33
|
https://github.com/soravux/scoop/blob/d391dfa62f47e49d48328ee9cf08aa114256fd33/scoop/_debug.py#L72-L90
|
10,937
|
soravux/scoop
|
scoop/launcher.py
|
main
|
def main():
"""Execution of the SCOOP module. Parses its command-line arguments and
launch needed resources."""
# Generate a argparse parser and parse the command-line arguments
parser = makeParser()
args = parser.parse_args()
# Get a list of resources to launch worker(s) on
hosts = utils.getHosts(args.hostfile, args.hosts)
if args.n:
n = args.n
else:
n = utils.getWorkerQte(hosts)
assert n >= 0, (
"Scoop couldn't determine the number of worker to start.\n"
"Use the '-n' flag to set it manually."
)
if not args.external_hostname:
args.external_hostname = [utils.externalHostname(hosts)]
# Launch SCOOP
thisScoopApp = ScoopApp(hosts, n, args.b,
args.verbose if not args.quiet else 0,
args.python_interpreter,
args.external_hostname[0],
args.executable, args.args, args.tunnel,
args.path, args.debug, args.nice,
utils.getEnv(), args.profile, args.pythonpath[0],
args.prolog[0], args.backend, args.rsh,
args.ssh_executable)
rootTaskExitCode = False
interruptPreventer = Thread(target=thisScoopApp.close)
try:
rootTaskExitCode = thisScoopApp.run()
except Exception as e:
logging.error('Error while launching SCOOP subprocesses:')
logging.error(traceback.format_exc())
rootTaskExitCode = -1
finally:
# This should not be interrupted (ie. by a KeyboadInterrupt)
# The only cross-platform way to do it I found was by using a thread.
interruptPreventer.start()
interruptPreventer.join()
# Exit with the proper exit code
if rootTaskExitCode:
sys.exit(rootTaskExitCode)
|
python
|
def main():
"""Execution of the SCOOP module. Parses its command-line arguments and
launch needed resources."""
# Generate a argparse parser and parse the command-line arguments
parser = makeParser()
args = parser.parse_args()
# Get a list of resources to launch worker(s) on
hosts = utils.getHosts(args.hostfile, args.hosts)
if args.n:
n = args.n
else:
n = utils.getWorkerQte(hosts)
assert n >= 0, (
"Scoop couldn't determine the number of worker to start.\n"
"Use the '-n' flag to set it manually."
)
if not args.external_hostname:
args.external_hostname = [utils.externalHostname(hosts)]
# Launch SCOOP
thisScoopApp = ScoopApp(hosts, n, args.b,
args.verbose if not args.quiet else 0,
args.python_interpreter,
args.external_hostname[0],
args.executable, args.args, args.tunnel,
args.path, args.debug, args.nice,
utils.getEnv(), args.profile, args.pythonpath[0],
args.prolog[0], args.backend, args.rsh,
args.ssh_executable)
rootTaskExitCode = False
interruptPreventer = Thread(target=thisScoopApp.close)
try:
rootTaskExitCode = thisScoopApp.run()
except Exception as e:
logging.error('Error while launching SCOOP subprocesses:')
logging.error(traceback.format_exc())
rootTaskExitCode = -1
finally:
# This should not be interrupted (ie. by a KeyboadInterrupt)
# The only cross-platform way to do it I found was by using a thread.
interruptPreventer.start()
interruptPreventer.join()
# Exit with the proper exit code
if rootTaskExitCode:
sys.exit(rootTaskExitCode)
|
[
"def",
"main",
"(",
")",
":",
"# Generate a argparse parser and parse the command-line arguments",
"parser",
"=",
"makeParser",
"(",
")",
"args",
"=",
"parser",
".",
"parse_args",
"(",
")",
"# Get a list of resources to launch worker(s) on",
"hosts",
"=",
"utils",
".",
"getHosts",
"(",
"args",
".",
"hostfile",
",",
"args",
".",
"hosts",
")",
"if",
"args",
".",
"n",
":",
"n",
"=",
"args",
".",
"n",
"else",
":",
"n",
"=",
"utils",
".",
"getWorkerQte",
"(",
"hosts",
")",
"assert",
"n",
">=",
"0",
",",
"(",
"\"Scoop couldn't determine the number of worker to start.\\n\"",
"\"Use the '-n' flag to set it manually.\"",
")",
"if",
"not",
"args",
".",
"external_hostname",
":",
"args",
".",
"external_hostname",
"=",
"[",
"utils",
".",
"externalHostname",
"(",
"hosts",
")",
"]",
"# Launch SCOOP",
"thisScoopApp",
"=",
"ScoopApp",
"(",
"hosts",
",",
"n",
",",
"args",
".",
"b",
",",
"args",
".",
"verbose",
"if",
"not",
"args",
".",
"quiet",
"else",
"0",
",",
"args",
".",
"python_interpreter",
",",
"args",
".",
"external_hostname",
"[",
"0",
"]",
",",
"args",
".",
"executable",
",",
"args",
".",
"args",
",",
"args",
".",
"tunnel",
",",
"args",
".",
"path",
",",
"args",
".",
"debug",
",",
"args",
".",
"nice",
",",
"utils",
".",
"getEnv",
"(",
")",
",",
"args",
".",
"profile",
",",
"args",
".",
"pythonpath",
"[",
"0",
"]",
",",
"args",
".",
"prolog",
"[",
"0",
"]",
",",
"args",
".",
"backend",
",",
"args",
".",
"rsh",
",",
"args",
".",
"ssh_executable",
")",
"rootTaskExitCode",
"=",
"False",
"interruptPreventer",
"=",
"Thread",
"(",
"target",
"=",
"thisScoopApp",
".",
"close",
")",
"try",
":",
"rootTaskExitCode",
"=",
"thisScoopApp",
".",
"run",
"(",
")",
"except",
"Exception",
"as",
"e",
":",
"logging",
".",
"error",
"(",
"'Error while launching SCOOP subprocesses:'",
")",
"logging",
".",
"error",
"(",
"traceback",
".",
"format_exc",
"(",
")",
")",
"rootTaskExitCode",
"=",
"-",
"1",
"finally",
":",
"# This should not be interrupted (ie. by a KeyboadInterrupt)",
"# The only cross-platform way to do it I found was by using a thread.",
"interruptPreventer",
".",
"start",
"(",
")",
"interruptPreventer",
".",
"join",
"(",
")",
"# Exit with the proper exit code",
"if",
"rootTaskExitCode",
":",
"sys",
".",
"exit",
"(",
"rootTaskExitCode",
")"
] |
Execution of the SCOOP module. Parses its command-line arguments and
launch needed resources.
|
[
"Execution",
"of",
"the",
"SCOOP",
"module",
".",
"Parses",
"its",
"command",
"-",
"line",
"arguments",
"and",
"launch",
"needed",
"resources",
"."
] |
d391dfa62f47e49d48328ee9cf08aa114256fd33
|
https://github.com/soravux/scoop/blob/d391dfa62f47e49d48328ee9cf08aa114256fd33/scoop/launcher.py#L450-L499
|
10,938
|
soravux/scoop
|
scoop/launcher.py
|
ScoopApp.initLogging
|
def initLogging(self):
"""Configures the logger."""
verbose_levels = {
0: logging.WARNING,
1: logging.INFO,
2: logging.DEBUG,
}
logging.basicConfig(
level=verbose_levels[self.verbose],
format="[%(asctime)-15s] %(module)-9s %(levelname)-7s %(message)s"
)
return logging.getLogger(self.__class__.__name__)
|
python
|
def initLogging(self):
"""Configures the logger."""
verbose_levels = {
0: logging.WARNING,
1: logging.INFO,
2: logging.DEBUG,
}
logging.basicConfig(
level=verbose_levels[self.verbose],
format="[%(asctime)-15s] %(module)-9s %(levelname)-7s %(message)s"
)
return logging.getLogger(self.__class__.__name__)
|
[
"def",
"initLogging",
"(",
"self",
")",
":",
"verbose_levels",
"=",
"{",
"0",
":",
"logging",
".",
"WARNING",
",",
"1",
":",
"logging",
".",
"INFO",
",",
"2",
":",
"logging",
".",
"DEBUG",
",",
"}",
"logging",
".",
"basicConfig",
"(",
"level",
"=",
"verbose_levels",
"[",
"self",
".",
"verbose",
"]",
",",
"format",
"=",
"\"[%(asctime)-15s] %(module)-9s %(levelname)-7s %(message)s\"",
")",
"return",
"logging",
".",
"getLogger",
"(",
"self",
".",
"__class__",
".",
"__name__",
")"
] |
Configures the logger.
|
[
"Configures",
"the",
"logger",
"."
] |
d391dfa62f47e49d48328ee9cf08aa114256fd33
|
https://github.com/soravux/scoop/blob/d391dfa62f47e49d48328ee9cf08aa114256fd33/scoop/launcher.py#L138-L149
|
10,939
|
soravux/scoop
|
scoop/launcher.py
|
ScoopApp.divideHosts
|
def divideHosts(self, hosts, qty):
"""Divide processes among hosts."""
maximumWorkers = sum(host[1] for host in hosts)
# If specified amount of workers is greater than sum of each specified.
if qty > maximumWorkers:
index = 0
while qty > maximumWorkers:
hosts[index] = (hosts[index][0], hosts[index][1] + 1)
index = (index + 1) % len(hosts)
maximumWorkers += 1
# If specified amount of workers if lower than sum of each specified.
elif qty < maximumWorkers:
while qty < maximumWorkers:
maximumWorkers -= hosts[-1][1]
if qty > maximumWorkers:
hosts[-1] = (hosts[-1][0], qty - maximumWorkers)
maximumWorkers += hosts[-1][1]
else:
del hosts[-1]
# Checking if the broker if externally routable
if self.externalHostname in utils.loopbackReferences and \
len(hosts) > 1 and \
not self.tunnel:
raise Exception("\n"
"Could not find route from external worker to the "
"broker: Unresolvable hostname or IP address.\n "
"Please specify your externally routable hostname "
"or IP using the --external-hostname parameter or "
"use the --tunnel flag.")
return hosts
|
python
|
def divideHosts(self, hosts, qty):
"""Divide processes among hosts."""
maximumWorkers = sum(host[1] for host in hosts)
# If specified amount of workers is greater than sum of each specified.
if qty > maximumWorkers:
index = 0
while qty > maximumWorkers:
hosts[index] = (hosts[index][0], hosts[index][1] + 1)
index = (index + 1) % len(hosts)
maximumWorkers += 1
# If specified amount of workers if lower than sum of each specified.
elif qty < maximumWorkers:
while qty < maximumWorkers:
maximumWorkers -= hosts[-1][1]
if qty > maximumWorkers:
hosts[-1] = (hosts[-1][0], qty - maximumWorkers)
maximumWorkers += hosts[-1][1]
else:
del hosts[-1]
# Checking if the broker if externally routable
if self.externalHostname in utils.loopbackReferences and \
len(hosts) > 1 and \
not self.tunnel:
raise Exception("\n"
"Could not find route from external worker to the "
"broker: Unresolvable hostname or IP address.\n "
"Please specify your externally routable hostname "
"or IP using the --external-hostname parameter or "
"use the --tunnel flag.")
return hosts
|
[
"def",
"divideHosts",
"(",
"self",
",",
"hosts",
",",
"qty",
")",
":",
"maximumWorkers",
"=",
"sum",
"(",
"host",
"[",
"1",
"]",
"for",
"host",
"in",
"hosts",
")",
"# If specified amount of workers is greater than sum of each specified.",
"if",
"qty",
">",
"maximumWorkers",
":",
"index",
"=",
"0",
"while",
"qty",
">",
"maximumWorkers",
":",
"hosts",
"[",
"index",
"]",
"=",
"(",
"hosts",
"[",
"index",
"]",
"[",
"0",
"]",
",",
"hosts",
"[",
"index",
"]",
"[",
"1",
"]",
"+",
"1",
")",
"index",
"=",
"(",
"index",
"+",
"1",
")",
"%",
"len",
"(",
"hosts",
")",
"maximumWorkers",
"+=",
"1",
"# If specified amount of workers if lower than sum of each specified.",
"elif",
"qty",
"<",
"maximumWorkers",
":",
"while",
"qty",
"<",
"maximumWorkers",
":",
"maximumWorkers",
"-=",
"hosts",
"[",
"-",
"1",
"]",
"[",
"1",
"]",
"if",
"qty",
">",
"maximumWorkers",
":",
"hosts",
"[",
"-",
"1",
"]",
"=",
"(",
"hosts",
"[",
"-",
"1",
"]",
"[",
"0",
"]",
",",
"qty",
"-",
"maximumWorkers",
")",
"maximumWorkers",
"+=",
"hosts",
"[",
"-",
"1",
"]",
"[",
"1",
"]",
"else",
":",
"del",
"hosts",
"[",
"-",
"1",
"]",
"# Checking if the broker if externally routable",
"if",
"self",
".",
"externalHostname",
"in",
"utils",
".",
"loopbackReferences",
"and",
"len",
"(",
"hosts",
")",
">",
"1",
"and",
"not",
"self",
".",
"tunnel",
":",
"raise",
"Exception",
"(",
"\"\\n\"",
"\"Could not find route from external worker to the \"",
"\"broker: Unresolvable hostname or IP address.\\n \"",
"\"Please specify your externally routable hostname \"",
"\"or IP using the --external-hostname parameter or \"",
"\"use the --tunnel flag.\"",
")",
"return",
"hosts"
] |
Divide processes among hosts.
|
[
"Divide",
"processes",
"among",
"hosts",
"."
] |
d391dfa62f47e49d48328ee9cf08aa114256fd33
|
https://github.com/soravux/scoop/blob/d391dfa62f47e49d48328ee9cf08aa114256fd33/scoop/launcher.py#L151-L185
|
10,940
|
soravux/scoop
|
scoop/launcher.py
|
ScoopApp.showHostDivision
|
def showHostDivision(self, headless):
"""Show the worker distribution over the hosts."""
scoop.logger.info('Worker d--istribution: ')
for worker, number in self.worker_hosts:
first_worker = (worker == self.worker_hosts[0][0])
scoop.logger.info(' {0}:\t{1} {2}'.format(
worker,
number - 1 if first_worker or headless else str(number),
"+ origin" if first_worker or headless else "",
)
)
|
python
|
def showHostDivision(self, headless):
"""Show the worker distribution over the hosts."""
scoop.logger.info('Worker d--istribution: ')
for worker, number in self.worker_hosts:
first_worker = (worker == self.worker_hosts[0][0])
scoop.logger.info(' {0}:\t{1} {2}'.format(
worker,
number - 1 if first_worker or headless else str(number),
"+ origin" if first_worker or headless else "",
)
)
|
[
"def",
"showHostDivision",
"(",
"self",
",",
"headless",
")",
":",
"scoop",
".",
"logger",
".",
"info",
"(",
"'Worker d--istribution: '",
")",
"for",
"worker",
",",
"number",
"in",
"self",
".",
"worker_hosts",
":",
"first_worker",
"=",
"(",
"worker",
"==",
"self",
".",
"worker_hosts",
"[",
"0",
"]",
"[",
"0",
"]",
")",
"scoop",
".",
"logger",
".",
"info",
"(",
"' {0}:\\t{1} {2}'",
".",
"format",
"(",
"worker",
",",
"number",
"-",
"1",
"if",
"first_worker",
"or",
"headless",
"else",
"str",
"(",
"number",
")",
",",
"\"+ origin\"",
"if",
"first_worker",
"or",
"headless",
"else",
"\"\"",
",",
")",
")"
] |
Show the worker distribution over the hosts.
|
[
"Show",
"the",
"worker",
"distribution",
"over",
"the",
"hosts",
"."
] |
d391dfa62f47e49d48328ee9cf08aa114256fd33
|
https://github.com/soravux/scoop/blob/d391dfa62f47e49d48328ee9cf08aa114256fd33/scoop/launcher.py#L187-L197
|
10,941
|
soravux/scoop
|
scoop/launcher.py
|
ScoopApp.setWorkerInfo
|
def setWorkerInfo(self, hostname, workerAmount, origin):
"""Sets the worker information for the current host."""
scoop.logger.debug('Initialising {0}{1} worker {2} [{3}].'.format(
"local" if hostname in utils.localHostnames else "remote",
" origin" if origin else "",
self.workersLeft,
hostname,
)
)
add_args, add_kwargs = self._setWorker_args(origin)
self.workers[-1].setWorker(*add_args, **add_kwargs)
self.workers[-1].setWorkerAmount(workerAmount)
|
python
|
def setWorkerInfo(self, hostname, workerAmount, origin):
"""Sets the worker information for the current host."""
scoop.logger.debug('Initialising {0}{1} worker {2} [{3}].'.format(
"local" if hostname in utils.localHostnames else "remote",
" origin" if origin else "",
self.workersLeft,
hostname,
)
)
add_args, add_kwargs = self._setWorker_args(origin)
self.workers[-1].setWorker(*add_args, **add_kwargs)
self.workers[-1].setWorkerAmount(workerAmount)
|
[
"def",
"setWorkerInfo",
"(",
"self",
",",
"hostname",
",",
"workerAmount",
",",
"origin",
")",
":",
"scoop",
".",
"logger",
".",
"debug",
"(",
"'Initialising {0}{1} worker {2} [{3}].'",
".",
"format",
"(",
"\"local\"",
"if",
"hostname",
"in",
"utils",
".",
"localHostnames",
"else",
"\"remote\"",
",",
"\" origin\"",
"if",
"origin",
"else",
"\"\"",
",",
"self",
".",
"workersLeft",
",",
"hostname",
",",
")",
")",
"add_args",
",",
"add_kwargs",
"=",
"self",
".",
"_setWorker_args",
"(",
"origin",
")",
"self",
".",
"workers",
"[",
"-",
"1",
"]",
".",
"setWorker",
"(",
"*",
"add_args",
",",
"*",
"*",
"add_kwargs",
")",
"self",
".",
"workers",
"[",
"-",
"1",
"]",
".",
"setWorkerAmount",
"(",
"workerAmount",
")"
] |
Sets the worker information for the current host.
|
[
"Sets",
"the",
"worker",
"information",
"for",
"the",
"current",
"host",
"."
] |
d391dfa62f47e49d48328ee9cf08aa114256fd33
|
https://github.com/soravux/scoop/blob/d391dfa62f47e49d48328ee9cf08aa114256fd33/scoop/launcher.py#L228-L241
|
10,942
|
soravux/scoop
|
scoop/launcher.py
|
ScoopApp.close
|
def close(self):
"""Subprocess cleanup."""
# Give time to flush data if debug was on
if self.debug:
time.sleep(10)
# Terminate workers
for host in self.workers:
host.close()
# Terminate the brokers
for broker in self.brokers:
try:
broker.close()
except AttributeError:
# Broker was not started (probably mislaunched)
pass
scoop.logger.info('Finished cleaning spawned subprocesses.')
|
python
|
def close(self):
"""Subprocess cleanup."""
# Give time to flush data if debug was on
if self.debug:
time.sleep(10)
# Terminate workers
for host in self.workers:
host.close()
# Terminate the brokers
for broker in self.brokers:
try:
broker.close()
except AttributeError:
# Broker was not started (probably mislaunched)
pass
scoop.logger.info('Finished cleaning spawned subprocesses.')
|
[
"def",
"close",
"(",
"self",
")",
":",
"# Give time to flush data if debug was on",
"if",
"self",
".",
"debug",
":",
"time",
".",
"sleep",
"(",
"10",
")",
"# Terminate workers",
"for",
"host",
"in",
"self",
".",
"workers",
":",
"host",
".",
"close",
"(",
")",
"# Terminate the brokers",
"for",
"broker",
"in",
"self",
".",
"brokers",
":",
"try",
":",
"broker",
".",
"close",
"(",
")",
"except",
"AttributeError",
":",
"# Broker was not started (probably mislaunched)",
"pass",
"scoop",
".",
"logger",
".",
"info",
"(",
"'Finished cleaning spawned subprocesses.'",
")"
] |
Subprocess cleanup.
|
[
"Subprocess",
"cleanup",
"."
] |
d391dfa62f47e49d48328ee9cf08aa114256fd33
|
https://github.com/soravux/scoop/blob/d391dfa62f47e49d48328ee9cf08aa114256fd33/scoop/launcher.py#L320-L338
|
10,943
|
soravux/scoop
|
scoop/broker/brokerzmq.py
|
Broker.processConfig
|
def processConfig(self, worker_config):
"""Update the pool configuration with a worker configuration.
"""
self.config['headless'] |= worker_config.get("headless", False)
if self.config['headless']:
# Launch discovery process
if not self.discovery_thread:
self.discovery_thread = discovery.Advertise(
port=",".join(str(a) for a in self.getPorts()),
)
|
python
|
def processConfig(self, worker_config):
"""Update the pool configuration with a worker configuration.
"""
self.config['headless'] |= worker_config.get("headless", False)
if self.config['headless']:
# Launch discovery process
if not self.discovery_thread:
self.discovery_thread = discovery.Advertise(
port=",".join(str(a) for a in self.getPorts()),
)
|
[
"def",
"processConfig",
"(",
"self",
",",
"worker_config",
")",
":",
"self",
".",
"config",
"[",
"'headless'",
"]",
"|=",
"worker_config",
".",
"get",
"(",
"\"headless\"",
",",
"False",
")",
"if",
"self",
".",
"config",
"[",
"'headless'",
"]",
":",
"# Launch discovery process",
"if",
"not",
"self",
".",
"discovery_thread",
":",
"self",
".",
"discovery_thread",
"=",
"discovery",
".",
"Advertise",
"(",
"port",
"=",
"\",\"",
".",
"join",
"(",
"str",
"(",
"a",
")",
"for",
"a",
"in",
"self",
".",
"getPorts",
"(",
")",
")",
",",
")"
] |
Update the pool configuration with a worker configuration.
|
[
"Update",
"the",
"pool",
"configuration",
"with",
"a",
"worker",
"configuration",
"."
] |
d391dfa62f47e49d48328ee9cf08aa114256fd33
|
https://github.com/soravux/scoop/blob/d391dfa62f47e49d48328ee9cf08aa114256fd33/scoop/broker/brokerzmq.py#L173-L182
|
10,944
|
soravux/scoop
|
scoop/bootstrap/__main__.py
|
Bootstrap.main
|
def main(self):
"""Bootstrap an arbitrary script.
If no agruments were passed, use discovery module to search and connect
to a broker."""
if self.args is None:
self.parse()
self.log = utils.initLogging(self.verbose)
# Change to the desired directory
if self.args.workingDirectory:
os.chdir(self.args.workingDirectory)
if not self.args.brokerHostname:
self.log.info("Discovering SCOOP Brokers on network...")
pools = discovery.Seek()
if not pools:
self.log.error("Could not find a SCOOP Broker broadcast.")
sys.exit(-1)
self.log.info("Found a broker named {name} on {host} port "
"{ports}".format(
name=pools[0].name,
host=pools[0].host,
ports=pools[0].ports,
))
self.args.brokerHostname = pools[0].host
self.args.taskPort = pools[0].ports[0]
self.args.metaPort = pools[0].ports[0]
self.log.debug("Using following addresses:\n{brokerAddress}\n"
"{metaAddress}".format(
brokerAddress=self.args.brokerAddress,
metaAddress=self.args.metaAddress,
))
self.args.origin = True
self.setScoop()
self.run()
|
python
|
def main(self):
"""Bootstrap an arbitrary script.
If no agruments were passed, use discovery module to search and connect
to a broker."""
if self.args is None:
self.parse()
self.log = utils.initLogging(self.verbose)
# Change to the desired directory
if self.args.workingDirectory:
os.chdir(self.args.workingDirectory)
if not self.args.brokerHostname:
self.log.info("Discovering SCOOP Brokers on network...")
pools = discovery.Seek()
if not pools:
self.log.error("Could not find a SCOOP Broker broadcast.")
sys.exit(-1)
self.log.info("Found a broker named {name} on {host} port "
"{ports}".format(
name=pools[0].name,
host=pools[0].host,
ports=pools[0].ports,
))
self.args.brokerHostname = pools[0].host
self.args.taskPort = pools[0].ports[0]
self.args.metaPort = pools[0].ports[0]
self.log.debug("Using following addresses:\n{brokerAddress}\n"
"{metaAddress}".format(
brokerAddress=self.args.brokerAddress,
metaAddress=self.args.metaAddress,
))
self.args.origin = True
self.setScoop()
self.run()
|
[
"def",
"main",
"(",
"self",
")",
":",
"if",
"self",
".",
"args",
"is",
"None",
":",
"self",
".",
"parse",
"(",
")",
"self",
".",
"log",
"=",
"utils",
".",
"initLogging",
"(",
"self",
".",
"verbose",
")",
"# Change to the desired directory",
"if",
"self",
".",
"args",
".",
"workingDirectory",
":",
"os",
".",
"chdir",
"(",
"self",
".",
"args",
".",
"workingDirectory",
")",
"if",
"not",
"self",
".",
"args",
".",
"brokerHostname",
":",
"self",
".",
"log",
".",
"info",
"(",
"\"Discovering SCOOP Brokers on network...\"",
")",
"pools",
"=",
"discovery",
".",
"Seek",
"(",
")",
"if",
"not",
"pools",
":",
"self",
".",
"log",
".",
"error",
"(",
"\"Could not find a SCOOP Broker broadcast.\"",
")",
"sys",
".",
"exit",
"(",
"-",
"1",
")",
"self",
".",
"log",
".",
"info",
"(",
"\"Found a broker named {name} on {host} port \"",
"\"{ports}\"",
".",
"format",
"(",
"name",
"=",
"pools",
"[",
"0",
"]",
".",
"name",
",",
"host",
"=",
"pools",
"[",
"0",
"]",
".",
"host",
",",
"ports",
"=",
"pools",
"[",
"0",
"]",
".",
"ports",
",",
")",
")",
"self",
".",
"args",
".",
"brokerHostname",
"=",
"pools",
"[",
"0",
"]",
".",
"host",
"self",
".",
"args",
".",
"taskPort",
"=",
"pools",
"[",
"0",
"]",
".",
"ports",
"[",
"0",
"]",
"self",
".",
"args",
".",
"metaPort",
"=",
"pools",
"[",
"0",
"]",
".",
"ports",
"[",
"0",
"]",
"self",
".",
"log",
".",
"debug",
"(",
"\"Using following addresses:\\n{brokerAddress}\\n\"",
"\"{metaAddress}\"",
".",
"format",
"(",
"brokerAddress",
"=",
"self",
".",
"args",
".",
"brokerAddress",
",",
"metaAddress",
"=",
"self",
".",
"args",
".",
"metaAddress",
",",
")",
")",
"self",
".",
"args",
".",
"origin",
"=",
"True",
"self",
".",
"setScoop",
"(",
")",
"self",
".",
"run",
"(",
")"
] |
Bootstrap an arbitrary script.
If no agruments were passed, use discovery module to search and connect
to a broker.
|
[
"Bootstrap",
"an",
"arbitrary",
"script",
".",
"If",
"no",
"agruments",
"were",
"passed",
"use",
"discovery",
"module",
"to",
"search",
"and",
"connect",
"to",
"a",
"broker",
"."
] |
d391dfa62f47e49d48328ee9cf08aa114256fd33
|
https://github.com/soravux/scoop/blob/d391dfa62f47e49d48328ee9cf08aa114256fd33/scoop/bootstrap/__main__.py#L54-L92
|
10,945
|
soravux/scoop
|
scoop/bootstrap/__main__.py
|
Bootstrap.makeParser
|
def makeParser(self):
"""Generate the argparse parser object containing the bootloader
accepted parameters
"""
self.parser = argparse.ArgumentParser(description='Starts the executable.',
prog=("{0} -m scoop.bootstrap"
).format(sys.executable))
self.parser.add_argument('--origin',
help="To specify that the worker is the origin",
action='store_true')
self.parser.add_argument('--brokerHostname',
help="The routable hostname of a broker",
default="")
self.parser.add_argument('--externalBrokerHostname',
help="Externally routable hostname of local "
"worker",
default="")
self.parser.add_argument('--taskPort',
help="The port of the broker task socket",
type=int)
self.parser.add_argument('--metaPort',
help="The port of the broker meta socket",
type=int)
self.parser.add_argument('--size',
help="The size of the worker pool",
type=int,
default=1)
self.parser.add_argument('--nice',
help="Adjust the niceness of the process",
type=int,
default=0)
self.parser.add_argument('--debug',
help="Activate the debug",
action='store_true')
self.parser.add_argument('--profile',
help="Activate the profiler",
action='store_true')
self.parser.add_argument('--workingDirectory',
help="Set the working directory for the "
"execution",
default=os.path.expanduser("~"))
self.parser.add_argument('--backend',
help="Choice of communication backend",
choices=['ZMQ', 'TCP'],
default='ZMQ')
self.parser.add_argument('executable',
nargs='?',
help='The executable to start with scoop')
self.parser.add_argument('args',
nargs=argparse.REMAINDER,
help='The arguments to pass to the executable',
default=[])
self.parser.add_argument('--verbose', '-v', action='count',
help=("Verbosity level of this launch script"
"(-vv for more)"),
default=0)
|
python
|
def makeParser(self):
"""Generate the argparse parser object containing the bootloader
accepted parameters
"""
self.parser = argparse.ArgumentParser(description='Starts the executable.',
prog=("{0} -m scoop.bootstrap"
).format(sys.executable))
self.parser.add_argument('--origin',
help="To specify that the worker is the origin",
action='store_true')
self.parser.add_argument('--brokerHostname',
help="The routable hostname of a broker",
default="")
self.parser.add_argument('--externalBrokerHostname',
help="Externally routable hostname of local "
"worker",
default="")
self.parser.add_argument('--taskPort',
help="The port of the broker task socket",
type=int)
self.parser.add_argument('--metaPort',
help="The port of the broker meta socket",
type=int)
self.parser.add_argument('--size',
help="The size of the worker pool",
type=int,
default=1)
self.parser.add_argument('--nice',
help="Adjust the niceness of the process",
type=int,
default=0)
self.parser.add_argument('--debug',
help="Activate the debug",
action='store_true')
self.parser.add_argument('--profile',
help="Activate the profiler",
action='store_true')
self.parser.add_argument('--workingDirectory',
help="Set the working directory for the "
"execution",
default=os.path.expanduser("~"))
self.parser.add_argument('--backend',
help="Choice of communication backend",
choices=['ZMQ', 'TCP'],
default='ZMQ')
self.parser.add_argument('executable',
nargs='?',
help='The executable to start with scoop')
self.parser.add_argument('args',
nargs=argparse.REMAINDER,
help='The arguments to pass to the executable',
default=[])
self.parser.add_argument('--verbose', '-v', action='count',
help=("Verbosity level of this launch script"
"(-vv for more)"),
default=0)
|
[
"def",
"makeParser",
"(",
"self",
")",
":",
"self",
".",
"parser",
"=",
"argparse",
".",
"ArgumentParser",
"(",
"description",
"=",
"'Starts the executable.'",
",",
"prog",
"=",
"(",
"\"{0} -m scoop.bootstrap\"",
")",
".",
"format",
"(",
"sys",
".",
"executable",
")",
")",
"self",
".",
"parser",
".",
"add_argument",
"(",
"'--origin'",
",",
"help",
"=",
"\"To specify that the worker is the origin\"",
",",
"action",
"=",
"'store_true'",
")",
"self",
".",
"parser",
".",
"add_argument",
"(",
"'--brokerHostname'",
",",
"help",
"=",
"\"The routable hostname of a broker\"",
",",
"default",
"=",
"\"\"",
")",
"self",
".",
"parser",
".",
"add_argument",
"(",
"'--externalBrokerHostname'",
",",
"help",
"=",
"\"Externally routable hostname of local \"",
"\"worker\"",
",",
"default",
"=",
"\"\"",
")",
"self",
".",
"parser",
".",
"add_argument",
"(",
"'--taskPort'",
",",
"help",
"=",
"\"The port of the broker task socket\"",
",",
"type",
"=",
"int",
")",
"self",
".",
"parser",
".",
"add_argument",
"(",
"'--metaPort'",
",",
"help",
"=",
"\"The port of the broker meta socket\"",
",",
"type",
"=",
"int",
")",
"self",
".",
"parser",
".",
"add_argument",
"(",
"'--size'",
",",
"help",
"=",
"\"The size of the worker pool\"",
",",
"type",
"=",
"int",
",",
"default",
"=",
"1",
")",
"self",
".",
"parser",
".",
"add_argument",
"(",
"'--nice'",
",",
"help",
"=",
"\"Adjust the niceness of the process\"",
",",
"type",
"=",
"int",
",",
"default",
"=",
"0",
")",
"self",
".",
"parser",
".",
"add_argument",
"(",
"'--debug'",
",",
"help",
"=",
"\"Activate the debug\"",
",",
"action",
"=",
"'store_true'",
")",
"self",
".",
"parser",
".",
"add_argument",
"(",
"'--profile'",
",",
"help",
"=",
"\"Activate the profiler\"",
",",
"action",
"=",
"'store_true'",
")",
"self",
".",
"parser",
".",
"add_argument",
"(",
"'--workingDirectory'",
",",
"help",
"=",
"\"Set the working directory for the \"",
"\"execution\"",
",",
"default",
"=",
"os",
".",
"path",
".",
"expanduser",
"(",
"\"~\"",
")",
")",
"self",
".",
"parser",
".",
"add_argument",
"(",
"'--backend'",
",",
"help",
"=",
"\"Choice of communication backend\"",
",",
"choices",
"=",
"[",
"'ZMQ'",
",",
"'TCP'",
"]",
",",
"default",
"=",
"'ZMQ'",
")",
"self",
".",
"parser",
".",
"add_argument",
"(",
"'executable'",
",",
"nargs",
"=",
"'?'",
",",
"help",
"=",
"'The executable to start with scoop'",
")",
"self",
".",
"parser",
".",
"add_argument",
"(",
"'args'",
",",
"nargs",
"=",
"argparse",
".",
"REMAINDER",
",",
"help",
"=",
"'The arguments to pass to the executable'",
",",
"default",
"=",
"[",
"]",
")",
"self",
".",
"parser",
".",
"add_argument",
"(",
"'--verbose'",
",",
"'-v'",
",",
"action",
"=",
"'count'",
",",
"help",
"=",
"(",
"\"Verbosity level of this launch script\"",
"\"(-vv for more)\"",
")",
",",
"default",
"=",
"0",
")"
] |
Generate the argparse parser object containing the bootloader
accepted parameters
|
[
"Generate",
"the",
"argparse",
"parser",
"object",
"containing",
"the",
"bootloader",
"accepted",
"parameters"
] |
d391dfa62f47e49d48328ee9cf08aa114256fd33
|
https://github.com/soravux/scoop/blob/d391dfa62f47e49d48328ee9cf08aa114256fd33/scoop/bootstrap/__main__.py#L94-L150
|
10,946
|
soravux/scoop
|
scoop/bootstrap/__main__.py
|
Bootstrap.parse
|
def parse(self):
"""Generate a argparse parser and parse the command-line arguments"""
if self.parser is None:
self.makeParser()
self.args = self.parser.parse_args()
self.verbose = self.args.verbose
|
python
|
def parse(self):
"""Generate a argparse parser and parse the command-line arguments"""
if self.parser is None:
self.makeParser()
self.args = self.parser.parse_args()
self.verbose = self.args.verbose
|
[
"def",
"parse",
"(",
"self",
")",
":",
"if",
"self",
".",
"parser",
"is",
"None",
":",
"self",
".",
"makeParser",
"(",
")",
"self",
".",
"args",
"=",
"self",
".",
"parser",
".",
"parse_args",
"(",
")",
"self",
".",
"verbose",
"=",
"self",
".",
"args",
".",
"verbose"
] |
Generate a argparse parser and parse the command-line arguments
|
[
"Generate",
"a",
"argparse",
"parser",
"and",
"parse",
"the",
"command",
"-",
"line",
"arguments"
] |
d391dfa62f47e49d48328ee9cf08aa114256fd33
|
https://github.com/soravux/scoop/blob/d391dfa62f47e49d48328ee9cf08aa114256fd33/scoop/bootstrap/__main__.py#L152-L157
|
10,947
|
soravux/scoop
|
scoop/bootstrap/__main__.py
|
Bootstrap.setScoop
|
def setScoop(self):
"""Setup the SCOOP constants."""
scoop.IS_RUNNING = True
scoop.IS_ORIGIN = self.args.origin
scoop.BROKER = BrokerInfo(
self.args.brokerHostname,
self.args.taskPort,
self.args.metaPort,
self.args.externalBrokerHostname
if self.args.externalBrokerHostname
else self.args.brokerHostname,
)
scoop.SIZE = self.args.size
scoop.DEBUG = self.args.debug
scoop.MAIN_MODULE = self.args.executable
scoop.CONFIGURATION = {
'headless': not bool(self.args.executable),
'backend': self.args.backend,
}
scoop.WORKING_DIRECTORY = self.args.workingDirectory
scoop.logger = self.log
if self.args.nice:
if not psutil:
scoop.logger.error("psutil not installed.")
raise ImportError("psutil is needed for nice functionnality.")
p = psutil.Process(os.getpid())
p.set_nice(self.args.nice)
if scoop.DEBUG or self.args.profile:
from scoop import _debug
if scoop.DEBUG:
_debug.createDirectory()
|
python
|
def setScoop(self):
"""Setup the SCOOP constants."""
scoop.IS_RUNNING = True
scoop.IS_ORIGIN = self.args.origin
scoop.BROKER = BrokerInfo(
self.args.brokerHostname,
self.args.taskPort,
self.args.metaPort,
self.args.externalBrokerHostname
if self.args.externalBrokerHostname
else self.args.brokerHostname,
)
scoop.SIZE = self.args.size
scoop.DEBUG = self.args.debug
scoop.MAIN_MODULE = self.args.executable
scoop.CONFIGURATION = {
'headless': not bool(self.args.executable),
'backend': self.args.backend,
}
scoop.WORKING_DIRECTORY = self.args.workingDirectory
scoop.logger = self.log
if self.args.nice:
if not psutil:
scoop.logger.error("psutil not installed.")
raise ImportError("psutil is needed for nice functionnality.")
p = psutil.Process(os.getpid())
p.set_nice(self.args.nice)
if scoop.DEBUG or self.args.profile:
from scoop import _debug
if scoop.DEBUG:
_debug.createDirectory()
|
[
"def",
"setScoop",
"(",
"self",
")",
":",
"scoop",
".",
"IS_RUNNING",
"=",
"True",
"scoop",
".",
"IS_ORIGIN",
"=",
"self",
".",
"args",
".",
"origin",
"scoop",
".",
"BROKER",
"=",
"BrokerInfo",
"(",
"self",
".",
"args",
".",
"brokerHostname",
",",
"self",
".",
"args",
".",
"taskPort",
",",
"self",
".",
"args",
".",
"metaPort",
",",
"self",
".",
"args",
".",
"externalBrokerHostname",
"if",
"self",
".",
"args",
".",
"externalBrokerHostname",
"else",
"self",
".",
"args",
".",
"brokerHostname",
",",
")",
"scoop",
".",
"SIZE",
"=",
"self",
".",
"args",
".",
"size",
"scoop",
".",
"DEBUG",
"=",
"self",
".",
"args",
".",
"debug",
"scoop",
".",
"MAIN_MODULE",
"=",
"self",
".",
"args",
".",
"executable",
"scoop",
".",
"CONFIGURATION",
"=",
"{",
"'headless'",
":",
"not",
"bool",
"(",
"self",
".",
"args",
".",
"executable",
")",
",",
"'backend'",
":",
"self",
".",
"args",
".",
"backend",
",",
"}",
"scoop",
".",
"WORKING_DIRECTORY",
"=",
"self",
".",
"args",
".",
"workingDirectory",
"scoop",
".",
"logger",
"=",
"self",
".",
"log",
"if",
"self",
".",
"args",
".",
"nice",
":",
"if",
"not",
"psutil",
":",
"scoop",
".",
"logger",
".",
"error",
"(",
"\"psutil not installed.\"",
")",
"raise",
"ImportError",
"(",
"\"psutil is needed for nice functionnality.\"",
")",
"p",
"=",
"psutil",
".",
"Process",
"(",
"os",
".",
"getpid",
"(",
")",
")",
"p",
".",
"set_nice",
"(",
"self",
".",
"args",
".",
"nice",
")",
"if",
"scoop",
".",
"DEBUG",
"or",
"self",
".",
"args",
".",
"profile",
":",
"from",
"scoop",
"import",
"_debug",
"if",
"scoop",
".",
"DEBUG",
":",
"_debug",
".",
"createDirectory",
"(",
")"
] |
Setup the SCOOP constants.
|
[
"Setup",
"the",
"SCOOP",
"constants",
"."
] |
d391dfa62f47e49d48328ee9cf08aa114256fd33
|
https://github.com/soravux/scoop/blob/d391dfa62f47e49d48328ee9cf08aa114256fd33/scoop/bootstrap/__main__.py#L159-L191
|
10,948
|
soravux/scoop
|
examples/shared_example.py
|
myFunc
|
def myFunc(parameter):
"""This function will be executed on the remote host even if it was not
available at launch."""
print('Hello World from {0}!'.format(scoop.worker))
# It is possible to get a constant anywhere
print(shared.getConst('myVar')[2])
# Parameters are handled as usual
return parameter + 1
|
python
|
def myFunc(parameter):
"""This function will be executed on the remote host even if it was not
available at launch."""
print('Hello World from {0}!'.format(scoop.worker))
# It is possible to get a constant anywhere
print(shared.getConst('myVar')[2])
# Parameters are handled as usual
return parameter + 1
|
[
"def",
"myFunc",
"(",
"parameter",
")",
":",
"print",
"(",
"'Hello World from {0}!'",
".",
"format",
"(",
"scoop",
".",
"worker",
")",
")",
"# It is possible to get a constant anywhere",
"print",
"(",
"shared",
".",
"getConst",
"(",
"'myVar'",
")",
"[",
"2",
"]",
")",
"# Parameters are handled as usual",
"return",
"parameter",
"+",
"1"
] |
This function will be executed on the remote host even if it was not
available at launch.
|
[
"This",
"function",
"will",
"be",
"executed",
"on",
"the",
"remote",
"host",
"even",
"if",
"it",
"was",
"not",
"available",
"at",
"launch",
"."
] |
d391dfa62f47e49d48328ee9cf08aa114256fd33
|
https://github.com/soravux/scoop/blob/d391dfa62f47e49d48328ee9cf08aa114256fd33/examples/shared_example.py#L26-L35
|
10,949
|
soravux/scoop
|
scoop/_comm/scooptcp.py
|
TCPCommunicator.sendResult
|
def sendResult(self, future):
"""Send a terminated future back to its parent."""
future = copy.copy(future)
# Remove the (now) extraneous elements from future class
future.callable = future.args = future.kargs = future.greenlet = None
if not future.sendResultBack:
# Don't reply back the result if it isn't asked
future.resultValue = None
self._sendReply(
future.id.worker,
pickle.dumps(
future,
pickle.HIGHEST_PROTOCOL,
),
)
|
python
|
def sendResult(self, future):
"""Send a terminated future back to its parent."""
future = copy.copy(future)
# Remove the (now) extraneous elements from future class
future.callable = future.args = future.kargs = future.greenlet = None
if not future.sendResultBack:
# Don't reply back the result if it isn't asked
future.resultValue = None
self._sendReply(
future.id.worker,
pickle.dumps(
future,
pickle.HIGHEST_PROTOCOL,
),
)
|
[
"def",
"sendResult",
"(",
"self",
",",
"future",
")",
":",
"future",
"=",
"copy",
".",
"copy",
"(",
"future",
")",
"# Remove the (now) extraneous elements from future class\r",
"future",
".",
"callable",
"=",
"future",
".",
"args",
"=",
"future",
".",
"kargs",
"=",
"future",
".",
"greenlet",
"=",
"None",
"if",
"not",
"future",
".",
"sendResultBack",
":",
"# Don't reply back the result if it isn't asked\r",
"future",
".",
"resultValue",
"=",
"None",
"self",
".",
"_sendReply",
"(",
"future",
".",
"id",
".",
"worker",
",",
"pickle",
".",
"dumps",
"(",
"future",
",",
"pickle",
".",
"HIGHEST_PROTOCOL",
",",
")",
",",
")"
] |
Send a terminated future back to its parent.
|
[
"Send",
"a",
"terminated",
"future",
"back",
"to",
"its",
"parent",
"."
] |
d391dfa62f47e49d48328ee9cf08aa114256fd33
|
https://github.com/soravux/scoop/blob/d391dfa62f47e49d48328ee9cf08aa114256fd33/scoop/_comm/scooptcp.py#L315-L332
|
10,950
|
soravux/scoop
|
examples/url_fetch.py
|
getSize
|
def getSize(string):
""" This functions opens a web sites and then calculate the total
size of the page in bytes. This is for the sake of the example. Do
not use this technique in real code as it is not a very bright way
to do this."""
try:
# We open the web page
with urllib.request.urlopen(string, None, 1) as f:
return sum(len(line) for line in f)
except (urllib.error.URLError, socket.timeout) as e:
return 0
|
python
|
def getSize(string):
""" This functions opens a web sites and then calculate the total
size of the page in bytes. This is for the sake of the example. Do
not use this technique in real code as it is not a very bright way
to do this."""
try:
# We open the web page
with urllib.request.urlopen(string, None, 1) as f:
return sum(len(line) for line in f)
except (urllib.error.URLError, socket.timeout) as e:
return 0
|
[
"def",
"getSize",
"(",
"string",
")",
":",
"try",
":",
"# We open the web page",
"with",
"urllib",
".",
"request",
".",
"urlopen",
"(",
"string",
",",
"None",
",",
"1",
")",
"as",
"f",
":",
"return",
"sum",
"(",
"len",
"(",
"line",
")",
"for",
"line",
"in",
"f",
")",
"except",
"(",
"urllib",
".",
"error",
".",
"URLError",
",",
"socket",
".",
"timeout",
")",
"as",
"e",
":",
"return",
"0"
] |
This functions opens a web sites and then calculate the total
size of the page in bytes. This is for the sake of the example. Do
not use this technique in real code as it is not a very bright way
to do this.
|
[
"This",
"functions",
"opens",
"a",
"web",
"sites",
"and",
"then",
"calculate",
"the",
"total",
"size",
"of",
"the",
"page",
"in",
"bytes",
".",
"This",
"is",
"for",
"the",
"sake",
"of",
"the",
"example",
".",
"Do",
"not",
"use",
"this",
"technique",
"in",
"real",
"code",
"as",
"it",
"is",
"not",
"a",
"very",
"bright",
"way",
"to",
"do",
"this",
"."
] |
d391dfa62f47e49d48328ee9cf08aa114256fd33
|
https://github.com/soravux/scoop/blob/d391dfa62f47e49d48328ee9cf08aa114256fd33/examples/url_fetch.py#L30-L40
|
10,951
|
soravux/scoop
|
examples/shared_example_doc.py
|
getValue
|
def getValue(words):
"""Computes the sum of the values of the words."""
value = 0
for word in words:
for letter in word:
# shared.getConst will evaluate to the dictionary broadcasted by
# the root Future
value += shared.getConst('lettersValue')[letter]
return value
|
python
|
def getValue(words):
"""Computes the sum of the values of the words."""
value = 0
for word in words:
for letter in word:
# shared.getConst will evaluate to the dictionary broadcasted by
# the root Future
value += shared.getConst('lettersValue')[letter]
return value
|
[
"def",
"getValue",
"(",
"words",
")",
":",
"value",
"=",
"0",
"for",
"word",
"in",
"words",
":",
"for",
"letter",
"in",
"word",
":",
"# shared.getConst will evaluate to the dictionary broadcasted by",
"# the root Future",
"value",
"+=",
"shared",
".",
"getConst",
"(",
"'lettersValue'",
")",
"[",
"letter",
"]",
"return",
"value"
] |
Computes the sum of the values of the words.
|
[
"Computes",
"the",
"sum",
"of",
"the",
"values",
"of",
"the",
"words",
"."
] |
d391dfa62f47e49d48328ee9cf08aa114256fd33
|
https://github.com/soravux/scoop/blob/d391dfa62f47e49d48328ee9cf08aa114256fd33/examples/shared_example_doc.py#L23-L31
|
10,952
|
soravux/scoop
|
scoop/backports/runpy.py
|
_run_module_code
|
def _run_module_code(code, init_globals=None,
mod_name=None, mod_fname=None,
mod_loader=None, pkg_name=None):
"""Helper to run code in new namespace with sys modified"""
with _ModifiedArgv0(mod_fname):
with _TempModule(mod_name) as temp_module:
mod_globals = temp_module.module.__dict__
_run_code(code, mod_globals, init_globals,
mod_name, mod_fname, mod_loader, pkg_name)
# Copy the globals of the temporary module, as they
# may be cleared when the temporary module goes away
return mod_globals.copy()
|
python
|
def _run_module_code(code, init_globals=None,
mod_name=None, mod_fname=None,
mod_loader=None, pkg_name=None):
"""Helper to run code in new namespace with sys modified"""
with _ModifiedArgv0(mod_fname):
with _TempModule(mod_name) as temp_module:
mod_globals = temp_module.module.__dict__
_run_code(code, mod_globals, init_globals,
mod_name, mod_fname, mod_loader, pkg_name)
# Copy the globals of the temporary module, as they
# may be cleared when the temporary module goes away
return mod_globals.copy()
|
[
"def",
"_run_module_code",
"(",
"code",
",",
"init_globals",
"=",
"None",
",",
"mod_name",
"=",
"None",
",",
"mod_fname",
"=",
"None",
",",
"mod_loader",
"=",
"None",
",",
"pkg_name",
"=",
"None",
")",
":",
"with",
"_ModifiedArgv0",
"(",
"mod_fname",
")",
":",
"with",
"_TempModule",
"(",
"mod_name",
")",
"as",
"temp_module",
":",
"mod_globals",
"=",
"temp_module",
".",
"module",
".",
"__dict__",
"_run_code",
"(",
"code",
",",
"mod_globals",
",",
"init_globals",
",",
"mod_name",
",",
"mod_fname",
",",
"mod_loader",
",",
"pkg_name",
")",
"# Copy the globals of the temporary module, as they",
"# may be cleared when the temporary module goes away",
"return",
"mod_globals",
".",
"copy",
"(",
")"
] |
Helper to run code in new namespace with sys modified
|
[
"Helper",
"to",
"run",
"code",
"in",
"new",
"namespace",
"with",
"sys",
"modified"
] |
d391dfa62f47e49d48328ee9cf08aa114256fd33
|
https://github.com/soravux/scoop/blob/d391dfa62f47e49d48328ee9cf08aa114256fd33/scoop/backports/runpy.py#L75-L86
|
10,953
|
soravux/scoop
|
scoop/backports/runpy.py
|
run_module
|
def run_module(mod_name, init_globals=None,
run_name=None, alter_sys=False):
"""Execute a module's code without importing it
Returns the resulting top level namespace dictionary
"""
mod_name, loader, code, fname = _get_module_details(mod_name)
if run_name is None:
run_name = mod_name
pkg_name = mod_name.rpartition('.')[0]
if alter_sys:
return _run_module_code(code, init_globals, run_name,
fname, loader, pkg_name)
else:
# Leave the sys module alone
return _run_code(code, {}, init_globals, run_name,
fname, loader, pkg_name)
|
python
|
def run_module(mod_name, init_globals=None,
run_name=None, alter_sys=False):
"""Execute a module's code without importing it
Returns the resulting top level namespace dictionary
"""
mod_name, loader, code, fname = _get_module_details(mod_name)
if run_name is None:
run_name = mod_name
pkg_name = mod_name.rpartition('.')[0]
if alter_sys:
return _run_module_code(code, init_globals, run_name,
fname, loader, pkg_name)
else:
# Leave the sys module alone
return _run_code(code, {}, init_globals, run_name,
fname, loader, pkg_name)
|
[
"def",
"run_module",
"(",
"mod_name",
",",
"init_globals",
"=",
"None",
",",
"run_name",
"=",
"None",
",",
"alter_sys",
"=",
"False",
")",
":",
"mod_name",
",",
"loader",
",",
"code",
",",
"fname",
"=",
"_get_module_details",
"(",
"mod_name",
")",
"if",
"run_name",
"is",
"None",
":",
"run_name",
"=",
"mod_name",
"pkg_name",
"=",
"mod_name",
".",
"rpartition",
"(",
"'.'",
")",
"[",
"0",
"]",
"if",
"alter_sys",
":",
"return",
"_run_module_code",
"(",
"code",
",",
"init_globals",
",",
"run_name",
",",
"fname",
",",
"loader",
",",
"pkg_name",
")",
"else",
":",
"# Leave the sys module alone",
"return",
"_run_code",
"(",
"code",
",",
"{",
"}",
",",
"init_globals",
",",
"run_name",
",",
"fname",
",",
"loader",
",",
"pkg_name",
")"
] |
Execute a module's code without importing it
Returns the resulting top level namespace dictionary
|
[
"Execute",
"a",
"module",
"s",
"code",
"without",
"importing",
"it"
] |
d391dfa62f47e49d48328ee9cf08aa114256fd33
|
https://github.com/soravux/scoop/blob/d391dfa62f47e49d48328ee9cf08aa114256fd33/scoop/backports/runpy.py#L165-L181
|
10,954
|
soravux/scoop
|
scoop/backports/runpy.py
|
_get_importer
|
def _get_importer(path_name):
"""Python version of PyImport_GetImporter C API function"""
cache = sys.path_importer_cache
try:
importer = cache[path_name]
except KeyError:
# Not yet cached. Flag as using the
# standard machinery until we finish
# checking the hooks
cache[path_name] = None
for hook in sys.path_hooks:
try:
importer = hook(path_name)
break
except ImportError:
pass
else:
# The following check looks a bit odd. The trick is that
# NullImporter throws ImportError if the supplied path is a
# *valid* directory entry (and hence able to be handled
# by the standard import machinery)
try:
importer = imp.NullImporter(path_name)
except ImportError:
return None
cache[path_name] = importer
return importer
|
python
|
def _get_importer(path_name):
"""Python version of PyImport_GetImporter C API function"""
cache = sys.path_importer_cache
try:
importer = cache[path_name]
except KeyError:
# Not yet cached. Flag as using the
# standard machinery until we finish
# checking the hooks
cache[path_name] = None
for hook in sys.path_hooks:
try:
importer = hook(path_name)
break
except ImportError:
pass
else:
# The following check looks a bit odd. The trick is that
# NullImporter throws ImportError if the supplied path is a
# *valid* directory entry (and hence able to be handled
# by the standard import machinery)
try:
importer = imp.NullImporter(path_name)
except ImportError:
return None
cache[path_name] = importer
return importer
|
[
"def",
"_get_importer",
"(",
"path_name",
")",
":",
"cache",
"=",
"sys",
".",
"path_importer_cache",
"try",
":",
"importer",
"=",
"cache",
"[",
"path_name",
"]",
"except",
"KeyError",
":",
"# Not yet cached. Flag as using the",
"# standard machinery until we finish",
"# checking the hooks",
"cache",
"[",
"path_name",
"]",
"=",
"None",
"for",
"hook",
"in",
"sys",
".",
"path_hooks",
":",
"try",
":",
"importer",
"=",
"hook",
"(",
"path_name",
")",
"break",
"except",
"ImportError",
":",
"pass",
"else",
":",
"# The following check looks a bit odd. The trick is that",
"# NullImporter throws ImportError if the supplied path is a",
"# *valid* directory entry (and hence able to be handled",
"# by the standard import machinery)",
"try",
":",
"importer",
"=",
"imp",
".",
"NullImporter",
"(",
"path_name",
")",
"except",
"ImportError",
":",
"return",
"None",
"cache",
"[",
"path_name",
"]",
"=",
"importer",
"return",
"importer"
] |
Python version of PyImport_GetImporter C API function
|
[
"Python",
"version",
"of",
"PyImport_GetImporter",
"C",
"API",
"function"
] |
d391dfa62f47e49d48328ee9cf08aa114256fd33
|
https://github.com/soravux/scoop/blob/d391dfa62f47e49d48328ee9cf08aa114256fd33/scoop/backports/runpy.py#L186-L212
|
10,955
|
soravux/scoop
|
scoop/backports/runpy.py
|
run_path
|
def run_path(path_name, init_globals=None, run_name=None):
"""Execute code located at the specified filesystem location
Returns the resulting top level namespace dictionary
The file path may refer directly to a Python script (i.e.
one that could be directly executed with execfile) or else
it may refer to a zipfile or directory containing a top
level __main__.py script.
"""
if run_name is None:
run_name = "<run_path>"
importer = _get_importer(path_name)
if isinstance(importer, imp.NullImporter):
# Not a valid sys.path entry, so run the code directly
# execfile() doesn't help as we want to allow compiled files
code = _get_code_from_file(path_name)
return _run_module_code(code, init_globals, run_name, path_name)
else:
# Importer is defined for path, so add it to
# the start of sys.path
sys.path.insert(0, path_name)
try:
# Here's where things are a little different from the run_module
# case. There, we only had to replace the module in sys while the
# code was running and doing so was somewhat optional. Here, we
# have no choice and we have to remove it even while we read the
# code. If we don't do this, a __loader__ attribute in the
# existing __main__ module may prevent location of the new module.
main_name = "__main__"
saved_main = sys.modules[main_name]
del sys.modules[main_name]
try:
mod_name, loader, code, fname = _get_main_module_details()
finally:
sys.modules[main_name] = saved_main
pkg_name = ""
with _ModifiedArgv0(path_name):
with _TempModule(run_name) as temp_module:
mod_globals = temp_module.module.__dict__
return _run_code(code, mod_globals, init_globals,
run_name, fname, loader, pkg_name).copy()
finally:
try:
sys.path.remove(path_name)
except ValueError:
pass
|
python
|
def run_path(path_name, init_globals=None, run_name=None):
"""Execute code located at the specified filesystem location
Returns the resulting top level namespace dictionary
The file path may refer directly to a Python script (i.e.
one that could be directly executed with execfile) or else
it may refer to a zipfile or directory containing a top
level __main__.py script.
"""
if run_name is None:
run_name = "<run_path>"
importer = _get_importer(path_name)
if isinstance(importer, imp.NullImporter):
# Not a valid sys.path entry, so run the code directly
# execfile() doesn't help as we want to allow compiled files
code = _get_code_from_file(path_name)
return _run_module_code(code, init_globals, run_name, path_name)
else:
# Importer is defined for path, so add it to
# the start of sys.path
sys.path.insert(0, path_name)
try:
# Here's where things are a little different from the run_module
# case. There, we only had to replace the module in sys while the
# code was running and doing so was somewhat optional. Here, we
# have no choice and we have to remove it even while we read the
# code. If we don't do this, a __loader__ attribute in the
# existing __main__ module may prevent location of the new module.
main_name = "__main__"
saved_main = sys.modules[main_name]
del sys.modules[main_name]
try:
mod_name, loader, code, fname = _get_main_module_details()
finally:
sys.modules[main_name] = saved_main
pkg_name = ""
with _ModifiedArgv0(path_name):
with _TempModule(run_name) as temp_module:
mod_globals = temp_module.module.__dict__
return _run_code(code, mod_globals, init_globals,
run_name, fname, loader, pkg_name).copy()
finally:
try:
sys.path.remove(path_name)
except ValueError:
pass
|
[
"def",
"run_path",
"(",
"path_name",
",",
"init_globals",
"=",
"None",
",",
"run_name",
"=",
"None",
")",
":",
"if",
"run_name",
"is",
"None",
":",
"run_name",
"=",
"\"<run_path>\"",
"importer",
"=",
"_get_importer",
"(",
"path_name",
")",
"if",
"isinstance",
"(",
"importer",
",",
"imp",
".",
"NullImporter",
")",
":",
"# Not a valid sys.path entry, so run the code directly",
"# execfile() doesn't help as we want to allow compiled files",
"code",
"=",
"_get_code_from_file",
"(",
"path_name",
")",
"return",
"_run_module_code",
"(",
"code",
",",
"init_globals",
",",
"run_name",
",",
"path_name",
")",
"else",
":",
"# Importer is defined for path, so add it to",
"# the start of sys.path",
"sys",
".",
"path",
".",
"insert",
"(",
"0",
",",
"path_name",
")",
"try",
":",
"# Here's where things are a little different from the run_module",
"# case. There, we only had to replace the module in sys while the",
"# code was running and doing so was somewhat optional. Here, we",
"# have no choice and we have to remove it even while we read the",
"# code. If we don't do this, a __loader__ attribute in the",
"# existing __main__ module may prevent location of the new module.",
"main_name",
"=",
"\"__main__\"",
"saved_main",
"=",
"sys",
".",
"modules",
"[",
"main_name",
"]",
"del",
"sys",
".",
"modules",
"[",
"main_name",
"]",
"try",
":",
"mod_name",
",",
"loader",
",",
"code",
",",
"fname",
"=",
"_get_main_module_details",
"(",
")",
"finally",
":",
"sys",
".",
"modules",
"[",
"main_name",
"]",
"=",
"saved_main",
"pkg_name",
"=",
"\"\"",
"with",
"_ModifiedArgv0",
"(",
"path_name",
")",
":",
"with",
"_TempModule",
"(",
"run_name",
")",
"as",
"temp_module",
":",
"mod_globals",
"=",
"temp_module",
".",
"module",
".",
"__dict__",
"return",
"_run_code",
"(",
"code",
",",
"mod_globals",
",",
"init_globals",
",",
"run_name",
",",
"fname",
",",
"loader",
",",
"pkg_name",
")",
".",
"copy",
"(",
")",
"finally",
":",
"try",
":",
"sys",
".",
"path",
".",
"remove",
"(",
"path_name",
")",
"except",
"ValueError",
":",
"pass"
] |
Execute code located at the specified filesystem location
Returns the resulting top level namespace dictionary
The file path may refer directly to a Python script (i.e.
one that could be directly executed with execfile) or else
it may refer to a zipfile or directory containing a top
level __main__.py script.
|
[
"Execute",
"code",
"located",
"at",
"the",
"specified",
"filesystem",
"location"
] |
d391dfa62f47e49d48328ee9cf08aa114256fd33
|
https://github.com/soravux/scoop/blob/d391dfa62f47e49d48328ee9cf08aa114256fd33/scoop/backports/runpy.py#L224-L270
|
10,956
|
soravux/scoop
|
examples/tree_traversal.py
|
maxTreeDepthDivide
|
def maxTreeDepthDivide(rootValue, currentDepth=0, parallelLevel=2):
"""Finds a tree node that represents rootValue and computes the max depth
of this tree branch.
This function will emit new futures until currentDepth=parallelLevel"""
thisRoot = shared.getConst('myTree').search(rootValue)
if currentDepth >= parallelLevel:
return thisRoot.maxDepth(currentDepth)
else:
# Base case
if not any([thisRoot.left, thisRoot.right]):
return currentDepth
if not all([thisRoot.left, thisRoot.right]):
return thisRoot.maxDepth(currentDepth)
# Parallel recursion
return max(
futures.map(
maxTreeDepthDivide,
[
thisRoot.left.payload,
thisRoot.right.payload,
],
cycle([currentDepth + 1]),
cycle([parallelLevel]),
)
)
|
python
|
def maxTreeDepthDivide(rootValue, currentDepth=0, parallelLevel=2):
"""Finds a tree node that represents rootValue and computes the max depth
of this tree branch.
This function will emit new futures until currentDepth=parallelLevel"""
thisRoot = shared.getConst('myTree').search(rootValue)
if currentDepth >= parallelLevel:
return thisRoot.maxDepth(currentDepth)
else:
# Base case
if not any([thisRoot.left, thisRoot.right]):
return currentDepth
if not all([thisRoot.left, thisRoot.right]):
return thisRoot.maxDepth(currentDepth)
# Parallel recursion
return max(
futures.map(
maxTreeDepthDivide,
[
thisRoot.left.payload,
thisRoot.right.payload,
],
cycle([currentDepth + 1]),
cycle([parallelLevel]),
)
)
|
[
"def",
"maxTreeDepthDivide",
"(",
"rootValue",
",",
"currentDepth",
"=",
"0",
",",
"parallelLevel",
"=",
"2",
")",
":",
"thisRoot",
"=",
"shared",
".",
"getConst",
"(",
"'myTree'",
")",
".",
"search",
"(",
"rootValue",
")",
"if",
"currentDepth",
">=",
"parallelLevel",
":",
"return",
"thisRoot",
".",
"maxDepth",
"(",
"currentDepth",
")",
"else",
":",
"# Base case",
"if",
"not",
"any",
"(",
"[",
"thisRoot",
".",
"left",
",",
"thisRoot",
".",
"right",
"]",
")",
":",
"return",
"currentDepth",
"if",
"not",
"all",
"(",
"[",
"thisRoot",
".",
"left",
",",
"thisRoot",
".",
"right",
"]",
")",
":",
"return",
"thisRoot",
".",
"maxDepth",
"(",
"currentDepth",
")",
"# Parallel recursion",
"return",
"max",
"(",
"futures",
".",
"map",
"(",
"maxTreeDepthDivide",
",",
"[",
"thisRoot",
".",
"left",
".",
"payload",
",",
"thisRoot",
".",
"right",
".",
"payload",
",",
"]",
",",
"cycle",
"(",
"[",
"currentDepth",
"+",
"1",
"]",
")",
",",
"cycle",
"(",
"[",
"parallelLevel",
"]",
")",
",",
")",
")"
] |
Finds a tree node that represents rootValue and computes the max depth
of this tree branch.
This function will emit new futures until currentDepth=parallelLevel
|
[
"Finds",
"a",
"tree",
"node",
"that",
"represents",
"rootValue",
"and",
"computes",
"the",
"max",
"depth",
"of",
"this",
"tree",
"branch",
".",
"This",
"function",
"will",
"emit",
"new",
"futures",
"until",
"currentDepth",
"=",
"parallelLevel"
] |
d391dfa62f47e49d48328ee9cf08aa114256fd33
|
https://github.com/soravux/scoop/blob/d391dfa62f47e49d48328ee9cf08aa114256fd33/examples/tree_traversal.py#L27-L52
|
10,957
|
soravux/scoop
|
examples/tree_traversal.py
|
BinaryTreeNode.insert
|
def insert(self, value):
"""Insert a value in the tree"""
if not self.payload or value == self.payload:
self.payload = value
else:
if value <= self.payload:
if self.left:
self.left.insert(value)
else:
self.left = BinaryTreeNode(value)
else:
if self.right:
self.right.insert(value)
else:
self.right = BinaryTreeNode(value)
|
python
|
def insert(self, value):
"""Insert a value in the tree"""
if not self.payload or value == self.payload:
self.payload = value
else:
if value <= self.payload:
if self.left:
self.left.insert(value)
else:
self.left = BinaryTreeNode(value)
else:
if self.right:
self.right.insert(value)
else:
self.right = BinaryTreeNode(value)
|
[
"def",
"insert",
"(",
"self",
",",
"value",
")",
":",
"if",
"not",
"self",
".",
"payload",
"or",
"value",
"==",
"self",
".",
"payload",
":",
"self",
".",
"payload",
"=",
"value",
"else",
":",
"if",
"value",
"<=",
"self",
".",
"payload",
":",
"if",
"self",
".",
"left",
":",
"self",
".",
"left",
".",
"insert",
"(",
"value",
")",
"else",
":",
"self",
".",
"left",
"=",
"BinaryTreeNode",
"(",
"value",
")",
"else",
":",
"if",
"self",
".",
"right",
":",
"self",
".",
"right",
".",
"insert",
"(",
"value",
")",
"else",
":",
"self",
".",
"right",
"=",
"BinaryTreeNode",
"(",
"value",
")"
] |
Insert a value in the tree
|
[
"Insert",
"a",
"value",
"in",
"the",
"tree"
] |
d391dfa62f47e49d48328ee9cf08aa114256fd33
|
https://github.com/soravux/scoop/blob/d391dfa62f47e49d48328ee9cf08aa114256fd33/examples/tree_traversal.py#L62-L76
|
10,958
|
soravux/scoop
|
examples/tree_traversal.py
|
BinaryTreeNode.maxDepth
|
def maxDepth(self, currentDepth=0):
"""Compute the depth of the longest branch of the tree"""
if not any((self.left, self.right)):
return currentDepth
result = 0
for child in (self.left, self.right):
if child:
result = max(result, child.maxDepth(currentDepth + 1))
return result
|
python
|
def maxDepth(self, currentDepth=0):
"""Compute the depth of the longest branch of the tree"""
if not any((self.left, self.right)):
return currentDepth
result = 0
for child in (self.left, self.right):
if child:
result = max(result, child.maxDepth(currentDepth + 1))
return result
|
[
"def",
"maxDepth",
"(",
"self",
",",
"currentDepth",
"=",
"0",
")",
":",
"if",
"not",
"any",
"(",
"(",
"self",
".",
"left",
",",
"self",
".",
"right",
")",
")",
":",
"return",
"currentDepth",
"result",
"=",
"0",
"for",
"child",
"in",
"(",
"self",
".",
"left",
",",
"self",
".",
"right",
")",
":",
"if",
"child",
":",
"result",
"=",
"max",
"(",
"result",
",",
"child",
".",
"maxDepth",
"(",
"currentDepth",
"+",
"1",
")",
")",
"return",
"result"
] |
Compute the depth of the longest branch of the tree
|
[
"Compute",
"the",
"depth",
"of",
"the",
"longest",
"branch",
"of",
"the",
"tree"
] |
d391dfa62f47e49d48328ee9cf08aa114256fd33
|
https://github.com/soravux/scoop/blob/d391dfa62f47e49d48328ee9cf08aa114256fd33/examples/tree_traversal.py#L78-L86
|
10,959
|
soravux/scoop
|
examples/tree_traversal.py
|
BinaryTreeNode.search
|
def search(self, value):
"""Find an element in the tree"""
if self.payload == value:
return self
else:
if value <= self.payload:
if self.left:
return self.left.search(value)
else:
if self.right:
return self.right.search(value)
return None
|
python
|
def search(self, value):
"""Find an element in the tree"""
if self.payload == value:
return self
else:
if value <= self.payload:
if self.left:
return self.left.search(value)
else:
if self.right:
return self.right.search(value)
return None
|
[
"def",
"search",
"(",
"self",
",",
"value",
")",
":",
"if",
"self",
".",
"payload",
"==",
"value",
":",
"return",
"self",
"else",
":",
"if",
"value",
"<=",
"self",
".",
"payload",
":",
"if",
"self",
".",
"left",
":",
"return",
"self",
".",
"left",
".",
"search",
"(",
"value",
")",
"else",
":",
"if",
"self",
".",
"right",
":",
"return",
"self",
".",
"right",
".",
"search",
"(",
"value",
")",
"return",
"None"
] |
Find an element in the tree
|
[
"Find",
"an",
"element",
"in",
"the",
"tree"
] |
d391dfa62f47e49d48328ee9cf08aa114256fd33
|
https://github.com/soravux/scoop/blob/d391dfa62f47e49d48328ee9cf08aa114256fd33/examples/tree_traversal.py#L88-L99
|
10,960
|
soravux/scoop
|
scoop/_comm/scoopzmq.py
|
ZMQCommunicator.createZMQSocket
|
def createZMQSocket(self, sock_type):
"""Create a socket of the given sock_type and deactivate message dropping"""
sock = self.ZMQcontext.socket(sock_type)
sock.setsockopt(zmq.LINGER, LINGER_TIME)
sock.setsockopt(zmq.IPV4ONLY, 0)
# Remove message dropping
sock.setsockopt(zmq.SNDHWM, 0)
sock.setsockopt(zmq.RCVHWM, 0)
try:
sock.setsockopt(zmq.IMMEDIATE, 1)
except:
# This parameter was recently added by new libzmq versions
pass
# Don't accept unroutable messages
if sock_type == zmq.ROUTER:
sock.setsockopt(zmq.ROUTER_MANDATORY, 1)
return sock
|
python
|
def createZMQSocket(self, sock_type):
"""Create a socket of the given sock_type and deactivate message dropping"""
sock = self.ZMQcontext.socket(sock_type)
sock.setsockopt(zmq.LINGER, LINGER_TIME)
sock.setsockopt(zmq.IPV4ONLY, 0)
# Remove message dropping
sock.setsockopt(zmq.SNDHWM, 0)
sock.setsockopt(zmq.RCVHWM, 0)
try:
sock.setsockopt(zmq.IMMEDIATE, 1)
except:
# This parameter was recently added by new libzmq versions
pass
# Don't accept unroutable messages
if sock_type == zmq.ROUTER:
sock.setsockopt(zmq.ROUTER_MANDATORY, 1)
return sock
|
[
"def",
"createZMQSocket",
"(",
"self",
",",
"sock_type",
")",
":",
"sock",
"=",
"self",
".",
"ZMQcontext",
".",
"socket",
"(",
"sock_type",
")",
"sock",
".",
"setsockopt",
"(",
"zmq",
".",
"LINGER",
",",
"LINGER_TIME",
")",
"sock",
".",
"setsockopt",
"(",
"zmq",
".",
"IPV4ONLY",
",",
"0",
")",
"# Remove message dropping",
"sock",
".",
"setsockopt",
"(",
"zmq",
".",
"SNDHWM",
",",
"0",
")",
"sock",
".",
"setsockopt",
"(",
"zmq",
".",
"RCVHWM",
",",
"0",
")",
"try",
":",
"sock",
".",
"setsockopt",
"(",
"zmq",
".",
"IMMEDIATE",
",",
"1",
")",
"except",
":",
"# This parameter was recently added by new libzmq versions",
"pass",
"# Don't accept unroutable messages",
"if",
"sock_type",
"==",
"zmq",
".",
"ROUTER",
":",
"sock",
".",
"setsockopt",
"(",
"zmq",
".",
"ROUTER_MANDATORY",
",",
"1",
")",
"return",
"sock"
] |
Create a socket of the given sock_type and deactivate message dropping
|
[
"Create",
"a",
"socket",
"of",
"the",
"given",
"sock_type",
"and",
"deactivate",
"message",
"dropping"
] |
d391dfa62f47e49d48328ee9cf08aa114256fd33
|
https://github.com/soravux/scoop/blob/d391dfa62f47e49d48328ee9cf08aa114256fd33/scoop/_comm/scoopzmq.py#L164-L182
|
10,961
|
soravux/scoop
|
scoop/_comm/scoopzmq.py
|
ZMQCommunicator._reportFutures
|
def _reportFutures(self):
"""Sends futures status updates to broker at intervals of
scoop.TIME_BETWEEN_STATUS_REPORTS seconds. Is intended to be run by a
separate thread."""
try:
while True:
time.sleep(scoop.TIME_BETWEEN_STATUS_REPORTS)
fids = set(x.id for x in scoop._control.execQueue.movable)
fids.update(set(x.id for x in scoop._control.execQueue.ready))
fids.update(set(x.id for x in scoop._control.execQueue.inprogress))
self.socket.send_multipart([
STATUS_UPDATE,
pickle.dumps(fids),
])
except AttributeError:
# The process is being shut down.
pass
|
python
|
def _reportFutures(self):
"""Sends futures status updates to broker at intervals of
scoop.TIME_BETWEEN_STATUS_REPORTS seconds. Is intended to be run by a
separate thread."""
try:
while True:
time.sleep(scoop.TIME_BETWEEN_STATUS_REPORTS)
fids = set(x.id for x in scoop._control.execQueue.movable)
fids.update(set(x.id for x in scoop._control.execQueue.ready))
fids.update(set(x.id for x in scoop._control.execQueue.inprogress))
self.socket.send_multipart([
STATUS_UPDATE,
pickle.dumps(fids),
])
except AttributeError:
# The process is being shut down.
pass
|
[
"def",
"_reportFutures",
"(",
"self",
")",
":",
"try",
":",
"while",
"True",
":",
"time",
".",
"sleep",
"(",
"scoop",
".",
"TIME_BETWEEN_STATUS_REPORTS",
")",
"fids",
"=",
"set",
"(",
"x",
".",
"id",
"for",
"x",
"in",
"scoop",
".",
"_control",
".",
"execQueue",
".",
"movable",
")",
"fids",
".",
"update",
"(",
"set",
"(",
"x",
".",
"id",
"for",
"x",
"in",
"scoop",
".",
"_control",
".",
"execQueue",
".",
"ready",
")",
")",
"fids",
".",
"update",
"(",
"set",
"(",
"x",
".",
"id",
"for",
"x",
"in",
"scoop",
".",
"_control",
".",
"execQueue",
".",
"inprogress",
")",
")",
"self",
".",
"socket",
".",
"send_multipart",
"(",
"[",
"STATUS_UPDATE",
",",
"pickle",
".",
"dumps",
"(",
"fids",
")",
",",
"]",
")",
"except",
"AttributeError",
":",
"# The process is being shut down.",
"pass"
] |
Sends futures status updates to broker at intervals of
scoop.TIME_BETWEEN_STATUS_REPORTS seconds. Is intended to be run by a
separate thread.
|
[
"Sends",
"futures",
"status",
"updates",
"to",
"broker",
"at",
"intervals",
"of",
"scoop",
".",
"TIME_BETWEEN_STATUS_REPORTS",
"seconds",
".",
"Is",
"intended",
"to",
"be",
"run",
"by",
"a",
"separate",
"thread",
"."
] |
d391dfa62f47e49d48328ee9cf08aa114256fd33
|
https://github.com/soravux/scoop/blob/d391dfa62f47e49d48328ee9cf08aa114256fd33/scoop/_comm/scoopzmq.py#L184-L200
|
10,962
|
soravux/scoop
|
scoop/_comm/scoopzmq.py
|
ZMQCommunicator._sendReply
|
def _sendReply(self, destination, fid, *args):
"""Send a REPLY directly to its destination. If it doesn't work, launch
it back to the broker."""
# Try to send the result directly to its parent
self.addPeer(destination)
try:
self.direct_socket.send_multipart([
destination,
REPLY,
] + list(args),
flags=zmq.NOBLOCK)
except zmq.error.ZMQError as e:
# Fallback on Broker routing if no direct connection possible
scoop.logger.debug(
"{0}: Could not send result directly to peer {1}, routing through "
"broker.".format(scoop.worker, destination)
)
self.socket.send_multipart([
REPLY,
] + list(args) + [
destination,
])
self.socket.send_multipart([
STATUS_DONE,
fid,
])
|
python
|
def _sendReply(self, destination, fid, *args):
"""Send a REPLY directly to its destination. If it doesn't work, launch
it back to the broker."""
# Try to send the result directly to its parent
self.addPeer(destination)
try:
self.direct_socket.send_multipart([
destination,
REPLY,
] + list(args),
flags=zmq.NOBLOCK)
except zmq.error.ZMQError as e:
# Fallback on Broker routing if no direct connection possible
scoop.logger.debug(
"{0}: Could not send result directly to peer {1}, routing through "
"broker.".format(scoop.worker, destination)
)
self.socket.send_multipart([
REPLY,
] + list(args) + [
destination,
])
self.socket.send_multipart([
STATUS_DONE,
fid,
])
|
[
"def",
"_sendReply",
"(",
"self",
",",
"destination",
",",
"fid",
",",
"*",
"args",
")",
":",
"# Try to send the result directly to its parent",
"self",
".",
"addPeer",
"(",
"destination",
")",
"try",
":",
"self",
".",
"direct_socket",
".",
"send_multipart",
"(",
"[",
"destination",
",",
"REPLY",
",",
"]",
"+",
"list",
"(",
"args",
")",
",",
"flags",
"=",
"zmq",
".",
"NOBLOCK",
")",
"except",
"zmq",
".",
"error",
".",
"ZMQError",
"as",
"e",
":",
"# Fallback on Broker routing if no direct connection possible",
"scoop",
".",
"logger",
".",
"debug",
"(",
"\"{0}: Could not send result directly to peer {1}, routing through \"",
"\"broker.\"",
".",
"format",
"(",
"scoop",
".",
"worker",
",",
"destination",
")",
")",
"self",
".",
"socket",
".",
"send_multipart",
"(",
"[",
"REPLY",
",",
"]",
"+",
"list",
"(",
"args",
")",
"+",
"[",
"destination",
",",
"]",
")",
"self",
".",
"socket",
".",
"send_multipart",
"(",
"[",
"STATUS_DONE",
",",
"fid",
",",
"]",
")"
] |
Send a REPLY directly to its destination. If it doesn't work, launch
it back to the broker.
|
[
"Send",
"a",
"REPLY",
"directly",
"to",
"its",
"destination",
".",
"If",
"it",
"doesn",
"t",
"work",
"launch",
"it",
"back",
"to",
"the",
"broker",
"."
] |
d391dfa62f47e49d48328ee9cf08aa114256fd33
|
https://github.com/soravux/scoop/blob/d391dfa62f47e49d48328ee9cf08aa114256fd33/scoop/_comm/scoopzmq.py#L399-L426
|
10,963
|
soravux/scoop
|
scoop/futures.py
|
_startup
|
def _startup(rootFuture, *args, **kargs):
"""Initializes the SCOOP environment.
:param rootFuture: Any callable object (function or class object with *__call__*
method); this object will be called once and allows the use of parallel
calls inside this object.
:param args: A tuple of positional arguments that will be passed to the
callable object.
:param kargs: A dictionary of additional keyword arguments that will be
passed to the callable object.
:returns: The result of the root Future.
Be sure to launch your root Future using this method."""
import greenlet
global _controller
_controller = greenlet.greenlet(control.runController)
try:
result = _controller.switch(rootFuture, *args, **kargs)
except scoop._comm.Shutdown:
result = None
control.execQueue.shutdown()
return result
|
python
|
def _startup(rootFuture, *args, **kargs):
"""Initializes the SCOOP environment.
:param rootFuture: Any callable object (function or class object with *__call__*
method); this object will be called once and allows the use of parallel
calls inside this object.
:param args: A tuple of positional arguments that will be passed to the
callable object.
:param kargs: A dictionary of additional keyword arguments that will be
passed to the callable object.
:returns: The result of the root Future.
Be sure to launch your root Future using this method."""
import greenlet
global _controller
_controller = greenlet.greenlet(control.runController)
try:
result = _controller.switch(rootFuture, *args, **kargs)
except scoop._comm.Shutdown:
result = None
control.execQueue.shutdown()
return result
|
[
"def",
"_startup",
"(",
"rootFuture",
",",
"*",
"args",
",",
"*",
"*",
"kargs",
")",
":",
"import",
"greenlet",
"global",
"_controller",
"_controller",
"=",
"greenlet",
".",
"greenlet",
"(",
"control",
".",
"runController",
")",
"try",
":",
"result",
"=",
"_controller",
".",
"switch",
"(",
"rootFuture",
",",
"*",
"args",
",",
"*",
"*",
"kargs",
")",
"except",
"scoop",
".",
"_comm",
".",
"Shutdown",
":",
"result",
"=",
"None",
"control",
".",
"execQueue",
".",
"shutdown",
"(",
")",
"return",
"result"
] |
Initializes the SCOOP environment.
:param rootFuture: Any callable object (function or class object with *__call__*
method); this object will be called once and allows the use of parallel
calls inside this object.
:param args: A tuple of positional arguments that will be passed to the
callable object.
:param kargs: A dictionary of additional keyword arguments that will be
passed to the callable object.
:returns: The result of the root Future.
Be sure to launch your root Future using this method.
|
[
"Initializes",
"the",
"SCOOP",
"environment",
"."
] |
d391dfa62f47e49d48328ee9cf08aa114256fd33
|
https://github.com/soravux/scoop/blob/d391dfa62f47e49d48328ee9cf08aa114256fd33/scoop/futures.py#L47-L69
|
10,964
|
soravux/scoop
|
scoop/futures.py
|
_recursiveReduce
|
def _recursiveReduce(mapFunc, reductionFunc, scan, *iterables):
"""Generates the recursive reduction tree. Used by mapReduce."""
if iterables:
half = min(len(x) // 2 for x in iterables)
data_left = [list(x)[:half] for x in iterables]
data_right = [list(x)[half:] for x in iterables]
else:
data_left = data_right = [[]]
# Submit the left and right parts of the reduction
out_futures = [None, None]
out_results = [None, None]
for index, data in enumerate([data_left, data_right]):
if any(len(x) <= 1 for x in data):
out_results[index] = mapFunc(*list(zip(*data))[0])
else:
out_futures[index] = submit(
_recursiveReduce,
mapFunc,
reductionFunc,
scan,
*data
)
# Wait for the results
for index, future in enumerate(out_futures):
if future:
out_results[index] = future.result()
# Apply a scan if needed
if scan:
last_results = copy.copy(out_results)
if type(out_results[0]) is not list:
out_results[0] = [out_results[0]]
else:
last_results[0] = out_results[0][-1]
if type(out_results[1]) is list:
out_results[0].extend(out_results[1][:-1])
last_results[1] = out_results[1][-1]
out_results[0].append(reductionFunc(*last_results))
return out_results[0]
return reductionFunc(*out_results)
|
python
|
def _recursiveReduce(mapFunc, reductionFunc, scan, *iterables):
"""Generates the recursive reduction tree. Used by mapReduce."""
if iterables:
half = min(len(x) // 2 for x in iterables)
data_left = [list(x)[:half] for x in iterables]
data_right = [list(x)[half:] for x in iterables]
else:
data_left = data_right = [[]]
# Submit the left and right parts of the reduction
out_futures = [None, None]
out_results = [None, None]
for index, data in enumerate([data_left, data_right]):
if any(len(x) <= 1 for x in data):
out_results[index] = mapFunc(*list(zip(*data))[0])
else:
out_futures[index] = submit(
_recursiveReduce,
mapFunc,
reductionFunc,
scan,
*data
)
# Wait for the results
for index, future in enumerate(out_futures):
if future:
out_results[index] = future.result()
# Apply a scan if needed
if scan:
last_results = copy.copy(out_results)
if type(out_results[0]) is not list:
out_results[0] = [out_results[0]]
else:
last_results[0] = out_results[0][-1]
if type(out_results[1]) is list:
out_results[0].extend(out_results[1][:-1])
last_results[1] = out_results[1][-1]
out_results[0].append(reductionFunc(*last_results))
return out_results[0]
return reductionFunc(*out_results)
|
[
"def",
"_recursiveReduce",
"(",
"mapFunc",
",",
"reductionFunc",
",",
"scan",
",",
"*",
"iterables",
")",
":",
"if",
"iterables",
":",
"half",
"=",
"min",
"(",
"len",
"(",
"x",
")",
"//",
"2",
"for",
"x",
"in",
"iterables",
")",
"data_left",
"=",
"[",
"list",
"(",
"x",
")",
"[",
":",
"half",
"]",
"for",
"x",
"in",
"iterables",
"]",
"data_right",
"=",
"[",
"list",
"(",
"x",
")",
"[",
"half",
":",
"]",
"for",
"x",
"in",
"iterables",
"]",
"else",
":",
"data_left",
"=",
"data_right",
"=",
"[",
"[",
"]",
"]",
"# Submit the left and right parts of the reduction",
"out_futures",
"=",
"[",
"None",
",",
"None",
"]",
"out_results",
"=",
"[",
"None",
",",
"None",
"]",
"for",
"index",
",",
"data",
"in",
"enumerate",
"(",
"[",
"data_left",
",",
"data_right",
"]",
")",
":",
"if",
"any",
"(",
"len",
"(",
"x",
")",
"<=",
"1",
"for",
"x",
"in",
"data",
")",
":",
"out_results",
"[",
"index",
"]",
"=",
"mapFunc",
"(",
"*",
"list",
"(",
"zip",
"(",
"*",
"data",
")",
")",
"[",
"0",
"]",
")",
"else",
":",
"out_futures",
"[",
"index",
"]",
"=",
"submit",
"(",
"_recursiveReduce",
",",
"mapFunc",
",",
"reductionFunc",
",",
"scan",
",",
"*",
"data",
")",
"# Wait for the results",
"for",
"index",
",",
"future",
"in",
"enumerate",
"(",
"out_futures",
")",
":",
"if",
"future",
":",
"out_results",
"[",
"index",
"]",
"=",
"future",
".",
"result",
"(",
")",
"# Apply a scan if needed",
"if",
"scan",
":",
"last_results",
"=",
"copy",
".",
"copy",
"(",
"out_results",
")",
"if",
"type",
"(",
"out_results",
"[",
"0",
"]",
")",
"is",
"not",
"list",
":",
"out_results",
"[",
"0",
"]",
"=",
"[",
"out_results",
"[",
"0",
"]",
"]",
"else",
":",
"last_results",
"[",
"0",
"]",
"=",
"out_results",
"[",
"0",
"]",
"[",
"-",
"1",
"]",
"if",
"type",
"(",
"out_results",
"[",
"1",
"]",
")",
"is",
"list",
":",
"out_results",
"[",
"0",
"]",
".",
"extend",
"(",
"out_results",
"[",
"1",
"]",
"[",
":",
"-",
"1",
"]",
")",
"last_results",
"[",
"1",
"]",
"=",
"out_results",
"[",
"1",
"]",
"[",
"-",
"1",
"]",
"out_results",
"[",
"0",
"]",
".",
"append",
"(",
"reductionFunc",
"(",
"*",
"last_results",
")",
")",
"return",
"out_results",
"[",
"0",
"]",
"return",
"reductionFunc",
"(",
"*",
"out_results",
")"
] |
Generates the recursive reduction tree. Used by mapReduce.
|
[
"Generates",
"the",
"recursive",
"reduction",
"tree",
".",
"Used",
"by",
"mapReduce",
"."
] |
d391dfa62f47e49d48328ee9cf08aa114256fd33
|
https://github.com/soravux/scoop/blob/d391dfa62f47e49d48328ee9cf08aa114256fd33/scoop/futures.py#L154-L196
|
10,965
|
soravux/scoop
|
scoop/futures.py
|
_createFuture
|
def _createFuture(func, *args, **kwargs):
"""Helper function to create a future."""
assert callable(func), (
"The provided func parameter is not a callable."
)
if scoop.IS_ORIGIN and "SCOOP_WORKER" not in sys.modules:
sys.modules["SCOOP_WORKER"] = sys.modules["__main__"]
# If function is a lambda or class method, share it (or its parent object)
# beforehand
lambdaType = type(lambda: None)
funcIsLambda = isinstance(func, lambdaType) and func.__name__ == '<lambda>'
# Determine if function is a method. Methods derived from external
# languages such as C++ aren't detected by ismethod.
funcIsMethod = ismethod(func)
if funcIsLambda or funcIsMethod:
from .shared import SharedElementEncapsulation
func = SharedElementEncapsulation(func)
return Future(control.current.id, func, *args, **kwargs)
|
python
|
def _createFuture(func, *args, **kwargs):
"""Helper function to create a future."""
assert callable(func), (
"The provided func parameter is not a callable."
)
if scoop.IS_ORIGIN and "SCOOP_WORKER" not in sys.modules:
sys.modules["SCOOP_WORKER"] = sys.modules["__main__"]
# If function is a lambda or class method, share it (or its parent object)
# beforehand
lambdaType = type(lambda: None)
funcIsLambda = isinstance(func, lambdaType) and func.__name__ == '<lambda>'
# Determine if function is a method. Methods derived from external
# languages such as C++ aren't detected by ismethod.
funcIsMethod = ismethod(func)
if funcIsLambda or funcIsMethod:
from .shared import SharedElementEncapsulation
func = SharedElementEncapsulation(func)
return Future(control.current.id, func, *args, **kwargs)
|
[
"def",
"_createFuture",
"(",
"func",
",",
"*",
"args",
",",
"*",
"*",
"kwargs",
")",
":",
"assert",
"callable",
"(",
"func",
")",
",",
"(",
"\"The provided func parameter is not a callable.\"",
")",
"if",
"scoop",
".",
"IS_ORIGIN",
"and",
"\"SCOOP_WORKER\"",
"not",
"in",
"sys",
".",
"modules",
":",
"sys",
".",
"modules",
"[",
"\"SCOOP_WORKER\"",
"]",
"=",
"sys",
".",
"modules",
"[",
"\"__main__\"",
"]",
"# If function is a lambda or class method, share it (or its parent object)",
"# beforehand",
"lambdaType",
"=",
"type",
"(",
"lambda",
":",
"None",
")",
"funcIsLambda",
"=",
"isinstance",
"(",
"func",
",",
"lambdaType",
")",
"and",
"func",
".",
"__name__",
"==",
"'<lambda>'",
"# Determine if function is a method. Methods derived from external",
"# languages such as C++ aren't detected by ismethod.",
"funcIsMethod",
"=",
"ismethod",
"(",
"func",
")",
"if",
"funcIsLambda",
"or",
"funcIsMethod",
":",
"from",
".",
"shared",
"import",
"SharedElementEncapsulation",
"func",
"=",
"SharedElementEncapsulation",
"(",
"func",
")",
"return",
"Future",
"(",
"control",
".",
"current",
".",
"id",
",",
"func",
",",
"*",
"args",
",",
"*",
"*",
"kwargs",
")"
] |
Helper function to create a future.
|
[
"Helper",
"function",
"to",
"create",
"a",
"future",
"."
] |
d391dfa62f47e49d48328ee9cf08aa114256fd33
|
https://github.com/soravux/scoop/blob/d391dfa62f47e49d48328ee9cf08aa114256fd33/scoop/futures.py#L259-L279
|
10,966
|
soravux/scoop
|
scoop/futures.py
|
_waitAny
|
def _waitAny(*children):
"""Waits on any child Future created by the calling Future.
:param children: A tuple of children Future objects spawned by the calling
Future.
:return: A generator function that iterates on futures that are done.
The generator produces results of the children in a non deterministic order
that depends on the particular parallel execution of the Futures. The
generator returns a tuple as soon as one becomes available."""
n = len(children)
# check for available results and index those unavailable
for index, future in enumerate(children):
if future.exceptionValue:
raise future.exceptionValue
if future._ended():
future._delete()
yield future
n -= 1
else:
future.index = index
future = control.current
while n > 0:
# wait for remaining results; switch to controller
future.stopWatch.halt()
childFuture = _controller.switch(future)
future.stopWatch.resume()
if childFuture.exceptionValue:
raise childFuture.exceptionValue
# Only yield if executed future was in children, otherwise loop
if childFuture in children:
childFuture._delete()
yield childFuture
n -= 1
|
python
|
def _waitAny(*children):
"""Waits on any child Future created by the calling Future.
:param children: A tuple of children Future objects spawned by the calling
Future.
:return: A generator function that iterates on futures that are done.
The generator produces results of the children in a non deterministic order
that depends on the particular parallel execution of the Futures. The
generator returns a tuple as soon as one becomes available."""
n = len(children)
# check for available results and index those unavailable
for index, future in enumerate(children):
if future.exceptionValue:
raise future.exceptionValue
if future._ended():
future._delete()
yield future
n -= 1
else:
future.index = index
future = control.current
while n > 0:
# wait for remaining results; switch to controller
future.stopWatch.halt()
childFuture = _controller.switch(future)
future.stopWatch.resume()
if childFuture.exceptionValue:
raise childFuture.exceptionValue
# Only yield if executed future was in children, otherwise loop
if childFuture in children:
childFuture._delete()
yield childFuture
n -= 1
|
[
"def",
"_waitAny",
"(",
"*",
"children",
")",
":",
"n",
"=",
"len",
"(",
"children",
")",
"# check for available results and index those unavailable",
"for",
"index",
",",
"future",
"in",
"enumerate",
"(",
"children",
")",
":",
"if",
"future",
".",
"exceptionValue",
":",
"raise",
"future",
".",
"exceptionValue",
"if",
"future",
".",
"_ended",
"(",
")",
":",
"future",
".",
"_delete",
"(",
")",
"yield",
"future",
"n",
"-=",
"1",
"else",
":",
"future",
".",
"index",
"=",
"index",
"future",
"=",
"control",
".",
"current",
"while",
"n",
">",
"0",
":",
"# wait for remaining results; switch to controller",
"future",
".",
"stopWatch",
".",
"halt",
"(",
")",
"childFuture",
"=",
"_controller",
".",
"switch",
"(",
"future",
")",
"future",
".",
"stopWatch",
".",
"resume",
"(",
")",
"if",
"childFuture",
".",
"exceptionValue",
":",
"raise",
"childFuture",
".",
"exceptionValue",
"# Only yield if executed future was in children, otherwise loop",
"if",
"childFuture",
"in",
"children",
":",
"childFuture",
".",
"_delete",
"(",
")",
"yield",
"childFuture",
"n",
"-=",
"1"
] |
Waits on any child Future created by the calling Future.
:param children: A tuple of children Future objects spawned by the calling
Future.
:return: A generator function that iterates on futures that are done.
The generator produces results of the children in a non deterministic order
that depends on the particular parallel execution of the Futures. The
generator returns a tuple as soon as one becomes available.
|
[
"Waits",
"on",
"any",
"child",
"Future",
"created",
"by",
"the",
"calling",
"Future",
"."
] |
d391dfa62f47e49d48328ee9cf08aa114256fd33
|
https://github.com/soravux/scoop/blob/d391dfa62f47e49d48328ee9cf08aa114256fd33/scoop/futures.py#L308-L342
|
10,967
|
soravux/scoop
|
scoop/futures.py
|
wait
|
def wait(fs, timeout=-1, return_when=ALL_COMPLETED):
"""Wait for the futures in the given sequence to complete.
Using this function may prevent a worker from executing.
:param fs: The sequence of Futures to wait upon.
:param timeout: The maximum number of seconds to wait. If negative or not
specified, then there is no limit on the wait time.
:param return_when: Indicates when this function should return. The options
are:
=============== ================================================
FIRST_COMPLETED Return when any future finishes or is cancelled.
FIRST_EXCEPTION Return when any future finishes by raising an
exception. If no future raises an exception then
it is equivalent to ALL_COMPLETED.
ALL_COMPLETED Return when all futures finish or are cancelled.
=============== ================================================
:return: A named 2-tuple of sets. The first set, named 'done', contains the
futures that completed (is finished or cancelled) before the wait
completed. The second set, named 'not_done', contains uncompleted
futures."""
DoneAndNotDoneFutures = namedtuple('DoneAndNotDoneFutures', 'done not_done')
if timeout < 0:
# Negative timeout means blocking.
if return_when == FIRST_COMPLETED:
next(_waitAny(*fs))
elif return_when in [ALL_COMPLETED, FIRST_EXCEPTION]:
for _ in _waitAll(*fs):
pass
done = set(f for f in fs if f.done())
not_done = set(fs) - done
return DoneAndNotDoneFutures(done, not_done)
elif timeout == 0:
# Zero-value entry means non-blocking
control.execQueue.flush()
control.execQueue.updateQueue()
done = set(f for f in fs if f._ended())
not_done = set(fs) - done
return DoneAndNotDoneFutures(done, not_done)
else:
# Any other value means blocking for a given time.
done = set()
start_time = time.time()
while time.time() - start_time < timeout:
# Flush futures on local queue (to be executed remotely)
control.execQueue.flush()
# Block until data arrives (to free CPU time)
control.execQueue.socket._poll(time.time() - start_time)
# Update queue
control.execQueue.updateQueue()
for f in fs:
if f._ended():
done.add(f)
not_done = set(fs) - done
if return_when == FIRST_COMPLETED and len(done) > 0:
break
if len(not_done) == 0:
break
return DoneAndNotDoneFutures(done, not_done)
|
python
|
def wait(fs, timeout=-1, return_when=ALL_COMPLETED):
"""Wait for the futures in the given sequence to complete.
Using this function may prevent a worker from executing.
:param fs: The sequence of Futures to wait upon.
:param timeout: The maximum number of seconds to wait. If negative or not
specified, then there is no limit on the wait time.
:param return_when: Indicates when this function should return. The options
are:
=============== ================================================
FIRST_COMPLETED Return when any future finishes or is cancelled.
FIRST_EXCEPTION Return when any future finishes by raising an
exception. If no future raises an exception then
it is equivalent to ALL_COMPLETED.
ALL_COMPLETED Return when all futures finish or are cancelled.
=============== ================================================
:return: A named 2-tuple of sets. The first set, named 'done', contains the
futures that completed (is finished or cancelled) before the wait
completed. The second set, named 'not_done', contains uncompleted
futures."""
DoneAndNotDoneFutures = namedtuple('DoneAndNotDoneFutures', 'done not_done')
if timeout < 0:
# Negative timeout means blocking.
if return_when == FIRST_COMPLETED:
next(_waitAny(*fs))
elif return_when in [ALL_COMPLETED, FIRST_EXCEPTION]:
for _ in _waitAll(*fs):
pass
done = set(f for f in fs if f.done())
not_done = set(fs) - done
return DoneAndNotDoneFutures(done, not_done)
elif timeout == 0:
# Zero-value entry means non-blocking
control.execQueue.flush()
control.execQueue.updateQueue()
done = set(f for f in fs if f._ended())
not_done = set(fs) - done
return DoneAndNotDoneFutures(done, not_done)
else:
# Any other value means blocking for a given time.
done = set()
start_time = time.time()
while time.time() - start_time < timeout:
# Flush futures on local queue (to be executed remotely)
control.execQueue.flush()
# Block until data arrives (to free CPU time)
control.execQueue.socket._poll(time.time() - start_time)
# Update queue
control.execQueue.updateQueue()
for f in fs:
if f._ended():
done.add(f)
not_done = set(fs) - done
if return_when == FIRST_COMPLETED and len(done) > 0:
break
if len(not_done) == 0:
break
return DoneAndNotDoneFutures(done, not_done)
|
[
"def",
"wait",
"(",
"fs",
",",
"timeout",
"=",
"-",
"1",
",",
"return_when",
"=",
"ALL_COMPLETED",
")",
":",
"DoneAndNotDoneFutures",
"=",
"namedtuple",
"(",
"'DoneAndNotDoneFutures'",
",",
"'done not_done'",
")",
"if",
"timeout",
"<",
"0",
":",
"# Negative timeout means blocking.",
"if",
"return_when",
"==",
"FIRST_COMPLETED",
":",
"next",
"(",
"_waitAny",
"(",
"*",
"fs",
")",
")",
"elif",
"return_when",
"in",
"[",
"ALL_COMPLETED",
",",
"FIRST_EXCEPTION",
"]",
":",
"for",
"_",
"in",
"_waitAll",
"(",
"*",
"fs",
")",
":",
"pass",
"done",
"=",
"set",
"(",
"f",
"for",
"f",
"in",
"fs",
"if",
"f",
".",
"done",
"(",
")",
")",
"not_done",
"=",
"set",
"(",
"fs",
")",
"-",
"done",
"return",
"DoneAndNotDoneFutures",
"(",
"done",
",",
"not_done",
")",
"elif",
"timeout",
"==",
"0",
":",
"# Zero-value entry means non-blocking",
"control",
".",
"execQueue",
".",
"flush",
"(",
")",
"control",
".",
"execQueue",
".",
"updateQueue",
"(",
")",
"done",
"=",
"set",
"(",
"f",
"for",
"f",
"in",
"fs",
"if",
"f",
".",
"_ended",
"(",
")",
")",
"not_done",
"=",
"set",
"(",
"fs",
")",
"-",
"done",
"return",
"DoneAndNotDoneFutures",
"(",
"done",
",",
"not_done",
")",
"else",
":",
"# Any other value means blocking for a given time.",
"done",
"=",
"set",
"(",
")",
"start_time",
"=",
"time",
".",
"time",
"(",
")",
"while",
"time",
".",
"time",
"(",
")",
"-",
"start_time",
"<",
"timeout",
":",
"# Flush futures on local queue (to be executed remotely)",
"control",
".",
"execQueue",
".",
"flush",
"(",
")",
"# Block until data arrives (to free CPU time)",
"control",
".",
"execQueue",
".",
"socket",
".",
"_poll",
"(",
"time",
".",
"time",
"(",
")",
"-",
"start_time",
")",
"# Update queue",
"control",
".",
"execQueue",
".",
"updateQueue",
"(",
")",
"for",
"f",
"in",
"fs",
":",
"if",
"f",
".",
"_ended",
"(",
")",
":",
"done",
".",
"add",
"(",
"f",
")",
"not_done",
"=",
"set",
"(",
"fs",
")",
"-",
"done",
"if",
"return_when",
"==",
"FIRST_COMPLETED",
"and",
"len",
"(",
"done",
")",
">",
"0",
":",
"break",
"if",
"len",
"(",
"not_done",
")",
"==",
"0",
":",
"break",
"return",
"DoneAndNotDoneFutures",
"(",
"done",
",",
"not_done",
")"
] |
Wait for the futures in the given sequence to complete.
Using this function may prevent a worker from executing.
:param fs: The sequence of Futures to wait upon.
:param timeout: The maximum number of seconds to wait. If negative or not
specified, then there is no limit on the wait time.
:param return_when: Indicates when this function should return. The options
are:
=============== ================================================
FIRST_COMPLETED Return when any future finishes or is cancelled.
FIRST_EXCEPTION Return when any future finishes by raising an
exception. If no future raises an exception then
it is equivalent to ALL_COMPLETED.
ALL_COMPLETED Return when all futures finish or are cancelled.
=============== ================================================
:return: A named 2-tuple of sets. The first set, named 'done', contains the
futures that completed (is finished or cancelled) before the wait
completed. The second set, named 'not_done', contains uncompleted
futures.
|
[
"Wait",
"for",
"the",
"futures",
"in",
"the",
"given",
"sequence",
"to",
"complete",
".",
"Using",
"this",
"function",
"may",
"prevent",
"a",
"worker",
"from",
"executing",
"."
] |
d391dfa62f47e49d48328ee9cf08aa114256fd33
|
https://github.com/soravux/scoop/blob/d391dfa62f47e49d48328ee9cf08aa114256fd33/scoop/futures.py#L364-L429
|
10,968
|
soravux/scoop
|
scoop/_control.py
|
advertiseBrokerWorkerDown
|
def advertiseBrokerWorkerDown(exctype, value, traceback):
"""Hook advertizing the broker if an impromptu shutdown is occuring."""
if not scoop.SHUTDOWN_REQUESTED:
execQueue.shutdown()
sys.__excepthook__(exctype, value, traceback)
|
python
|
def advertiseBrokerWorkerDown(exctype, value, traceback):
"""Hook advertizing the broker if an impromptu shutdown is occuring."""
if not scoop.SHUTDOWN_REQUESTED:
execQueue.shutdown()
sys.__excepthook__(exctype, value, traceback)
|
[
"def",
"advertiseBrokerWorkerDown",
"(",
"exctype",
",",
"value",
",",
"traceback",
")",
":",
"if",
"not",
"scoop",
".",
"SHUTDOWN_REQUESTED",
":",
"execQueue",
".",
"shutdown",
"(",
")",
"sys",
".",
"__excepthook__",
"(",
"exctype",
",",
"value",
",",
"traceback",
")"
] |
Hook advertizing the broker if an impromptu shutdown is occuring.
|
[
"Hook",
"advertizing",
"the",
"broker",
"if",
"an",
"impromptu",
"shutdown",
"is",
"occuring",
"."
] |
d391dfa62f47e49d48328ee9cf08aa114256fd33
|
https://github.com/soravux/scoop/blob/d391dfa62f47e49d48328ee9cf08aa114256fd33/scoop/_control.py#L91-L95
|
10,969
|
soravux/scoop
|
scoop/_control.py
|
delFutureById
|
def delFutureById(futureId, parentId):
"""Delete future on id basis"""
try:
del futureDict[futureId]
except KeyError:
pass
try:
toDel = [a for a in futureDict[parentId].children if a.id == futureId]
for f in toDel:
del futureDict[parentId].children[f]
except KeyError:
pass
|
python
|
def delFutureById(futureId, parentId):
"""Delete future on id basis"""
try:
del futureDict[futureId]
except KeyError:
pass
try:
toDel = [a for a in futureDict[parentId].children if a.id == futureId]
for f in toDel:
del futureDict[parentId].children[f]
except KeyError:
pass
|
[
"def",
"delFutureById",
"(",
"futureId",
",",
"parentId",
")",
":",
"try",
":",
"del",
"futureDict",
"[",
"futureId",
"]",
"except",
"KeyError",
":",
"pass",
"try",
":",
"toDel",
"=",
"[",
"a",
"for",
"a",
"in",
"futureDict",
"[",
"parentId",
"]",
".",
"children",
"if",
"a",
".",
"id",
"==",
"futureId",
"]",
"for",
"f",
"in",
"toDel",
":",
"del",
"futureDict",
"[",
"parentId",
"]",
".",
"children",
"[",
"f",
"]",
"except",
"KeyError",
":",
"pass"
] |
Delete future on id basis
|
[
"Delete",
"future",
"on",
"id",
"basis"
] |
d391dfa62f47e49d48328ee9cf08aa114256fd33
|
https://github.com/soravux/scoop/blob/d391dfa62f47e49d48328ee9cf08aa114256fd33/scoop/_control.py#L108-L119
|
10,970
|
soravux/scoop
|
scoop/_control.py
|
delFuture
|
def delFuture(afuture):
"""Delete future afuture"""
try:
del futureDict[afuture.id]
except KeyError:
pass
try:
del futureDict[afuture.parentId].children[afuture]
except KeyError:
pass
|
python
|
def delFuture(afuture):
"""Delete future afuture"""
try:
del futureDict[afuture.id]
except KeyError:
pass
try:
del futureDict[afuture.parentId].children[afuture]
except KeyError:
pass
|
[
"def",
"delFuture",
"(",
"afuture",
")",
":",
"try",
":",
"del",
"futureDict",
"[",
"afuture",
".",
"id",
"]",
"except",
"KeyError",
":",
"pass",
"try",
":",
"del",
"futureDict",
"[",
"afuture",
".",
"parentId",
"]",
".",
"children",
"[",
"afuture",
"]",
"except",
"KeyError",
":",
"pass"
] |
Delete future afuture
|
[
"Delete",
"future",
"afuture"
] |
d391dfa62f47e49d48328ee9cf08aa114256fd33
|
https://github.com/soravux/scoop/blob/d391dfa62f47e49d48328ee9cf08aa114256fd33/scoop/_control.py#L122-L131
|
10,971
|
soravux/scoop
|
scoop/_control.py
|
runFuture
|
def runFuture(future):
"""Callable greenlet in charge of running tasks."""
global debug_stats
global QueueLength
if scoop.DEBUG:
init_debug() # in case _control is imported before scoop.DEBUG was set
debug_stats[future.id]['start_time'].append(time.time())
future.waitTime = future.stopWatch.get()
future.stopWatch.reset()
# Get callback Group ID and assign the broker-wide unique executor ID
try:
uniqueReference = [cb.groupID for cb in future.callback][0]
except IndexError:
uniqueReference = None
future.executor = (scoop.worker, uniqueReference)
try:
future.resultValue = future.callable(*future.args, **future.kargs)
except BaseException as err:
future.exceptionValue = err
future.exceptionTraceback = str(traceback.format_exc())
scoop.logger.debug(
"The following error occured on a worker:\n%r\n%s",
err,
traceback.format_exc(),
)
future.executionTime = future.stopWatch.get()
future.isDone = True
# Update the worker inner work statistics
if future.executionTime != 0. and hasattr(future.callable, '__name__'):
execStats[hash(future.callable)].appendleft(future.executionTime)
# Set debugging informations if needed
if scoop.DEBUG:
t = time.time()
debug_stats[future.id]['end_time'].append(t)
debug_stats[future.id].update({
'executionTime': future.executionTime,
'worker': scoop.worker,
'creationTime': future.creationTime,
'callable': str(future.callable.__name__)
if hasattr(future.callable, '__name__')
else 'No name',
'parent': future.parentId
})
QueueLength.append((t, len(execQueue), execQueue.timelen(execQueue)))
# Run callback (see http://www.python.org/dev/peps/pep-3148/#future-objects)
future._execute_callbacks(CallbackType.universal)
# Delete references to the future
future._delete()
return future
|
python
|
def runFuture(future):
"""Callable greenlet in charge of running tasks."""
global debug_stats
global QueueLength
if scoop.DEBUG:
init_debug() # in case _control is imported before scoop.DEBUG was set
debug_stats[future.id]['start_time'].append(time.time())
future.waitTime = future.stopWatch.get()
future.stopWatch.reset()
# Get callback Group ID and assign the broker-wide unique executor ID
try:
uniqueReference = [cb.groupID for cb in future.callback][0]
except IndexError:
uniqueReference = None
future.executor = (scoop.worker, uniqueReference)
try:
future.resultValue = future.callable(*future.args, **future.kargs)
except BaseException as err:
future.exceptionValue = err
future.exceptionTraceback = str(traceback.format_exc())
scoop.logger.debug(
"The following error occured on a worker:\n%r\n%s",
err,
traceback.format_exc(),
)
future.executionTime = future.stopWatch.get()
future.isDone = True
# Update the worker inner work statistics
if future.executionTime != 0. and hasattr(future.callable, '__name__'):
execStats[hash(future.callable)].appendleft(future.executionTime)
# Set debugging informations if needed
if scoop.DEBUG:
t = time.time()
debug_stats[future.id]['end_time'].append(t)
debug_stats[future.id].update({
'executionTime': future.executionTime,
'worker': scoop.worker,
'creationTime': future.creationTime,
'callable': str(future.callable.__name__)
if hasattr(future.callable, '__name__')
else 'No name',
'parent': future.parentId
})
QueueLength.append((t, len(execQueue), execQueue.timelen(execQueue)))
# Run callback (see http://www.python.org/dev/peps/pep-3148/#future-objects)
future._execute_callbacks(CallbackType.universal)
# Delete references to the future
future._delete()
return future
|
[
"def",
"runFuture",
"(",
"future",
")",
":",
"global",
"debug_stats",
"global",
"QueueLength",
"if",
"scoop",
".",
"DEBUG",
":",
"init_debug",
"(",
")",
"# in case _control is imported before scoop.DEBUG was set",
"debug_stats",
"[",
"future",
".",
"id",
"]",
"[",
"'start_time'",
"]",
".",
"append",
"(",
"time",
".",
"time",
"(",
")",
")",
"future",
".",
"waitTime",
"=",
"future",
".",
"stopWatch",
".",
"get",
"(",
")",
"future",
".",
"stopWatch",
".",
"reset",
"(",
")",
"# Get callback Group ID and assign the broker-wide unique executor ID",
"try",
":",
"uniqueReference",
"=",
"[",
"cb",
".",
"groupID",
"for",
"cb",
"in",
"future",
".",
"callback",
"]",
"[",
"0",
"]",
"except",
"IndexError",
":",
"uniqueReference",
"=",
"None",
"future",
".",
"executor",
"=",
"(",
"scoop",
".",
"worker",
",",
"uniqueReference",
")",
"try",
":",
"future",
".",
"resultValue",
"=",
"future",
".",
"callable",
"(",
"*",
"future",
".",
"args",
",",
"*",
"*",
"future",
".",
"kargs",
")",
"except",
"BaseException",
"as",
"err",
":",
"future",
".",
"exceptionValue",
"=",
"err",
"future",
".",
"exceptionTraceback",
"=",
"str",
"(",
"traceback",
".",
"format_exc",
"(",
")",
")",
"scoop",
".",
"logger",
".",
"debug",
"(",
"\"The following error occured on a worker:\\n%r\\n%s\"",
",",
"err",
",",
"traceback",
".",
"format_exc",
"(",
")",
",",
")",
"future",
".",
"executionTime",
"=",
"future",
".",
"stopWatch",
".",
"get",
"(",
")",
"future",
".",
"isDone",
"=",
"True",
"# Update the worker inner work statistics",
"if",
"future",
".",
"executionTime",
"!=",
"0.",
"and",
"hasattr",
"(",
"future",
".",
"callable",
",",
"'__name__'",
")",
":",
"execStats",
"[",
"hash",
"(",
"future",
".",
"callable",
")",
"]",
".",
"appendleft",
"(",
"future",
".",
"executionTime",
")",
"# Set debugging informations if needed",
"if",
"scoop",
".",
"DEBUG",
":",
"t",
"=",
"time",
".",
"time",
"(",
")",
"debug_stats",
"[",
"future",
".",
"id",
"]",
"[",
"'end_time'",
"]",
".",
"append",
"(",
"t",
")",
"debug_stats",
"[",
"future",
".",
"id",
"]",
".",
"update",
"(",
"{",
"'executionTime'",
":",
"future",
".",
"executionTime",
",",
"'worker'",
":",
"scoop",
".",
"worker",
",",
"'creationTime'",
":",
"future",
".",
"creationTime",
",",
"'callable'",
":",
"str",
"(",
"future",
".",
"callable",
".",
"__name__",
")",
"if",
"hasattr",
"(",
"future",
".",
"callable",
",",
"'__name__'",
")",
"else",
"'No name'",
",",
"'parent'",
":",
"future",
".",
"parentId",
"}",
")",
"QueueLength",
".",
"append",
"(",
"(",
"t",
",",
"len",
"(",
"execQueue",
")",
",",
"execQueue",
".",
"timelen",
"(",
"execQueue",
")",
")",
")",
"# Run callback (see http://www.python.org/dev/peps/pep-3148/#future-objects)",
"future",
".",
"_execute_callbacks",
"(",
"CallbackType",
".",
"universal",
")",
"# Delete references to the future",
"future",
".",
"_delete",
"(",
")",
"return",
"future"
] |
Callable greenlet in charge of running tasks.
|
[
"Callable",
"greenlet",
"in",
"charge",
"of",
"running",
"tasks",
"."
] |
d391dfa62f47e49d48328ee9cf08aa114256fd33
|
https://github.com/soravux/scoop/blob/d391dfa62f47e49d48328ee9cf08aa114256fd33/scoop/_control.py#L134-L187
|
10,972
|
soravux/scoop
|
scoop/_control.py
|
runController
|
def runController(callable_, *args, **kargs):
"""Callable greenlet implementing controller logic."""
global execQueue
# initialize and run root future
rootId = (-1, 0)
# initialise queue
if execQueue is None:
execQueue = FutureQueue()
sys.excepthook = advertiseBrokerWorkerDown
if scoop.DEBUG:
from scoop import _debug
_debug.redirectSTDOUTtoDebugFile()
# TODO: Make that a function
# Wait until we received the main module if we are a headless slave
headless = scoop.CONFIGURATION.get("headless", False)
if not scoop.MAIN_MODULE:
# If we're not the origin and still don't have our main_module,
# wait for it and then import it as module __main___
main = scoop.shared.getConst('__MAIN_MODULE__', timeout=float('inf'))
directory_name = tempfile.mkdtemp()
os.chdir(directory_name)
scoop.MAIN_MODULE = main.writeFile(directory_name)
from .bootstrap.__main__ import Bootstrap as SCOOPBootstrap
newModule = SCOOPBootstrap.setupEnvironment()
sys.modules['__main__'] = newModule
elif scoop.IS_ORIGIN and headless and scoop.MAIN_MODULE:
# We're the origin, share our main_module
scoop.shared.setConst(
__MAIN_MODULE__=scoop.encapsulation.ExternalEncapsulation(
scoop.MAIN_MODULE,
)
)
# TODO: use modulefinder to share every local dependency of
# main module
# launch future if origin or try to pickup a future if slave worker
if scoop.IS_ORIGIN:
future = Future(rootId, callable_, *args, **kargs)
else:
future = execQueue.pop()
future.greenlet = greenlet.greenlet(runFuture)
future = future._switch(future)
if scoop.DEBUG:
lastDebugTs = time.time()
while not scoop.IS_ORIGIN or future.parentId != rootId or not future._ended():
if scoop.DEBUG and time.time() - lastDebugTs > scoop.TIME_BETWEEN_PARTIALDEBUG:
_debug.writeWorkerDebug(
debug_stats,
QueueLength,
"debug/partial-{0}".format(
round(time.time(), -1)
)
)
lastDebugTs = time.time()
# process future
if future._ended():
# future is finished
if future.id[0] != scoop.worker:
# future is not local
execQueue.sendResult(future)
future = execQueue.pop()
else:
# future is local, parent is waiting
if future.index is not None:
try:
parent = futureDict[future.parentId]
except KeyError:
# Job has no parent here (probably children restart)
future = execQueue.pop()
else:
if parent.exceptionValue is None:
future = parent._switch(future)
else:
future = execQueue.pop()
else:
future = execQueue.pop()
else:
# future is in progress; run next future from pending execution queue.
future = execQueue.pop()
if not future._ended() and future.greenlet is None:
# initialize if the future hasn't started
future.greenlet = greenlet.greenlet(runFuture)
future = future._switch(future)
execQueue.shutdown()
if future.exceptionValue:
print(future.exceptionTraceback)
sys.exit(1)
return future.resultValue
|
python
|
def runController(callable_, *args, **kargs):
"""Callable greenlet implementing controller logic."""
global execQueue
# initialize and run root future
rootId = (-1, 0)
# initialise queue
if execQueue is None:
execQueue = FutureQueue()
sys.excepthook = advertiseBrokerWorkerDown
if scoop.DEBUG:
from scoop import _debug
_debug.redirectSTDOUTtoDebugFile()
# TODO: Make that a function
# Wait until we received the main module if we are a headless slave
headless = scoop.CONFIGURATION.get("headless", False)
if not scoop.MAIN_MODULE:
# If we're not the origin and still don't have our main_module,
# wait for it and then import it as module __main___
main = scoop.shared.getConst('__MAIN_MODULE__', timeout=float('inf'))
directory_name = tempfile.mkdtemp()
os.chdir(directory_name)
scoop.MAIN_MODULE = main.writeFile(directory_name)
from .bootstrap.__main__ import Bootstrap as SCOOPBootstrap
newModule = SCOOPBootstrap.setupEnvironment()
sys.modules['__main__'] = newModule
elif scoop.IS_ORIGIN and headless and scoop.MAIN_MODULE:
# We're the origin, share our main_module
scoop.shared.setConst(
__MAIN_MODULE__=scoop.encapsulation.ExternalEncapsulation(
scoop.MAIN_MODULE,
)
)
# TODO: use modulefinder to share every local dependency of
# main module
# launch future if origin or try to pickup a future if slave worker
if scoop.IS_ORIGIN:
future = Future(rootId, callable_, *args, **kargs)
else:
future = execQueue.pop()
future.greenlet = greenlet.greenlet(runFuture)
future = future._switch(future)
if scoop.DEBUG:
lastDebugTs = time.time()
while not scoop.IS_ORIGIN or future.parentId != rootId or not future._ended():
if scoop.DEBUG and time.time() - lastDebugTs > scoop.TIME_BETWEEN_PARTIALDEBUG:
_debug.writeWorkerDebug(
debug_stats,
QueueLength,
"debug/partial-{0}".format(
round(time.time(), -1)
)
)
lastDebugTs = time.time()
# process future
if future._ended():
# future is finished
if future.id[0] != scoop.worker:
# future is not local
execQueue.sendResult(future)
future = execQueue.pop()
else:
# future is local, parent is waiting
if future.index is not None:
try:
parent = futureDict[future.parentId]
except KeyError:
# Job has no parent here (probably children restart)
future = execQueue.pop()
else:
if parent.exceptionValue is None:
future = parent._switch(future)
else:
future = execQueue.pop()
else:
future = execQueue.pop()
else:
# future is in progress; run next future from pending execution queue.
future = execQueue.pop()
if not future._ended() and future.greenlet is None:
# initialize if the future hasn't started
future.greenlet = greenlet.greenlet(runFuture)
future = future._switch(future)
execQueue.shutdown()
if future.exceptionValue:
print(future.exceptionTraceback)
sys.exit(1)
return future.resultValue
|
[
"def",
"runController",
"(",
"callable_",
",",
"*",
"args",
",",
"*",
"*",
"kargs",
")",
":",
"global",
"execQueue",
"# initialize and run root future",
"rootId",
"=",
"(",
"-",
"1",
",",
"0",
")",
"# initialise queue",
"if",
"execQueue",
"is",
"None",
":",
"execQueue",
"=",
"FutureQueue",
"(",
")",
"sys",
".",
"excepthook",
"=",
"advertiseBrokerWorkerDown",
"if",
"scoop",
".",
"DEBUG",
":",
"from",
"scoop",
"import",
"_debug",
"_debug",
".",
"redirectSTDOUTtoDebugFile",
"(",
")",
"# TODO: Make that a function",
"# Wait until we received the main module if we are a headless slave",
"headless",
"=",
"scoop",
".",
"CONFIGURATION",
".",
"get",
"(",
"\"headless\"",
",",
"False",
")",
"if",
"not",
"scoop",
".",
"MAIN_MODULE",
":",
"# If we're not the origin and still don't have our main_module,",
"# wait for it and then import it as module __main___",
"main",
"=",
"scoop",
".",
"shared",
".",
"getConst",
"(",
"'__MAIN_MODULE__'",
",",
"timeout",
"=",
"float",
"(",
"'inf'",
")",
")",
"directory_name",
"=",
"tempfile",
".",
"mkdtemp",
"(",
")",
"os",
".",
"chdir",
"(",
"directory_name",
")",
"scoop",
".",
"MAIN_MODULE",
"=",
"main",
".",
"writeFile",
"(",
"directory_name",
")",
"from",
".",
"bootstrap",
".",
"__main__",
"import",
"Bootstrap",
"as",
"SCOOPBootstrap",
"newModule",
"=",
"SCOOPBootstrap",
".",
"setupEnvironment",
"(",
")",
"sys",
".",
"modules",
"[",
"'__main__'",
"]",
"=",
"newModule",
"elif",
"scoop",
".",
"IS_ORIGIN",
"and",
"headless",
"and",
"scoop",
".",
"MAIN_MODULE",
":",
"# We're the origin, share our main_module",
"scoop",
".",
"shared",
".",
"setConst",
"(",
"__MAIN_MODULE__",
"=",
"scoop",
".",
"encapsulation",
".",
"ExternalEncapsulation",
"(",
"scoop",
".",
"MAIN_MODULE",
",",
")",
")",
"# TODO: use modulefinder to share every local dependency of",
"# main module",
"# launch future if origin or try to pickup a future if slave worker",
"if",
"scoop",
".",
"IS_ORIGIN",
":",
"future",
"=",
"Future",
"(",
"rootId",
",",
"callable_",
",",
"*",
"args",
",",
"*",
"*",
"kargs",
")",
"else",
":",
"future",
"=",
"execQueue",
".",
"pop",
"(",
")",
"future",
".",
"greenlet",
"=",
"greenlet",
".",
"greenlet",
"(",
"runFuture",
")",
"future",
"=",
"future",
".",
"_switch",
"(",
"future",
")",
"if",
"scoop",
".",
"DEBUG",
":",
"lastDebugTs",
"=",
"time",
".",
"time",
"(",
")",
"while",
"not",
"scoop",
".",
"IS_ORIGIN",
"or",
"future",
".",
"parentId",
"!=",
"rootId",
"or",
"not",
"future",
".",
"_ended",
"(",
")",
":",
"if",
"scoop",
".",
"DEBUG",
"and",
"time",
".",
"time",
"(",
")",
"-",
"lastDebugTs",
">",
"scoop",
".",
"TIME_BETWEEN_PARTIALDEBUG",
":",
"_debug",
".",
"writeWorkerDebug",
"(",
"debug_stats",
",",
"QueueLength",
",",
"\"debug/partial-{0}\"",
".",
"format",
"(",
"round",
"(",
"time",
".",
"time",
"(",
")",
",",
"-",
"1",
")",
")",
")",
"lastDebugTs",
"=",
"time",
".",
"time",
"(",
")",
"# process future",
"if",
"future",
".",
"_ended",
"(",
")",
":",
"# future is finished",
"if",
"future",
".",
"id",
"[",
"0",
"]",
"!=",
"scoop",
".",
"worker",
":",
"# future is not local",
"execQueue",
".",
"sendResult",
"(",
"future",
")",
"future",
"=",
"execQueue",
".",
"pop",
"(",
")",
"else",
":",
"# future is local, parent is waiting",
"if",
"future",
".",
"index",
"is",
"not",
"None",
":",
"try",
":",
"parent",
"=",
"futureDict",
"[",
"future",
".",
"parentId",
"]",
"except",
"KeyError",
":",
"# Job has no parent here (probably children restart)",
"future",
"=",
"execQueue",
".",
"pop",
"(",
")",
"else",
":",
"if",
"parent",
".",
"exceptionValue",
"is",
"None",
":",
"future",
"=",
"parent",
".",
"_switch",
"(",
"future",
")",
"else",
":",
"future",
"=",
"execQueue",
".",
"pop",
"(",
")",
"else",
":",
"future",
"=",
"execQueue",
".",
"pop",
"(",
")",
"else",
":",
"# future is in progress; run next future from pending execution queue.",
"future",
"=",
"execQueue",
".",
"pop",
"(",
")",
"if",
"not",
"future",
".",
"_ended",
"(",
")",
"and",
"future",
".",
"greenlet",
"is",
"None",
":",
"# initialize if the future hasn't started",
"future",
".",
"greenlet",
"=",
"greenlet",
".",
"greenlet",
"(",
"runFuture",
")",
"future",
"=",
"future",
".",
"_switch",
"(",
"future",
")",
"execQueue",
".",
"shutdown",
"(",
")",
"if",
"future",
".",
"exceptionValue",
":",
"print",
"(",
"future",
".",
"exceptionTraceback",
")",
"sys",
".",
"exit",
"(",
"1",
")",
"return",
"future",
".",
"resultValue"
] |
Callable greenlet implementing controller logic.
|
[
"Callable",
"greenlet",
"implementing",
"controller",
"logic",
"."
] |
d391dfa62f47e49d48328ee9cf08aa114256fd33
|
https://github.com/soravux/scoop/blob/d391dfa62f47e49d48328ee9cf08aa114256fd33/scoop/_control.py#L190-L287
|
10,973
|
soravux/scoop
|
scoop/_control.py
|
_stat.mode
|
def mode(self):
"""Computes the mode of a log-normal distribution built with the stats data."""
mu = self.mean()
sigma = self.std()
ret_val = math.exp(mu - sigma**2)
if math.isnan(ret_val):
ret_val = float("inf")
return ret_val
|
python
|
def mode(self):
"""Computes the mode of a log-normal distribution built with the stats data."""
mu = self.mean()
sigma = self.std()
ret_val = math.exp(mu - sigma**2)
if math.isnan(ret_val):
ret_val = float("inf")
return ret_val
|
[
"def",
"mode",
"(",
"self",
")",
":",
"mu",
"=",
"self",
".",
"mean",
"(",
")",
"sigma",
"=",
"self",
".",
"std",
"(",
")",
"ret_val",
"=",
"math",
".",
"exp",
"(",
"mu",
"-",
"sigma",
"**",
"2",
")",
"if",
"math",
".",
"isnan",
"(",
"ret_val",
")",
":",
"ret_val",
"=",
"float",
"(",
"\"inf\"",
")",
"return",
"ret_val"
] |
Computes the mode of a log-normal distribution built with the stats data.
|
[
"Computes",
"the",
"mode",
"of",
"a",
"log",
"-",
"normal",
"distribution",
"built",
"with",
"the",
"stats",
"data",
"."
] |
d391dfa62f47e49d48328ee9cf08aa114256fd33
|
https://github.com/soravux/scoop/blob/d391dfa62f47e49d48328ee9cf08aa114256fd33/scoop/_control.py#L73-L80
|
10,974
|
soravux/scoop
|
scoop/_control.py
|
_stat.median
|
def median(self):
"""Computes the median of a log-normal distribution built with the stats data."""
mu = self.mean()
ret_val = math.exp(mu)
if math.isnan(ret_val):
ret_val = float("inf")
return ret_val
|
python
|
def median(self):
"""Computes the median of a log-normal distribution built with the stats data."""
mu = self.mean()
ret_val = math.exp(mu)
if math.isnan(ret_val):
ret_val = float("inf")
return ret_val
|
[
"def",
"median",
"(",
"self",
")",
":",
"mu",
"=",
"self",
".",
"mean",
"(",
")",
"ret_val",
"=",
"math",
".",
"exp",
"(",
"mu",
")",
"if",
"math",
".",
"isnan",
"(",
"ret_val",
")",
":",
"ret_val",
"=",
"float",
"(",
"\"inf\"",
")",
"return",
"ret_val"
] |
Computes the median of a log-normal distribution built with the stats data.
|
[
"Computes",
"the",
"median",
"of",
"a",
"log",
"-",
"normal",
"distribution",
"built",
"with",
"the",
"stats",
"data",
"."
] |
d391dfa62f47e49d48328ee9cf08aa114256fd33
|
https://github.com/soravux/scoop/blob/d391dfa62f47e49d48328ee9cf08aa114256fd33/scoop/_control.py#L82-L88
|
10,975
|
soravux/scoop
|
scoop/discovery/minusconf.py
|
_decode_string
|
def _decode_string(buf, pos):
""" Decodes a string in the buffer buf, starting at position pos.
Returns a tupel of the read string and the next byte to read.
"""
for i in range(pos, len(buf)):
if buf[i:i+1] == _compat_bytes('\x00'):
try:
return (buf[pos:i].decode(_CHARSET), i+1)
# Uncomment the following two lines for detailled information
#except UnicodeDecodeError as ude:
# raise MinusconfError(str(ude))
except UnicodeDecodeError:
raise MinusconfError('Not a valid ' + _CHARSET + ' string: ' + repr(buf[pos:i]))
raise MinusconfError("Premature end of string (Forgot trailing \\0?), buf=" + repr(buf))
|
python
|
def _decode_string(buf, pos):
""" Decodes a string in the buffer buf, starting at position pos.
Returns a tupel of the read string and the next byte to read.
"""
for i in range(pos, len(buf)):
if buf[i:i+1] == _compat_bytes('\x00'):
try:
return (buf[pos:i].decode(_CHARSET), i+1)
# Uncomment the following two lines for detailled information
#except UnicodeDecodeError as ude:
# raise MinusconfError(str(ude))
except UnicodeDecodeError:
raise MinusconfError('Not a valid ' + _CHARSET + ' string: ' + repr(buf[pos:i]))
raise MinusconfError("Premature end of string (Forgot trailing \\0?), buf=" + repr(buf))
|
[
"def",
"_decode_string",
"(",
"buf",
",",
"pos",
")",
":",
"for",
"i",
"in",
"range",
"(",
"pos",
",",
"len",
"(",
"buf",
")",
")",
":",
"if",
"buf",
"[",
"i",
":",
"i",
"+",
"1",
"]",
"==",
"_compat_bytes",
"(",
"'\\x00'",
")",
":",
"try",
":",
"return",
"(",
"buf",
"[",
"pos",
":",
"i",
"]",
".",
"decode",
"(",
"_CHARSET",
")",
",",
"i",
"+",
"1",
")",
"# Uncomment the following two lines for detailled information",
"#except UnicodeDecodeError as ude:",
"# raise MinusconfError(str(ude))",
"except",
"UnicodeDecodeError",
":",
"raise",
"MinusconfError",
"(",
"'Not a valid '",
"+",
"_CHARSET",
"+",
"' string: '",
"+",
"repr",
"(",
"buf",
"[",
"pos",
":",
"i",
"]",
")",
")",
"raise",
"MinusconfError",
"(",
"\"Premature end of string (Forgot trailing \\\\0?), buf=\"",
"+",
"repr",
"(",
"buf",
")",
")"
] |
Decodes a string in the buffer buf, starting at position pos.
Returns a tupel of the read string and the next byte to read.
|
[
"Decodes",
"a",
"string",
"in",
"the",
"buffer",
"buf",
"starting",
"at",
"position",
"pos",
".",
"Returns",
"a",
"tupel",
"of",
"the",
"read",
"string",
"and",
"the",
"next",
"byte",
"to",
"read",
"."
] |
d391dfa62f47e49d48328ee9cf08aa114256fd33
|
https://github.com/soravux/scoop/blob/d391dfa62f47e49d48328ee9cf08aa114256fd33/scoop/discovery/minusconf.py#L492-L506
|
10,976
|
soravux/scoop
|
scoop/discovery/minusconf.py
|
_find_sock
|
def _find_sock():
""" Create a UDP socket """
if socket.has_ipv6:
try:
return socket.socket(socket.AF_INET6, socket.SOCK_DGRAM)
except socket.gaierror:
pass # Platform lied about IPv6 support
return socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
|
python
|
def _find_sock():
""" Create a UDP socket """
if socket.has_ipv6:
try:
return socket.socket(socket.AF_INET6, socket.SOCK_DGRAM)
except socket.gaierror:
pass # Platform lied about IPv6 support
return socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
|
[
"def",
"_find_sock",
"(",
")",
":",
"if",
"socket",
".",
"has_ipv6",
":",
"try",
":",
"return",
"socket",
".",
"socket",
"(",
"socket",
".",
"AF_INET6",
",",
"socket",
".",
"SOCK_DGRAM",
")",
"except",
"socket",
".",
"gaierror",
":",
"pass",
"# Platform lied about IPv6 support",
"return",
"socket",
".",
"socket",
"(",
"socket",
".",
"AF_INET",
",",
"socket",
".",
"SOCK_DGRAM",
")"
] |
Create a UDP socket
|
[
"Create",
"a",
"UDP",
"socket"
] |
d391dfa62f47e49d48328ee9cf08aa114256fd33
|
https://github.com/soravux/scoop/blob/d391dfa62f47e49d48328ee9cf08aa114256fd33/scoop/discovery/minusconf.py#L556-L563
|
10,977
|
soravux/scoop
|
scoop/discovery/minusconf.py
|
_compat_inet_pton
|
def _compat_inet_pton(family, addr):
""" socket.inet_pton for platforms that don't have it """
if family == socket.AF_INET:
# inet_aton accepts some strange forms, so we use our own
res = _compat_bytes('')
parts = addr.split('.')
if len(parts) != 4:
raise ValueError('Expected 4 dot-separated numbers')
for part in parts:
intval = int(part, 10)
if intval < 0 or intval > 0xff:
raise ValueError("Invalid integer value in IPv4 address: " + str(intval))
res = res + struct.pack('!B', intval)
return res
elif family == socket.AF_INET6:
wordcount = 8
res = _compat_bytes('')
# IPv4 embedded?
dotpos = addr.find('.')
if dotpos >= 0:
v4start = addr.rfind(':', 0, dotpos)
if v4start == -1:
raise ValueException("Missing colons in an IPv6 address")
wordcount = 6
res = socket.inet_aton(addr[v4start+1:])
addr = addr[:v4start] + '!' # We leave a marker that the address is not finished
# Compact version?
compact_pos = addr.find('::')
if compact_pos >= 0:
if compact_pos == 0:
addr = '0' + addr
compact_pos += 1
if compact_pos == len(addr)-len('::'):
addr = addr + '0'
addr = (addr[:compact_pos] + ':' +
('0:' * (wordcount - (addr.count(':') - '::'.count(':')) - 2))
+ addr[compact_pos + len('::'):])
# Remove any dots we left
if addr.endswith('!'):
addr = addr[:-len('!')]
words = addr.split(':')
if len(words) != wordcount:
raise ValueError('Invalid number of IPv6 hextets, expected ' + str(wordcount) + ', got ' + str(len(words)))
for w in reversed(words):
# 0x and negative is not valid here, but accepted by int(,16)
if 'x' in w or '-' in w:
raise ValueError("Invalid character in IPv6 address")
intval = int(w, 16)
if intval > 0xffff:
raise ValueError("IPv6 address componenent too big")
res = struct.pack('!H', intval) + res
return res
else:
raise ValueError("Unknown protocol family " + family)
|
python
|
def _compat_inet_pton(family, addr):
""" socket.inet_pton for platforms that don't have it """
if family == socket.AF_INET:
# inet_aton accepts some strange forms, so we use our own
res = _compat_bytes('')
parts = addr.split('.')
if len(parts) != 4:
raise ValueError('Expected 4 dot-separated numbers')
for part in parts:
intval = int(part, 10)
if intval < 0 or intval > 0xff:
raise ValueError("Invalid integer value in IPv4 address: " + str(intval))
res = res + struct.pack('!B', intval)
return res
elif family == socket.AF_INET6:
wordcount = 8
res = _compat_bytes('')
# IPv4 embedded?
dotpos = addr.find('.')
if dotpos >= 0:
v4start = addr.rfind(':', 0, dotpos)
if v4start == -1:
raise ValueException("Missing colons in an IPv6 address")
wordcount = 6
res = socket.inet_aton(addr[v4start+1:])
addr = addr[:v4start] + '!' # We leave a marker that the address is not finished
# Compact version?
compact_pos = addr.find('::')
if compact_pos >= 0:
if compact_pos == 0:
addr = '0' + addr
compact_pos += 1
if compact_pos == len(addr)-len('::'):
addr = addr + '0'
addr = (addr[:compact_pos] + ':' +
('0:' * (wordcount - (addr.count(':') - '::'.count(':')) - 2))
+ addr[compact_pos + len('::'):])
# Remove any dots we left
if addr.endswith('!'):
addr = addr[:-len('!')]
words = addr.split(':')
if len(words) != wordcount:
raise ValueError('Invalid number of IPv6 hextets, expected ' + str(wordcount) + ', got ' + str(len(words)))
for w in reversed(words):
# 0x and negative is not valid here, but accepted by int(,16)
if 'x' in w or '-' in w:
raise ValueError("Invalid character in IPv6 address")
intval = int(w, 16)
if intval > 0xffff:
raise ValueError("IPv6 address componenent too big")
res = struct.pack('!H', intval) + res
return res
else:
raise ValueError("Unknown protocol family " + family)
|
[
"def",
"_compat_inet_pton",
"(",
"family",
",",
"addr",
")",
":",
"if",
"family",
"==",
"socket",
".",
"AF_INET",
":",
"# inet_aton accepts some strange forms, so we use our own",
"res",
"=",
"_compat_bytes",
"(",
"''",
")",
"parts",
"=",
"addr",
".",
"split",
"(",
"'.'",
")",
"if",
"len",
"(",
"parts",
")",
"!=",
"4",
":",
"raise",
"ValueError",
"(",
"'Expected 4 dot-separated numbers'",
")",
"for",
"part",
"in",
"parts",
":",
"intval",
"=",
"int",
"(",
"part",
",",
"10",
")",
"if",
"intval",
"<",
"0",
"or",
"intval",
">",
"0xff",
":",
"raise",
"ValueError",
"(",
"\"Invalid integer value in IPv4 address: \"",
"+",
"str",
"(",
"intval",
")",
")",
"res",
"=",
"res",
"+",
"struct",
".",
"pack",
"(",
"'!B'",
",",
"intval",
")",
"return",
"res",
"elif",
"family",
"==",
"socket",
".",
"AF_INET6",
":",
"wordcount",
"=",
"8",
"res",
"=",
"_compat_bytes",
"(",
"''",
")",
"# IPv4 embedded?",
"dotpos",
"=",
"addr",
".",
"find",
"(",
"'.'",
")",
"if",
"dotpos",
">=",
"0",
":",
"v4start",
"=",
"addr",
".",
"rfind",
"(",
"':'",
",",
"0",
",",
"dotpos",
")",
"if",
"v4start",
"==",
"-",
"1",
":",
"raise",
"ValueException",
"(",
"\"Missing colons in an IPv6 address\"",
")",
"wordcount",
"=",
"6",
"res",
"=",
"socket",
".",
"inet_aton",
"(",
"addr",
"[",
"v4start",
"+",
"1",
":",
"]",
")",
"addr",
"=",
"addr",
"[",
":",
"v4start",
"]",
"+",
"'!'",
"# We leave a marker that the address is not finished",
"# Compact version?",
"compact_pos",
"=",
"addr",
".",
"find",
"(",
"'::'",
")",
"if",
"compact_pos",
">=",
"0",
":",
"if",
"compact_pos",
"==",
"0",
":",
"addr",
"=",
"'0'",
"+",
"addr",
"compact_pos",
"+=",
"1",
"if",
"compact_pos",
"==",
"len",
"(",
"addr",
")",
"-",
"len",
"(",
"'::'",
")",
":",
"addr",
"=",
"addr",
"+",
"'0'",
"addr",
"=",
"(",
"addr",
"[",
":",
"compact_pos",
"]",
"+",
"':'",
"+",
"(",
"'0:'",
"*",
"(",
"wordcount",
"-",
"(",
"addr",
".",
"count",
"(",
"':'",
")",
"-",
"'::'",
".",
"count",
"(",
"':'",
")",
")",
"-",
"2",
")",
")",
"+",
"addr",
"[",
"compact_pos",
"+",
"len",
"(",
"'::'",
")",
":",
"]",
")",
"# Remove any dots we left",
"if",
"addr",
".",
"endswith",
"(",
"'!'",
")",
":",
"addr",
"=",
"addr",
"[",
":",
"-",
"len",
"(",
"'!'",
")",
"]",
"words",
"=",
"addr",
".",
"split",
"(",
"':'",
")",
"if",
"len",
"(",
"words",
")",
"!=",
"wordcount",
":",
"raise",
"ValueError",
"(",
"'Invalid number of IPv6 hextets, expected '",
"+",
"str",
"(",
"wordcount",
")",
"+",
"', got '",
"+",
"str",
"(",
"len",
"(",
"words",
")",
")",
")",
"for",
"w",
"in",
"reversed",
"(",
"words",
")",
":",
"# 0x and negative is not valid here, but accepted by int(,16)",
"if",
"'x'",
"in",
"w",
"or",
"'-'",
"in",
"w",
":",
"raise",
"ValueError",
"(",
"\"Invalid character in IPv6 address\"",
")",
"intval",
"=",
"int",
"(",
"w",
",",
"16",
")",
"if",
"intval",
">",
"0xffff",
":",
"raise",
"ValueError",
"(",
"\"IPv6 address componenent too big\"",
")",
"res",
"=",
"struct",
".",
"pack",
"(",
"'!H'",
",",
"intval",
")",
"+",
"res",
"return",
"res",
"else",
":",
"raise",
"ValueError",
"(",
"\"Unknown protocol family \"",
"+",
"family",
")"
] |
socket.inet_pton for platforms that don't have it
|
[
"socket",
".",
"inet_pton",
"for",
"platforms",
"that",
"don",
"t",
"have",
"it"
] |
d391dfa62f47e49d48328ee9cf08aa114256fd33
|
https://github.com/soravux/scoop/blob/d391dfa62f47e49d48328ee9cf08aa114256fd33/scoop/discovery/minusconf.py#L623-L688
|
10,978
|
soravux/scoop
|
scoop/discovery/minusconf.py
|
ConcurrentAdvertiser.start_blocking
|
def start_blocking(self):
""" Start the advertiser in the background, but wait until it is ready """
self._cav_started.clear()
self.start()
self._cav_started.wait()
|
python
|
def start_blocking(self):
""" Start the advertiser in the background, but wait until it is ready """
self._cav_started.clear()
self.start()
self._cav_started.wait()
|
[
"def",
"start_blocking",
"(",
"self",
")",
":",
"self",
".",
"_cav_started",
".",
"clear",
"(",
")",
"self",
".",
"start",
"(",
")",
"self",
".",
"_cav_started",
".",
"wait",
"(",
")"
] |
Start the advertiser in the background, but wait until it is ready
|
[
"Start",
"the",
"advertiser",
"in",
"the",
"background",
"but",
"wait",
"until",
"it",
"is",
"ready"
] |
d391dfa62f47e49d48328ee9cf08aa114256fd33
|
https://github.com/soravux/scoop/blob/d391dfa62f47e49d48328ee9cf08aa114256fd33/scoop/discovery/minusconf.py#L243-L248
|
10,979
|
soravux/scoop
|
scoop/discovery/minusconf.py
|
Seeker._send_queries
|
def _send_queries(self):
""" Sends queries to multiple addresses. Returns the number of successful queries. """
res = 0
addrs = _resolve_addrs(self.addresses, self.port, self.ignore_senderrors, [self._sock.family])
for addr in addrs:
try:
self._send_query(addr[1])
res += 1
except:
if not self.ignore_senderrors:
raise
return res
|
python
|
def _send_queries(self):
""" Sends queries to multiple addresses. Returns the number of successful queries. """
res = 0
addrs = _resolve_addrs(self.addresses, self.port, self.ignore_senderrors, [self._sock.family])
for addr in addrs:
try:
self._send_query(addr[1])
res += 1
except:
if not self.ignore_senderrors:
raise
return res
|
[
"def",
"_send_queries",
"(",
"self",
")",
":",
"res",
"=",
"0",
"addrs",
"=",
"_resolve_addrs",
"(",
"self",
".",
"addresses",
",",
"self",
".",
"port",
",",
"self",
".",
"ignore_senderrors",
",",
"[",
"self",
".",
"_sock",
".",
"family",
"]",
")",
"for",
"addr",
"in",
"addrs",
":",
"try",
":",
"self",
".",
"_send_query",
"(",
"addr",
"[",
"1",
"]",
")",
"res",
"+=",
"1",
"except",
":",
"if",
"not",
"self",
".",
"ignore_senderrors",
":",
"raise",
"return",
"res"
] |
Sends queries to multiple addresses. Returns the number of successful queries.
|
[
"Sends",
"queries",
"to",
"multiple",
"addresses",
".",
"Returns",
"the",
"number",
"of",
"successful",
"queries",
"."
] |
d391dfa62f47e49d48328ee9cf08aa114256fd33
|
https://github.com/soravux/scoop/blob/d391dfa62f47e49d48328ee9cf08aa114256fd33/scoop/discovery/minusconf.py#L383-L397
|
10,980
|
dmpayton/django-admin-honeypot
|
admin_honeypot/forms.py
|
HoneypotLoginForm.clean
|
def clean(self):
"""
Always raise the default error message, because we don't
care what they entered here.
"""
raise forms.ValidationError(
self.error_messages['invalid_login'],
code='invalid_login',
params={'username': self.username_field.verbose_name}
)
|
python
|
def clean(self):
"""
Always raise the default error message, because we don't
care what they entered here.
"""
raise forms.ValidationError(
self.error_messages['invalid_login'],
code='invalid_login',
params={'username': self.username_field.verbose_name}
)
|
[
"def",
"clean",
"(",
"self",
")",
":",
"raise",
"forms",
".",
"ValidationError",
"(",
"self",
".",
"error_messages",
"[",
"'invalid_login'",
"]",
",",
"code",
"=",
"'invalid_login'",
",",
"params",
"=",
"{",
"'username'",
":",
"self",
".",
"username_field",
".",
"verbose_name",
"}",
")"
] |
Always raise the default error message, because we don't
care what they entered here.
|
[
"Always",
"raise",
"the",
"default",
"error",
"message",
"because",
"we",
"don",
"t",
"care",
"what",
"they",
"entered",
"here",
"."
] |
1308e5f794cd3b3b3c517e0ed96070bb1d656ce3
|
https://github.com/dmpayton/django-admin-honeypot/blob/1308e5f794cd3b3b3c517e0ed96070bb1d656ce3/admin_honeypot/forms.py#L7-L16
|
10,981
|
deadpixi/contracts
|
dpcontracts.py
|
types
|
def types(**requirements):
"""
Specify a precondition based on the types of the function's
arguments.
"""
def predicate(args):
for name, kind in sorted(requirements.items()):
assert hasattr(args, name), "missing required argument `%s`" % name
if not isinstance(kind, tuple):
kind = (kind,)
if not any(isinstance(getattr(args, name), k) for k in kind):
return False
return True
return condition("the types of arguments must be valid", predicate, True)
|
python
|
def types(**requirements):
"""
Specify a precondition based on the types of the function's
arguments.
"""
def predicate(args):
for name, kind in sorted(requirements.items()):
assert hasattr(args, name), "missing required argument `%s`" % name
if not isinstance(kind, tuple):
kind = (kind,)
if not any(isinstance(getattr(args, name), k) for k in kind):
return False
return True
return condition("the types of arguments must be valid", predicate, True)
|
[
"def",
"types",
"(",
"*",
"*",
"requirements",
")",
":",
"def",
"predicate",
"(",
"args",
")",
":",
"for",
"name",
",",
"kind",
"in",
"sorted",
"(",
"requirements",
".",
"items",
"(",
")",
")",
":",
"assert",
"hasattr",
"(",
"args",
",",
"name",
")",
",",
"\"missing required argument `%s`\"",
"%",
"name",
"if",
"not",
"isinstance",
"(",
"kind",
",",
"tuple",
")",
":",
"kind",
"=",
"(",
"kind",
",",
")",
"if",
"not",
"any",
"(",
"isinstance",
"(",
"getattr",
"(",
"args",
",",
"name",
")",
",",
"k",
")",
"for",
"k",
"in",
"kind",
")",
":",
"return",
"False",
"return",
"True",
"return",
"condition",
"(",
"\"the types of arguments must be valid\"",
",",
"predicate",
",",
"True",
")"
] |
Specify a precondition based on the types of the function's
arguments.
|
[
"Specify",
"a",
"precondition",
"based",
"on",
"the",
"types",
"of",
"the",
"function",
"s",
"arguments",
"."
] |
45cb8542272c2ebe095c6efb97aa9407ddc8bf3c
|
https://github.com/deadpixi/contracts/blob/45cb8542272c2ebe095c6efb97aa9407ddc8bf3c/dpcontracts.py#L701-L719
|
10,982
|
deadpixi/contracts
|
dpcontracts.py
|
ensure
|
def ensure(arg1, arg2=None):
"""
Specify a precondition described by `description` and tested by
`predicate`.
"""
assert (isinstance(arg1, str) and isfunction(arg2)) or (isfunction(arg1) and arg2 is None)
description = ""
predicate = lambda x: x
if isinstance(arg1, str):
description = arg1
predicate = arg2
else:
description = get_function_source(arg1)
predicate = arg1
return condition(description, predicate, False, True)
|
python
|
def ensure(arg1, arg2=None):
"""
Specify a precondition described by `description` and tested by
`predicate`.
"""
assert (isinstance(arg1, str) and isfunction(arg2)) or (isfunction(arg1) and arg2 is None)
description = ""
predicate = lambda x: x
if isinstance(arg1, str):
description = arg1
predicate = arg2
else:
description = get_function_source(arg1)
predicate = arg1
return condition(description, predicate, False, True)
|
[
"def",
"ensure",
"(",
"arg1",
",",
"arg2",
"=",
"None",
")",
":",
"assert",
"(",
"isinstance",
"(",
"arg1",
",",
"str",
")",
"and",
"isfunction",
"(",
"arg2",
")",
")",
"or",
"(",
"isfunction",
"(",
"arg1",
")",
"and",
"arg2",
"is",
"None",
")",
"description",
"=",
"\"\"",
"predicate",
"=",
"lambda",
"x",
":",
"x",
"if",
"isinstance",
"(",
"arg1",
",",
"str",
")",
":",
"description",
"=",
"arg1",
"predicate",
"=",
"arg2",
"else",
":",
"description",
"=",
"get_function_source",
"(",
"arg1",
")",
"predicate",
"=",
"arg1",
"return",
"condition",
"(",
"description",
",",
"predicate",
",",
"False",
",",
"True",
")"
] |
Specify a precondition described by `description` and tested by
`predicate`.
|
[
"Specify",
"a",
"precondition",
"described",
"by",
"description",
"and",
"tested",
"by",
"predicate",
"."
] |
45cb8542272c2ebe095c6efb97aa9407ddc8bf3c
|
https://github.com/deadpixi/contracts/blob/45cb8542272c2ebe095c6efb97aa9407ddc8bf3c/dpcontracts.py#L721-L739
|
10,983
|
deadpixi/contracts
|
dpcontracts.py
|
invariant
|
def invariant(arg1, arg2=None):
"""
Specify a class invariant described by `description` and tested
by `predicate`.
"""
desc = ""
predicate = lambda x: x
if isinstance(arg1, str):
desc = arg1
predicate = arg2
else:
desc = get_function_source(arg1)
predicate = arg1
def invariant(c):
def check(name, func):
exceptions = ("__getitem__", "__setitem__", "__lt__", "__le__", "__eq__",
"__ne__", "__gt__", "__ge__", "__init__")
if name.startswith("__") and name.endswith("__") and name not in exceptions:
return False
if not ismethod(func) and not isfunction(func):
return False
if getattr(func, "__self__", None) is c:
return False
return True
class InvariantContractor(c):
pass
for name, value in [(name, getattr(c, name)) for name in dir(c)]:
if check(name, value):
setattr(InvariantContractor, name,
condition(desc, predicate, name != "__init__", True, True)(value))
return InvariantContractor
return invariant
|
python
|
def invariant(arg1, arg2=None):
"""
Specify a class invariant described by `description` and tested
by `predicate`.
"""
desc = ""
predicate = lambda x: x
if isinstance(arg1, str):
desc = arg1
predicate = arg2
else:
desc = get_function_source(arg1)
predicate = arg1
def invariant(c):
def check(name, func):
exceptions = ("__getitem__", "__setitem__", "__lt__", "__le__", "__eq__",
"__ne__", "__gt__", "__ge__", "__init__")
if name.startswith("__") and name.endswith("__") and name not in exceptions:
return False
if not ismethod(func) and not isfunction(func):
return False
if getattr(func, "__self__", None) is c:
return False
return True
class InvariantContractor(c):
pass
for name, value in [(name, getattr(c, name)) for name in dir(c)]:
if check(name, value):
setattr(InvariantContractor, name,
condition(desc, predicate, name != "__init__", True, True)(value))
return InvariantContractor
return invariant
|
[
"def",
"invariant",
"(",
"arg1",
",",
"arg2",
"=",
"None",
")",
":",
"desc",
"=",
"\"\"",
"predicate",
"=",
"lambda",
"x",
":",
"x",
"if",
"isinstance",
"(",
"arg1",
",",
"str",
")",
":",
"desc",
"=",
"arg1",
"predicate",
"=",
"arg2",
"else",
":",
"desc",
"=",
"get_function_source",
"(",
"arg1",
")",
"predicate",
"=",
"arg1",
"def",
"invariant",
"(",
"c",
")",
":",
"def",
"check",
"(",
"name",
",",
"func",
")",
":",
"exceptions",
"=",
"(",
"\"__getitem__\"",
",",
"\"__setitem__\"",
",",
"\"__lt__\"",
",",
"\"__le__\"",
",",
"\"__eq__\"",
",",
"\"__ne__\"",
",",
"\"__gt__\"",
",",
"\"__ge__\"",
",",
"\"__init__\"",
")",
"if",
"name",
".",
"startswith",
"(",
"\"__\"",
")",
"and",
"name",
".",
"endswith",
"(",
"\"__\"",
")",
"and",
"name",
"not",
"in",
"exceptions",
":",
"return",
"False",
"if",
"not",
"ismethod",
"(",
"func",
")",
"and",
"not",
"isfunction",
"(",
"func",
")",
":",
"return",
"False",
"if",
"getattr",
"(",
"func",
",",
"\"__self__\"",
",",
"None",
")",
"is",
"c",
":",
"return",
"False",
"return",
"True",
"class",
"InvariantContractor",
"(",
"c",
")",
":",
"pass",
"for",
"name",
",",
"value",
"in",
"[",
"(",
"name",
",",
"getattr",
"(",
"c",
",",
"name",
")",
")",
"for",
"name",
"in",
"dir",
"(",
"c",
")",
"]",
":",
"if",
"check",
"(",
"name",
",",
"value",
")",
":",
"setattr",
"(",
"InvariantContractor",
",",
"name",
",",
"condition",
"(",
"desc",
",",
"predicate",
",",
"name",
"!=",
"\"__init__\"",
",",
"True",
",",
"True",
")",
"(",
"value",
")",
")",
"return",
"InvariantContractor",
"return",
"invariant"
] |
Specify a class invariant described by `description` and tested
by `predicate`.
|
[
"Specify",
"a",
"class",
"invariant",
"described",
"by",
"description",
"and",
"tested",
"by",
"predicate",
"."
] |
45cb8542272c2ebe095c6efb97aa9407ddc8bf3c
|
https://github.com/deadpixi/contracts/blob/45cb8542272c2ebe095c6efb97aa9407ddc8bf3c/dpcontracts.py#L741-L781
|
10,984
|
Gandi/gandi.cli
|
gandi/cli/core/utils/password.py
|
mkpassword
|
def mkpassword(length=16, chars=None, punctuation=None):
"""Generates a random ascii string - useful to generate authinfos
:param length: string wanted length
:type length: ``int``
:param chars: character population,
defaults to alphabet (lower & upper) + numbers
:type chars: ``str``, ``list``, ``set`` (sequence)
:param punctuation: number of punctuation signs to include in string
:type punctuation: ``int``
:rtype: ``str``
"""
if chars is None:
chars = string.ascii_letters + string.digits
# Generate string from population
data = [random.choice(chars) for _ in range(length)]
# If punctuation:
# - remove n chars from string
# - add random punctuation
# - shuffle chars :)
if punctuation:
data = data[:-punctuation]
for _ in range(punctuation):
data.append(random.choice(PUNCTUATION))
random.shuffle(data)
return ''.join(data)
|
python
|
def mkpassword(length=16, chars=None, punctuation=None):
"""Generates a random ascii string - useful to generate authinfos
:param length: string wanted length
:type length: ``int``
:param chars: character population,
defaults to alphabet (lower & upper) + numbers
:type chars: ``str``, ``list``, ``set`` (sequence)
:param punctuation: number of punctuation signs to include in string
:type punctuation: ``int``
:rtype: ``str``
"""
if chars is None:
chars = string.ascii_letters + string.digits
# Generate string from population
data = [random.choice(chars) for _ in range(length)]
# If punctuation:
# - remove n chars from string
# - add random punctuation
# - shuffle chars :)
if punctuation:
data = data[:-punctuation]
for _ in range(punctuation):
data.append(random.choice(PUNCTUATION))
random.shuffle(data)
return ''.join(data)
|
[
"def",
"mkpassword",
"(",
"length",
"=",
"16",
",",
"chars",
"=",
"None",
",",
"punctuation",
"=",
"None",
")",
":",
"if",
"chars",
"is",
"None",
":",
"chars",
"=",
"string",
".",
"ascii_letters",
"+",
"string",
".",
"digits",
"# Generate string from population",
"data",
"=",
"[",
"random",
".",
"choice",
"(",
"chars",
")",
"for",
"_",
"in",
"range",
"(",
"length",
")",
"]",
"# If punctuation:",
"# - remove n chars from string",
"# - add random punctuation",
"# - shuffle chars :)",
"if",
"punctuation",
":",
"data",
"=",
"data",
"[",
":",
"-",
"punctuation",
"]",
"for",
"_",
"in",
"range",
"(",
"punctuation",
")",
":",
"data",
".",
"append",
"(",
"random",
".",
"choice",
"(",
"PUNCTUATION",
")",
")",
"random",
".",
"shuffle",
"(",
"data",
")",
"return",
"''",
".",
"join",
"(",
"data",
")"
] |
Generates a random ascii string - useful to generate authinfos
:param length: string wanted length
:type length: ``int``
:param chars: character population,
defaults to alphabet (lower & upper) + numbers
:type chars: ``str``, ``list``, ``set`` (sequence)
:param punctuation: number of punctuation signs to include in string
:type punctuation: ``int``
:rtype: ``str``
|
[
"Generates",
"a",
"random",
"ascii",
"string",
"-",
"useful",
"to",
"generate",
"authinfos"
] |
6ee5b8fc8ec44b0a6c232043ca610606ad8f693d
|
https://github.com/Gandi/gandi.cli/blob/6ee5b8fc8ec44b0a6c232043ca610606ad8f693d/gandi/cli/core/utils/password.py#L12-L44
|
10,985
|
Gandi/gandi.cli
|
gandi/cli/core/utils/size.py
|
disk_check_size
|
def disk_check_size(ctx, param, value):
""" Validation callback for disk size parameter."""
if value:
# if we've got a prefix
if isinstance(value, tuple):
val = value[1]
else:
val = value
if val % 1024:
raise click.ClickException('Size must be a multiple of 1024.')
return value
|
python
|
def disk_check_size(ctx, param, value):
""" Validation callback for disk size parameter."""
if value:
# if we've got a prefix
if isinstance(value, tuple):
val = value[1]
else:
val = value
if val % 1024:
raise click.ClickException('Size must be a multiple of 1024.')
return value
|
[
"def",
"disk_check_size",
"(",
"ctx",
",",
"param",
",",
"value",
")",
":",
"if",
"value",
":",
"# if we've got a prefix",
"if",
"isinstance",
"(",
"value",
",",
"tuple",
")",
":",
"val",
"=",
"value",
"[",
"1",
"]",
"else",
":",
"val",
"=",
"value",
"if",
"val",
"%",
"1024",
":",
"raise",
"click",
".",
"ClickException",
"(",
"'Size must be a multiple of 1024.'",
")",
"return",
"value"
] |
Validation callback for disk size parameter.
|
[
"Validation",
"callback",
"for",
"disk",
"size",
"parameter",
"."
] |
6ee5b8fc8ec44b0a6c232043ca610606ad8f693d
|
https://github.com/Gandi/gandi.cli/blob/6ee5b8fc8ec44b0a6c232043ca610606ad8f693d/gandi/cli/core/utils/size.py#L8-L18
|
10,986
|
Gandi/gandi.cli
|
gandi/cli/modules/dnssec.py
|
DNSSEC.create
|
def create(cls, fqdn, flags, algorithm, public_key):
"""Create a dnssec key."""
fqdn = fqdn.lower()
params = {
'flags': flags,
'algorithm': algorithm,
'public_key': public_key,
}
result = cls.call('domain.dnssec.create', fqdn, params)
return result
|
python
|
def create(cls, fqdn, flags, algorithm, public_key):
"""Create a dnssec key."""
fqdn = fqdn.lower()
params = {
'flags': flags,
'algorithm': algorithm,
'public_key': public_key,
}
result = cls.call('domain.dnssec.create', fqdn, params)
return result
|
[
"def",
"create",
"(",
"cls",
",",
"fqdn",
",",
"flags",
",",
"algorithm",
",",
"public_key",
")",
":",
"fqdn",
"=",
"fqdn",
".",
"lower",
"(",
")",
"params",
"=",
"{",
"'flags'",
":",
"flags",
",",
"'algorithm'",
":",
"algorithm",
",",
"'public_key'",
":",
"public_key",
",",
"}",
"result",
"=",
"cls",
".",
"call",
"(",
"'domain.dnssec.create'",
",",
"fqdn",
",",
"params",
")",
"return",
"result"
] |
Create a dnssec key.
|
[
"Create",
"a",
"dnssec",
"key",
"."
] |
6ee5b8fc8ec44b0a6c232043ca610606ad8f693d
|
https://github.com/Gandi/gandi.cli/blob/6ee5b8fc8ec44b0a6c232043ca610606ad8f693d/gandi/cli/modules/dnssec.py#L22-L34
|
10,987
|
Gandi/gandi.cli
|
gandi/cli/modules/snapshotprofile.py
|
SnapshotProfile.from_name
|
def from_name(cls, name):
""" Retrieve a snapshot profile accsociated to a name."""
snps = cls.list({'name': name})
if len(snps) == 1:
return snps[0]['id']
elif not snps:
return
raise DuplicateResults('snapshot profile name %s is ambiguous.' % name)
|
python
|
def from_name(cls, name):
""" Retrieve a snapshot profile accsociated to a name."""
snps = cls.list({'name': name})
if len(snps) == 1:
return snps[0]['id']
elif not snps:
return
raise DuplicateResults('snapshot profile name %s is ambiguous.' % name)
|
[
"def",
"from_name",
"(",
"cls",
",",
"name",
")",
":",
"snps",
"=",
"cls",
".",
"list",
"(",
"{",
"'name'",
":",
"name",
"}",
")",
"if",
"len",
"(",
"snps",
")",
"==",
"1",
":",
"return",
"snps",
"[",
"0",
"]",
"[",
"'id'",
"]",
"elif",
"not",
"snps",
":",
"return",
"raise",
"DuplicateResults",
"(",
"'snapshot profile name %s is ambiguous.'",
"%",
"name",
")"
] |
Retrieve a snapshot profile accsociated to a name.
|
[
"Retrieve",
"a",
"snapshot",
"profile",
"accsociated",
"to",
"a",
"name",
"."
] |
6ee5b8fc8ec44b0a6c232043ca610606ad8f693d
|
https://github.com/Gandi/gandi.cli/blob/6ee5b8fc8ec44b0a6c232043ca610606ad8f693d/gandi/cli/modules/snapshotprofile.py#L17-L25
|
10,988
|
Gandi/gandi.cli
|
gandi/cli/modules/snapshotprofile.py
|
SnapshotProfile.list
|
def list(cls, options=None, target=None):
""" List all snapshot profiles."""
options = options or {}
result = []
if not target or target == 'paas':
for profile in cls.safe_call('paas.snapshotprofile.list', options):
profile['target'] = 'paas'
result.append((profile['id'], profile))
if not target or target == 'vm':
for profile in cls.safe_call('hosting.snapshotprofile.list',
options):
profile['target'] = 'vm'
result.append((profile['id'], profile))
result = sorted(result, key=lambda item: item[0])
return [profile for id_, profile in result]
|
python
|
def list(cls, options=None, target=None):
""" List all snapshot profiles."""
options = options or {}
result = []
if not target or target == 'paas':
for profile in cls.safe_call('paas.snapshotprofile.list', options):
profile['target'] = 'paas'
result.append((profile['id'], profile))
if not target or target == 'vm':
for profile in cls.safe_call('hosting.snapshotprofile.list',
options):
profile['target'] = 'vm'
result.append((profile['id'], profile))
result = sorted(result, key=lambda item: item[0])
return [profile for id_, profile in result]
|
[
"def",
"list",
"(",
"cls",
",",
"options",
"=",
"None",
",",
"target",
"=",
"None",
")",
":",
"options",
"=",
"options",
"or",
"{",
"}",
"result",
"=",
"[",
"]",
"if",
"not",
"target",
"or",
"target",
"==",
"'paas'",
":",
"for",
"profile",
"in",
"cls",
".",
"safe_call",
"(",
"'paas.snapshotprofile.list'",
",",
"options",
")",
":",
"profile",
"[",
"'target'",
"]",
"=",
"'paas'",
"result",
".",
"append",
"(",
"(",
"profile",
"[",
"'id'",
"]",
",",
"profile",
")",
")",
"if",
"not",
"target",
"or",
"target",
"==",
"'vm'",
":",
"for",
"profile",
"in",
"cls",
".",
"safe_call",
"(",
"'hosting.snapshotprofile.list'",
",",
"options",
")",
":",
"profile",
"[",
"'target'",
"]",
"=",
"'vm'",
"result",
".",
"append",
"(",
"(",
"profile",
"[",
"'id'",
"]",
",",
"profile",
")",
")",
"result",
"=",
"sorted",
"(",
"result",
",",
"key",
"=",
"lambda",
"item",
":",
"item",
"[",
"0",
"]",
")",
"return",
"[",
"profile",
"for",
"id_",
",",
"profile",
"in",
"result",
"]"
] |
List all snapshot profiles.
|
[
"List",
"all",
"snapshot",
"profiles",
"."
] |
6ee5b8fc8ec44b0a6c232043ca610606ad8f693d
|
https://github.com/Gandi/gandi.cli/blob/6ee5b8fc8ec44b0a6c232043ca610606ad8f693d/gandi/cli/modules/snapshotprofile.py#L46-L63
|
10,989
|
Gandi/gandi.cli
|
gandi/cli/modules/dns.py
|
Dns.records
|
def records(cls, fqdn, sort_by=None, text=False):
"""Display records information about a domain."""
meta = cls.get_fqdn_info(fqdn)
url = meta['domain_records_href']
kwargs = {}
if text:
kwargs = {'headers': {'Accept': 'text/plain'}}
return cls.json_get(cls.get_sort_url(url, sort_by), **kwargs)
|
python
|
def records(cls, fqdn, sort_by=None, text=False):
"""Display records information about a domain."""
meta = cls.get_fqdn_info(fqdn)
url = meta['domain_records_href']
kwargs = {}
if text:
kwargs = {'headers': {'Accept': 'text/plain'}}
return cls.json_get(cls.get_sort_url(url, sort_by), **kwargs)
|
[
"def",
"records",
"(",
"cls",
",",
"fqdn",
",",
"sort_by",
"=",
"None",
",",
"text",
"=",
"False",
")",
":",
"meta",
"=",
"cls",
".",
"get_fqdn_info",
"(",
"fqdn",
")",
"url",
"=",
"meta",
"[",
"'domain_records_href'",
"]",
"kwargs",
"=",
"{",
"}",
"if",
"text",
":",
"kwargs",
"=",
"{",
"'headers'",
":",
"{",
"'Accept'",
":",
"'text/plain'",
"}",
"}",
"return",
"cls",
".",
"json_get",
"(",
"cls",
".",
"get_sort_url",
"(",
"url",
",",
"sort_by",
")",
",",
"*",
"*",
"kwargs",
")"
] |
Display records information about a domain.
|
[
"Display",
"records",
"information",
"about",
"a",
"domain",
"."
] |
6ee5b8fc8ec44b0a6c232043ca610606ad8f693d
|
https://github.com/Gandi/gandi.cli/blob/6ee5b8fc8ec44b0a6c232043ca610606ad8f693d/gandi/cli/modules/dns.py#L51-L58
|
10,990
|
Gandi/gandi.cli
|
gandi/cli/modules/dns.py
|
Dns.add_record
|
def add_record(cls, fqdn, name, type, value, ttl):
"""Create record for a domain."""
data = {
"rrset_name": name,
"rrset_type": type,
"rrset_values": value,
}
if ttl:
data['rrset_ttl'] = int(ttl)
meta = cls.get_fqdn_info(fqdn)
url = meta['domain_records_href']
return cls.json_post(url, data=json.dumps(data))
|
python
|
def add_record(cls, fqdn, name, type, value, ttl):
"""Create record for a domain."""
data = {
"rrset_name": name,
"rrset_type": type,
"rrset_values": value,
}
if ttl:
data['rrset_ttl'] = int(ttl)
meta = cls.get_fqdn_info(fqdn)
url = meta['domain_records_href']
return cls.json_post(url, data=json.dumps(data))
|
[
"def",
"add_record",
"(",
"cls",
",",
"fqdn",
",",
"name",
",",
"type",
",",
"value",
",",
"ttl",
")",
":",
"data",
"=",
"{",
"\"rrset_name\"",
":",
"name",
",",
"\"rrset_type\"",
":",
"type",
",",
"\"rrset_values\"",
":",
"value",
",",
"}",
"if",
"ttl",
":",
"data",
"[",
"'rrset_ttl'",
"]",
"=",
"int",
"(",
"ttl",
")",
"meta",
"=",
"cls",
".",
"get_fqdn_info",
"(",
"fqdn",
")",
"url",
"=",
"meta",
"[",
"'domain_records_href'",
"]",
"return",
"cls",
".",
"json_post",
"(",
"url",
",",
"data",
"=",
"json",
".",
"dumps",
"(",
"data",
")",
")"
] |
Create record for a domain.
|
[
"Create",
"record",
"for",
"a",
"domain",
"."
] |
6ee5b8fc8ec44b0a6c232043ca610606ad8f693d
|
https://github.com/Gandi/gandi.cli/blob/6ee5b8fc8ec44b0a6c232043ca610606ad8f693d/gandi/cli/modules/dns.py#L61-L72
|
10,991
|
Gandi/gandi.cli
|
gandi/cli/modules/dns.py
|
Dns.update_record
|
def update_record(cls, fqdn, name, type, value, ttl, content):
"""Update all records for a domain."""
data = {
"rrset_name": name,
"rrset_type": type,
"rrset_values": value,
}
if ttl:
data['rrset_ttl'] = int(ttl)
meta = cls.get_fqdn_info(fqdn)
if content:
url = meta['domain_records_href']
kwargs = {'headers': {'Content-Type': 'text/plain'},
'data': content}
return cls.json_put(url, **kwargs)
url = '%s/domains/%s/records/%s/%s' % (cls.api_url, fqdn, name, type)
return cls.json_put(url, data=json.dumps(data))
|
python
|
def update_record(cls, fqdn, name, type, value, ttl, content):
"""Update all records for a domain."""
data = {
"rrset_name": name,
"rrset_type": type,
"rrset_values": value,
}
if ttl:
data['rrset_ttl'] = int(ttl)
meta = cls.get_fqdn_info(fqdn)
if content:
url = meta['domain_records_href']
kwargs = {'headers': {'Content-Type': 'text/plain'},
'data': content}
return cls.json_put(url, **kwargs)
url = '%s/domains/%s/records/%s/%s' % (cls.api_url, fqdn, name, type)
return cls.json_put(url, data=json.dumps(data))
|
[
"def",
"update_record",
"(",
"cls",
",",
"fqdn",
",",
"name",
",",
"type",
",",
"value",
",",
"ttl",
",",
"content",
")",
":",
"data",
"=",
"{",
"\"rrset_name\"",
":",
"name",
",",
"\"rrset_type\"",
":",
"type",
",",
"\"rrset_values\"",
":",
"value",
",",
"}",
"if",
"ttl",
":",
"data",
"[",
"'rrset_ttl'",
"]",
"=",
"int",
"(",
"ttl",
")",
"meta",
"=",
"cls",
".",
"get_fqdn_info",
"(",
"fqdn",
")",
"if",
"content",
":",
"url",
"=",
"meta",
"[",
"'domain_records_href'",
"]",
"kwargs",
"=",
"{",
"'headers'",
":",
"{",
"'Content-Type'",
":",
"'text/plain'",
"}",
",",
"'data'",
":",
"content",
"}",
"return",
"cls",
".",
"json_put",
"(",
"url",
",",
"*",
"*",
"kwargs",
")",
"url",
"=",
"'%s/domains/%s/records/%s/%s'",
"%",
"(",
"cls",
".",
"api_url",
",",
"fqdn",
",",
"name",
",",
"type",
")",
"return",
"cls",
".",
"json_put",
"(",
"url",
",",
"data",
"=",
"json",
".",
"dumps",
"(",
"data",
")",
")"
] |
Update all records for a domain.
|
[
"Update",
"all",
"records",
"for",
"a",
"domain",
"."
] |
6ee5b8fc8ec44b0a6c232043ca610606ad8f693d
|
https://github.com/Gandi/gandi.cli/blob/6ee5b8fc8ec44b0a6c232043ca610606ad8f693d/gandi/cli/modules/dns.py#L75-L92
|
10,992
|
Gandi/gandi.cli
|
gandi/cli/modules/dns.py
|
Dns.del_record
|
def del_record(cls, fqdn, name, type):
"""Delete record for a domain."""
meta = cls.get_fqdn_info(fqdn)
url = meta['domain_records_href']
delete_url = url
if name:
delete_url = '%s/%s' % (delete_url, name)
if type:
delete_url = '%s/%s' % (delete_url, type)
return cls.json_delete(delete_url)
|
python
|
def del_record(cls, fqdn, name, type):
"""Delete record for a domain."""
meta = cls.get_fqdn_info(fqdn)
url = meta['domain_records_href']
delete_url = url
if name:
delete_url = '%s/%s' % (delete_url, name)
if type:
delete_url = '%s/%s' % (delete_url, type)
return cls.json_delete(delete_url)
|
[
"def",
"del_record",
"(",
"cls",
",",
"fqdn",
",",
"name",
",",
"type",
")",
":",
"meta",
"=",
"cls",
".",
"get_fqdn_info",
"(",
"fqdn",
")",
"url",
"=",
"meta",
"[",
"'domain_records_href'",
"]",
"delete_url",
"=",
"url",
"if",
"name",
":",
"delete_url",
"=",
"'%s/%s'",
"%",
"(",
"delete_url",
",",
"name",
")",
"if",
"type",
":",
"delete_url",
"=",
"'%s/%s'",
"%",
"(",
"delete_url",
",",
"type",
")",
"return",
"cls",
".",
"json_delete",
"(",
"delete_url",
")"
] |
Delete record for a domain.
|
[
"Delete",
"record",
"for",
"a",
"domain",
"."
] |
6ee5b8fc8ec44b0a6c232043ca610606ad8f693d
|
https://github.com/Gandi/gandi.cli/blob/6ee5b8fc8ec44b0a6c232043ca610606ad8f693d/gandi/cli/modules/dns.py#L95-L104
|
10,993
|
Gandi/gandi.cli
|
gandi/cli/modules/dns.py
|
Dns.keys
|
def keys(cls, fqdn, sort_by=None):
"""Display keys information about a domain."""
meta = cls.get_fqdn_info(fqdn)
url = meta['domain_keys_href']
return cls.json_get(cls.get_sort_url(url, sort_by))
|
python
|
def keys(cls, fqdn, sort_by=None):
"""Display keys information about a domain."""
meta = cls.get_fqdn_info(fqdn)
url = meta['domain_keys_href']
return cls.json_get(cls.get_sort_url(url, sort_by))
|
[
"def",
"keys",
"(",
"cls",
",",
"fqdn",
",",
"sort_by",
"=",
"None",
")",
":",
"meta",
"=",
"cls",
".",
"get_fqdn_info",
"(",
"fqdn",
")",
"url",
"=",
"meta",
"[",
"'domain_keys_href'",
"]",
"return",
"cls",
".",
"json_get",
"(",
"cls",
".",
"get_sort_url",
"(",
"url",
",",
"sort_by",
")",
")"
] |
Display keys information about a domain.
|
[
"Display",
"keys",
"information",
"about",
"a",
"domain",
"."
] |
6ee5b8fc8ec44b0a6c232043ca610606ad8f693d
|
https://github.com/Gandi/gandi.cli/blob/6ee5b8fc8ec44b0a6c232043ca610606ad8f693d/gandi/cli/modules/dns.py#L107-L111
|
10,994
|
Gandi/gandi.cli
|
gandi/cli/modules/dns.py
|
Dns.keys_info
|
def keys_info(cls, fqdn, key):
"""Retrieve key information."""
return cls.json_get('%s/domains/%s/keys/%s' %
(cls.api_url, fqdn, key))
|
python
|
def keys_info(cls, fqdn, key):
"""Retrieve key information."""
return cls.json_get('%s/domains/%s/keys/%s' %
(cls.api_url, fqdn, key))
|
[
"def",
"keys_info",
"(",
"cls",
",",
"fqdn",
",",
"key",
")",
":",
"return",
"cls",
".",
"json_get",
"(",
"'%s/domains/%s/keys/%s'",
"%",
"(",
"cls",
".",
"api_url",
",",
"fqdn",
",",
"key",
")",
")"
] |
Retrieve key information.
|
[
"Retrieve",
"key",
"information",
"."
] |
6ee5b8fc8ec44b0a6c232043ca610606ad8f693d
|
https://github.com/Gandi/gandi.cli/blob/6ee5b8fc8ec44b0a6c232043ca610606ad8f693d/gandi/cli/modules/dns.py#L114-L117
|
10,995
|
Gandi/gandi.cli
|
gandi/cli/modules/dns.py
|
Dns.keys_create
|
def keys_create(cls, fqdn, flag):
"""Create new key entry for a domain."""
data = {
"flags": flag,
}
meta = cls.get_fqdn_info(fqdn)
url = meta['domain_keys_href']
ret, headers = cls.json_post(url, data=json.dumps(data),
return_header=True)
return cls.json_get(headers['location'])
|
python
|
def keys_create(cls, fqdn, flag):
"""Create new key entry for a domain."""
data = {
"flags": flag,
}
meta = cls.get_fqdn_info(fqdn)
url = meta['domain_keys_href']
ret, headers = cls.json_post(url, data=json.dumps(data),
return_header=True)
return cls.json_get(headers['location'])
|
[
"def",
"keys_create",
"(",
"cls",
",",
"fqdn",
",",
"flag",
")",
":",
"data",
"=",
"{",
"\"flags\"",
":",
"flag",
",",
"}",
"meta",
"=",
"cls",
".",
"get_fqdn_info",
"(",
"fqdn",
")",
"url",
"=",
"meta",
"[",
"'domain_keys_href'",
"]",
"ret",
",",
"headers",
"=",
"cls",
".",
"json_post",
"(",
"url",
",",
"data",
"=",
"json",
".",
"dumps",
"(",
"data",
")",
",",
"return_header",
"=",
"True",
")",
"return",
"cls",
".",
"json_get",
"(",
"headers",
"[",
"'location'",
"]",
")"
] |
Create new key entry for a domain.
|
[
"Create",
"new",
"key",
"entry",
"for",
"a",
"domain",
"."
] |
6ee5b8fc8ec44b0a6c232043ca610606ad8f693d
|
https://github.com/Gandi/gandi.cli/blob/6ee5b8fc8ec44b0a6c232043ca610606ad8f693d/gandi/cli/modules/dns.py#L120-L129
|
10,996
|
Gandi/gandi.cli
|
gandi/cli/commands/vlan.py
|
list
|
def list(gandi, datacenter, id, subnet, gateway):
"""List vlans."""
output_keys = ['name', 'state', 'dc']
if id:
output_keys.append('id')
if subnet:
output_keys.append('subnet')
if gateway:
output_keys.append('gateway')
datacenters = gandi.datacenter.list()
vlans = gandi.vlan.list(datacenter)
for num, vlan in enumerate(vlans):
if num:
gandi.separator_line()
output_vlan(gandi, vlan, datacenters, output_keys)
return vlans
|
python
|
def list(gandi, datacenter, id, subnet, gateway):
"""List vlans."""
output_keys = ['name', 'state', 'dc']
if id:
output_keys.append('id')
if subnet:
output_keys.append('subnet')
if gateway:
output_keys.append('gateway')
datacenters = gandi.datacenter.list()
vlans = gandi.vlan.list(datacenter)
for num, vlan in enumerate(vlans):
if num:
gandi.separator_line()
output_vlan(gandi, vlan, datacenters, output_keys)
return vlans
|
[
"def",
"list",
"(",
"gandi",
",",
"datacenter",
",",
"id",
",",
"subnet",
",",
"gateway",
")",
":",
"output_keys",
"=",
"[",
"'name'",
",",
"'state'",
",",
"'dc'",
"]",
"if",
"id",
":",
"output_keys",
".",
"append",
"(",
"'id'",
")",
"if",
"subnet",
":",
"output_keys",
".",
"append",
"(",
"'subnet'",
")",
"if",
"gateway",
":",
"output_keys",
".",
"append",
"(",
"'gateway'",
")",
"datacenters",
"=",
"gandi",
".",
"datacenter",
".",
"list",
"(",
")",
"vlans",
"=",
"gandi",
".",
"vlan",
".",
"list",
"(",
"datacenter",
")",
"for",
"num",
",",
"vlan",
"in",
"enumerate",
"(",
"vlans",
")",
":",
"if",
"num",
":",
"gandi",
".",
"separator_line",
"(",
")",
"output_vlan",
"(",
"gandi",
",",
"vlan",
",",
"datacenters",
",",
"output_keys",
")",
"return",
"vlans"
] |
List vlans.
|
[
"List",
"vlans",
"."
] |
6ee5b8fc8ec44b0a6c232043ca610606ad8f693d
|
https://github.com/Gandi/gandi.cli/blob/6ee5b8fc8ec44b0a6c232043ca610606ad8f693d/gandi/cli/commands/vlan.py#L27-L45
|
10,997
|
Gandi/gandi.cli
|
gandi/cli/commands/vlan.py
|
info
|
def info(gandi, resource, ip):
"""Display information about a vlan."""
output_keys = ['name', 'state', 'dc', 'subnet', 'gateway']
datacenters = gandi.datacenter.list()
vlan = gandi.vlan.info(resource)
gateway = vlan['gateway']
if not ip:
output_vlan(gandi, vlan, datacenters, output_keys, justify=11)
return vlan
gateway_exists = False
vms = dict([(vm_['id'], vm_) for vm_ in gandi.iaas.list()])
ifaces = gandi.vlan.ifaces(resource)
for iface in ifaces:
for ip in iface['ips']:
if gateway == ip['ip']:
gateway_exists = True
if gateway_exists:
vlan.pop('gateway')
else:
vlan['gateway'] = ("%s don't exists" % gateway if gateway
else 'none')
output_vlan(gandi, vlan, datacenters, output_keys, justify=11)
output_keys = ['vm', 'bandwidth']
for iface in ifaces:
gandi.separator_line()
output_iface(gandi, iface, datacenters, vms, output_keys,
justify=11)
for ip in iface['ips']:
output_ip(gandi, ip, None, None, None, ['ip'])
if gateway == ip['ip']:
output_line(gandi, 'gateway', 'true', justify=11)
return vlan
|
python
|
def info(gandi, resource, ip):
"""Display information about a vlan."""
output_keys = ['name', 'state', 'dc', 'subnet', 'gateway']
datacenters = gandi.datacenter.list()
vlan = gandi.vlan.info(resource)
gateway = vlan['gateway']
if not ip:
output_vlan(gandi, vlan, datacenters, output_keys, justify=11)
return vlan
gateway_exists = False
vms = dict([(vm_['id'], vm_) for vm_ in gandi.iaas.list()])
ifaces = gandi.vlan.ifaces(resource)
for iface in ifaces:
for ip in iface['ips']:
if gateway == ip['ip']:
gateway_exists = True
if gateway_exists:
vlan.pop('gateway')
else:
vlan['gateway'] = ("%s don't exists" % gateway if gateway
else 'none')
output_vlan(gandi, vlan, datacenters, output_keys, justify=11)
output_keys = ['vm', 'bandwidth']
for iface in ifaces:
gandi.separator_line()
output_iface(gandi, iface, datacenters, vms, output_keys,
justify=11)
for ip in iface['ips']:
output_ip(gandi, ip, None, None, None, ['ip'])
if gateway == ip['ip']:
output_line(gandi, 'gateway', 'true', justify=11)
return vlan
|
[
"def",
"info",
"(",
"gandi",
",",
"resource",
",",
"ip",
")",
":",
"output_keys",
"=",
"[",
"'name'",
",",
"'state'",
",",
"'dc'",
",",
"'subnet'",
",",
"'gateway'",
"]",
"datacenters",
"=",
"gandi",
".",
"datacenter",
".",
"list",
"(",
")",
"vlan",
"=",
"gandi",
".",
"vlan",
".",
"info",
"(",
"resource",
")",
"gateway",
"=",
"vlan",
"[",
"'gateway'",
"]",
"if",
"not",
"ip",
":",
"output_vlan",
"(",
"gandi",
",",
"vlan",
",",
"datacenters",
",",
"output_keys",
",",
"justify",
"=",
"11",
")",
"return",
"vlan",
"gateway_exists",
"=",
"False",
"vms",
"=",
"dict",
"(",
"[",
"(",
"vm_",
"[",
"'id'",
"]",
",",
"vm_",
")",
"for",
"vm_",
"in",
"gandi",
".",
"iaas",
".",
"list",
"(",
")",
"]",
")",
"ifaces",
"=",
"gandi",
".",
"vlan",
".",
"ifaces",
"(",
"resource",
")",
"for",
"iface",
"in",
"ifaces",
":",
"for",
"ip",
"in",
"iface",
"[",
"'ips'",
"]",
":",
"if",
"gateway",
"==",
"ip",
"[",
"'ip'",
"]",
":",
"gateway_exists",
"=",
"True",
"if",
"gateway_exists",
":",
"vlan",
".",
"pop",
"(",
"'gateway'",
")",
"else",
":",
"vlan",
"[",
"'gateway'",
"]",
"=",
"(",
"\"%s don't exists\"",
"%",
"gateway",
"if",
"gateway",
"else",
"'none'",
")",
"output_vlan",
"(",
"gandi",
",",
"vlan",
",",
"datacenters",
",",
"output_keys",
",",
"justify",
"=",
"11",
")",
"output_keys",
"=",
"[",
"'vm'",
",",
"'bandwidth'",
"]",
"for",
"iface",
"in",
"ifaces",
":",
"gandi",
".",
"separator_line",
"(",
")",
"output_iface",
"(",
"gandi",
",",
"iface",
",",
"datacenters",
",",
"vms",
",",
"output_keys",
",",
"justify",
"=",
"11",
")",
"for",
"ip",
"in",
"iface",
"[",
"'ips'",
"]",
":",
"output_ip",
"(",
"gandi",
",",
"ip",
",",
"None",
",",
"None",
",",
"None",
",",
"[",
"'ip'",
"]",
")",
"if",
"gateway",
"==",
"ip",
"[",
"'ip'",
"]",
":",
"output_line",
"(",
"gandi",
",",
"'gateway'",
",",
"'true'",
",",
"justify",
"=",
"11",
")",
"return",
"vlan"
] |
Display information about a vlan.
|
[
"Display",
"information",
"about",
"a",
"vlan",
"."
] |
6ee5b8fc8ec44b0a6c232043ca610606ad8f693d
|
https://github.com/Gandi/gandi.cli/blob/6ee5b8fc8ec44b0a6c232043ca610606ad8f693d/gandi/cli/commands/vlan.py#L52-L93
|
10,998
|
Gandi/gandi.cli
|
gandi/cli/commands/vlan.py
|
create
|
def create(gandi, name, datacenter, subnet, gateway, background):
""" Create a new vlan """
try:
gandi.datacenter.is_opened(datacenter, 'iaas')
except DatacenterLimited as exc:
gandi.echo('/!\ Datacenter %s will be closed on %s, '
'please consider using another datacenter.' %
(datacenter, exc.date))
result = gandi.vlan.create(name, datacenter, subnet, gateway, background)
if background:
gandi.pretty_echo(result)
return result
|
python
|
def create(gandi, name, datacenter, subnet, gateway, background):
""" Create a new vlan """
try:
gandi.datacenter.is_opened(datacenter, 'iaas')
except DatacenterLimited as exc:
gandi.echo('/!\ Datacenter %s will be closed on %s, '
'please consider using another datacenter.' %
(datacenter, exc.date))
result = gandi.vlan.create(name, datacenter, subnet, gateway, background)
if background:
gandi.pretty_echo(result)
return result
|
[
"def",
"create",
"(",
"gandi",
",",
"name",
",",
"datacenter",
",",
"subnet",
",",
"gateway",
",",
"background",
")",
":",
"try",
":",
"gandi",
".",
"datacenter",
".",
"is_opened",
"(",
"datacenter",
",",
"'iaas'",
")",
"except",
"DatacenterLimited",
"as",
"exc",
":",
"gandi",
".",
"echo",
"(",
"'/!\\ Datacenter %s will be closed on %s, '",
"'please consider using another datacenter.'",
"%",
"(",
"datacenter",
",",
"exc",
".",
"date",
")",
")",
"result",
"=",
"gandi",
".",
"vlan",
".",
"create",
"(",
"name",
",",
"datacenter",
",",
"subnet",
",",
"gateway",
",",
"background",
")",
"if",
"background",
":",
"gandi",
".",
"pretty_echo",
"(",
"result",
")",
"return",
"result"
] |
Create a new vlan
|
[
"Create",
"a",
"new",
"vlan"
] |
6ee5b8fc8ec44b0a6c232043ca610606ad8f693d
|
https://github.com/Gandi/gandi.cli/blob/6ee5b8fc8ec44b0a6c232043ca610606ad8f693d/gandi/cli/commands/vlan.py#L144-L158
|
10,999
|
Gandi/gandi.cli
|
gandi/cli/commands/vlan.py
|
update
|
def update(gandi, resource, name, gateway, create, bandwidth):
""" Update a vlan
``gateway`` can be a vm name or id, or an ip.
"""
params = {}
if name:
params['name'] = name
vlan_id = gandi.vlan.usable_id(resource)
try:
if gateway:
IP(gateway)
params['gateway'] = gateway
except ValueError:
vm = gandi.iaas.info(gateway)
ips = [ip for sublist in
[[ip['ip'] for ip in iface['ips'] if ip['version'] == 4]
for iface in vm['ifaces']
if iface['vlan'] and iface['vlan'].get('id') == vlan_id]
for ip in sublist]
if len(ips) > 1:
gandi.echo("This vm has two ips in the vlan, don't know which one"
' to choose (%s)' % (', '.join(ips)))
return
if not ips and not create:
gandi.echo("Can't find '%s' in '%s' vlan" % (gateway, resource))
return
if not ips and create:
gandi.echo('Will create a new ip in this vlan for vm %s' % gateway)
oper = gandi.ip.create('4', vm['datacenter_id'], bandwidth,
vm['hostname'], resource)
iface_id = oper['iface_id']
iface = gandi.iface.info(iface_id)
ips = [ip['ip'] for ip in iface['ips'] if ip['version'] == 4]
params['gateway'] = ips[0]
result = gandi.vlan.update(resource, params)
return result
|
python
|
def update(gandi, resource, name, gateway, create, bandwidth):
""" Update a vlan
``gateway`` can be a vm name or id, or an ip.
"""
params = {}
if name:
params['name'] = name
vlan_id = gandi.vlan.usable_id(resource)
try:
if gateway:
IP(gateway)
params['gateway'] = gateway
except ValueError:
vm = gandi.iaas.info(gateway)
ips = [ip for sublist in
[[ip['ip'] for ip in iface['ips'] if ip['version'] == 4]
for iface in vm['ifaces']
if iface['vlan'] and iface['vlan'].get('id') == vlan_id]
for ip in sublist]
if len(ips) > 1:
gandi.echo("This vm has two ips in the vlan, don't know which one"
' to choose (%s)' % (', '.join(ips)))
return
if not ips and not create:
gandi.echo("Can't find '%s' in '%s' vlan" % (gateway, resource))
return
if not ips and create:
gandi.echo('Will create a new ip in this vlan for vm %s' % gateway)
oper = gandi.ip.create('4', vm['datacenter_id'], bandwidth,
vm['hostname'], resource)
iface_id = oper['iface_id']
iface = gandi.iface.info(iface_id)
ips = [ip['ip'] for ip in iface['ips'] if ip['version'] == 4]
params['gateway'] = ips[0]
result = gandi.vlan.update(resource, params)
return result
|
[
"def",
"update",
"(",
"gandi",
",",
"resource",
",",
"name",
",",
"gateway",
",",
"create",
",",
"bandwidth",
")",
":",
"params",
"=",
"{",
"}",
"if",
"name",
":",
"params",
"[",
"'name'",
"]",
"=",
"name",
"vlan_id",
"=",
"gandi",
".",
"vlan",
".",
"usable_id",
"(",
"resource",
")",
"try",
":",
"if",
"gateway",
":",
"IP",
"(",
"gateway",
")",
"params",
"[",
"'gateway'",
"]",
"=",
"gateway",
"except",
"ValueError",
":",
"vm",
"=",
"gandi",
".",
"iaas",
".",
"info",
"(",
"gateway",
")",
"ips",
"=",
"[",
"ip",
"for",
"sublist",
"in",
"[",
"[",
"ip",
"[",
"'ip'",
"]",
"for",
"ip",
"in",
"iface",
"[",
"'ips'",
"]",
"if",
"ip",
"[",
"'version'",
"]",
"==",
"4",
"]",
"for",
"iface",
"in",
"vm",
"[",
"'ifaces'",
"]",
"if",
"iface",
"[",
"'vlan'",
"]",
"and",
"iface",
"[",
"'vlan'",
"]",
".",
"get",
"(",
"'id'",
")",
"==",
"vlan_id",
"]",
"for",
"ip",
"in",
"sublist",
"]",
"if",
"len",
"(",
"ips",
")",
">",
"1",
":",
"gandi",
".",
"echo",
"(",
"\"This vm has two ips in the vlan, don't know which one\"",
"' to choose (%s)'",
"%",
"(",
"', '",
".",
"join",
"(",
"ips",
")",
")",
")",
"return",
"if",
"not",
"ips",
"and",
"not",
"create",
":",
"gandi",
".",
"echo",
"(",
"\"Can't find '%s' in '%s' vlan\"",
"%",
"(",
"gateway",
",",
"resource",
")",
")",
"return",
"if",
"not",
"ips",
"and",
"create",
":",
"gandi",
".",
"echo",
"(",
"'Will create a new ip in this vlan for vm %s'",
"%",
"gateway",
")",
"oper",
"=",
"gandi",
".",
"ip",
".",
"create",
"(",
"'4'",
",",
"vm",
"[",
"'datacenter_id'",
"]",
",",
"bandwidth",
",",
"vm",
"[",
"'hostname'",
"]",
",",
"resource",
")",
"iface_id",
"=",
"oper",
"[",
"'iface_id'",
"]",
"iface",
"=",
"gandi",
".",
"iface",
".",
"info",
"(",
"iface_id",
")",
"ips",
"=",
"[",
"ip",
"[",
"'ip'",
"]",
"for",
"ip",
"in",
"iface",
"[",
"'ips'",
"]",
"if",
"ip",
"[",
"'version'",
"]",
"==",
"4",
"]",
"params",
"[",
"'gateway'",
"]",
"=",
"ips",
"[",
"0",
"]",
"result",
"=",
"gandi",
".",
"vlan",
".",
"update",
"(",
"resource",
",",
"params",
")",
"return",
"result"
] |
Update a vlan
``gateway`` can be a vm name or id, or an ip.
|
[
"Update",
"a",
"vlan"
] |
6ee5b8fc8ec44b0a6c232043ca610606ad8f693d
|
https://github.com/Gandi/gandi.cli/blob/6ee5b8fc8ec44b0a6c232043ca610606ad8f693d/gandi/cli/commands/vlan.py#L172-L217
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.