prompt
large_stringlengths
72
9.34k
completion
large_stringlengths
0
7.61k
<|file_name|>value.py<|end_file_name|><|fim▁begin|>from keras.models import Sequential from keras.layers import convolutional from keras.layers.core import Dense, Flatten from SGD_exponential_decay import SGD_exponential_decay as SGD ### Parameters obtained from paper ### K = 152 # depth of convolutional layers LEARNING_RATE = .003 # initial learning rate DECAY = 8.664339379294006e-08 # rate of exponential learning_rate decay class value_trainer: def __init__(self): self.model = Sequential() self.model.add(convolutional.Convolution2D(input_shape=(49, 19, 19), nb_filter=K, nb_row=5, nb_col=5, init='uniform', activation='relu', border_mode='same')) for i in range(2,13): self.model.add(convolutional.Convolution2D(nb_filter=K, nb_row=3, nb_col=3, init='uniform', activation='relu', border_mode='same')) self.model.add(convolutional.Convolution2D(nb_filter=1, nb_row=1, nb_col=1, init='uniform', activation='linear', border_mode='same')) self.model.add(Flatten()) self.model.add(Dense(256,init='uniform')) self.model.add(Dense(1,init='uniform',activation="tanh")) sgd = SGD(lr=LEARNING_RATE, decay=DECAY) self.model.compile(loss='mean_squared_error', optimizer=sgd) def get_samples(self): # TODO non-terminating loop that draws training samples uniformly at random pass def train(self): # TODO use self.model.fit_generator to train from data source pass if __name__ == '__main__': <|fim_middle|> <|fim▁end|>
trainer = value_trainer() # TODO command line instantiation
<|file_name|>value.py<|end_file_name|><|fim▁begin|>from keras.models import Sequential from keras.layers import convolutional from keras.layers.core import Dense, Flatten from SGD_exponential_decay import SGD_exponential_decay as SGD ### Parameters obtained from paper ### K = 152 # depth of convolutional layers LEARNING_RATE = .003 # initial learning rate DECAY = 8.664339379294006e-08 # rate of exponential learning_rate decay class value_trainer: def <|fim_middle|>(self): self.model = Sequential() self.model.add(convolutional.Convolution2D(input_shape=(49, 19, 19), nb_filter=K, nb_row=5, nb_col=5, init='uniform', activation='relu', border_mode='same')) for i in range(2,13): self.model.add(convolutional.Convolution2D(nb_filter=K, nb_row=3, nb_col=3, init='uniform', activation='relu', border_mode='same')) self.model.add(convolutional.Convolution2D(nb_filter=1, nb_row=1, nb_col=1, init='uniform', activation='linear', border_mode='same')) self.model.add(Flatten()) self.model.add(Dense(256,init='uniform')) self.model.add(Dense(1,init='uniform',activation="tanh")) sgd = SGD(lr=LEARNING_RATE, decay=DECAY) self.model.compile(loss='mean_squared_error', optimizer=sgd) def get_samples(self): # TODO non-terminating loop that draws training samples uniformly at random pass def train(self): # TODO use self.model.fit_generator to train from data source pass if __name__ == '__main__': trainer = value_trainer() # TODO command line instantiation <|fim▁end|>
__init__
<|file_name|>value.py<|end_file_name|><|fim▁begin|>from keras.models import Sequential from keras.layers import convolutional from keras.layers.core import Dense, Flatten from SGD_exponential_decay import SGD_exponential_decay as SGD ### Parameters obtained from paper ### K = 152 # depth of convolutional layers LEARNING_RATE = .003 # initial learning rate DECAY = 8.664339379294006e-08 # rate of exponential learning_rate decay class value_trainer: def __init__(self): self.model = Sequential() self.model.add(convolutional.Convolution2D(input_shape=(49, 19, 19), nb_filter=K, nb_row=5, nb_col=5, init='uniform', activation='relu', border_mode='same')) for i in range(2,13): self.model.add(convolutional.Convolution2D(nb_filter=K, nb_row=3, nb_col=3, init='uniform', activation='relu', border_mode='same')) self.model.add(convolutional.Convolution2D(nb_filter=1, nb_row=1, nb_col=1, init='uniform', activation='linear', border_mode='same')) self.model.add(Flatten()) self.model.add(Dense(256,init='uniform')) self.model.add(Dense(1,init='uniform',activation="tanh")) sgd = SGD(lr=LEARNING_RATE, decay=DECAY) self.model.compile(loss='mean_squared_error', optimizer=sgd) def <|fim_middle|>(self): # TODO non-terminating loop that draws training samples uniformly at random pass def train(self): # TODO use self.model.fit_generator to train from data source pass if __name__ == '__main__': trainer = value_trainer() # TODO command line instantiation <|fim▁end|>
get_samples
<|file_name|>value.py<|end_file_name|><|fim▁begin|>from keras.models import Sequential from keras.layers import convolutional from keras.layers.core import Dense, Flatten from SGD_exponential_decay import SGD_exponential_decay as SGD ### Parameters obtained from paper ### K = 152 # depth of convolutional layers LEARNING_RATE = .003 # initial learning rate DECAY = 8.664339379294006e-08 # rate of exponential learning_rate decay class value_trainer: def __init__(self): self.model = Sequential() self.model.add(convolutional.Convolution2D(input_shape=(49, 19, 19), nb_filter=K, nb_row=5, nb_col=5, init='uniform', activation='relu', border_mode='same')) for i in range(2,13): self.model.add(convolutional.Convolution2D(nb_filter=K, nb_row=3, nb_col=3, init='uniform', activation='relu', border_mode='same')) self.model.add(convolutional.Convolution2D(nb_filter=1, nb_row=1, nb_col=1, init='uniform', activation='linear', border_mode='same')) self.model.add(Flatten()) self.model.add(Dense(256,init='uniform')) self.model.add(Dense(1,init='uniform',activation="tanh")) sgd = SGD(lr=LEARNING_RATE, decay=DECAY) self.model.compile(loss='mean_squared_error', optimizer=sgd) def get_samples(self): # TODO non-terminating loop that draws training samples uniformly at random pass def <|fim_middle|>(self): # TODO use self.model.fit_generator to train from data source pass if __name__ == '__main__': trainer = value_trainer() # TODO command line instantiation <|fim▁end|>
train
<|file_name|>profile.py<|end_file_name|><|fim▁begin|>import copy from collections import OrderedDict from collections import defaultdict from conans.model.env_info import EnvValues from conans.model.options import OptionsValues from conans.model.values import Values class Profile(object): """A profile contains a set of setting (with values), environment variables """ def __init__(self): # Sections self.settings = OrderedDict() self.package_settings = defaultdict(OrderedDict) self.env_values = EnvValues() self.options = OptionsValues() self.build_requires = OrderedDict() # conan_ref Pattern: list of conan_ref @property def settings_values(self): return Values.from_list(list(self.settings.items())) @property def package_settings_values(self): result = {} for pkg, settings in self.package_settings.items(): result[pkg] = list(settings.items()) return result def dumps(self): result = ["[settings]"] for name, value in self.settings.items(): result.append("%s=%s" % (name, value)) for package, values in self.package_settings.items(): for name, value in values.items(): result.append("%s:%s=%s" % (package, name, value)) result.append("[options]") result.append(self.options.dumps()) result.append("[build_requires]") for pattern, req_list in self.build_requires.items(): result.append("%s: %s" % (pattern, ", ".join(str(r) for r in req_list))) result.append("[env]") result.append(self.env_values.dumps()) return "\n".join(result).replace("\n\n", "\n") def update(self, other): self.update_settings(other.settings) self.update_package_settings(other.package_settings) # this is the opposite other.env_values.update(self.env_values) self.env_values = other.env_values self.options.update(other.options) for pattern, req_list in other.build_requires.items(): self.build_requires.setdefault(pattern, []).extend(req_list) def update_settings(self, new_settings): """Mix the specified settings with the current profile. Specified settings are prioritized to profile""" assert(isinstance(new_settings, OrderedDict)) # apply the current profile<|fim▁hole|> for name, value in new_settings.items(): if "." not in name: if name in self.settings and self.settings[name] != value: for cur_name, _ in self.settings.items(): if cur_name.startswith("%s." % name): del res[cur_name] # Now merge the new values res.update(new_settings) self.settings = res def update_package_settings(self, package_settings): """Mix the specified package settings with the specified profile. Specified package settings are prioritized to profile""" for package_name, settings in package_settings.items(): self.package_settings[package_name].update(settings)<|fim▁end|>
res = copy.copy(self.settings) if new_settings: # Invalidate the current subsettings if the parent setting changes # Example: new_settings declare a different "compiler", so invalidate the current "compiler.XXX"
<|file_name|>profile.py<|end_file_name|><|fim▁begin|>import copy from collections import OrderedDict from collections import defaultdict from conans.model.env_info import EnvValues from conans.model.options import OptionsValues from conans.model.values import Values class Profile(object): <|fim_middle|> <|fim▁end|>
"""A profile contains a set of setting (with values), environment variables """ def __init__(self): # Sections self.settings = OrderedDict() self.package_settings = defaultdict(OrderedDict) self.env_values = EnvValues() self.options = OptionsValues() self.build_requires = OrderedDict() # conan_ref Pattern: list of conan_ref @property def settings_values(self): return Values.from_list(list(self.settings.items())) @property def package_settings_values(self): result = {} for pkg, settings in self.package_settings.items(): result[pkg] = list(settings.items()) return result def dumps(self): result = ["[settings]"] for name, value in self.settings.items(): result.append("%s=%s" % (name, value)) for package, values in self.package_settings.items(): for name, value in values.items(): result.append("%s:%s=%s" % (package, name, value)) result.append("[options]") result.append(self.options.dumps()) result.append("[build_requires]") for pattern, req_list in self.build_requires.items(): result.append("%s: %s" % (pattern, ", ".join(str(r) for r in req_list))) result.append("[env]") result.append(self.env_values.dumps()) return "\n".join(result).replace("\n\n", "\n") def update(self, other): self.update_settings(other.settings) self.update_package_settings(other.package_settings) # this is the opposite other.env_values.update(self.env_values) self.env_values = other.env_values self.options.update(other.options) for pattern, req_list in other.build_requires.items(): self.build_requires.setdefault(pattern, []).extend(req_list) def update_settings(self, new_settings): """Mix the specified settings with the current profile. Specified settings are prioritized to profile""" assert(isinstance(new_settings, OrderedDict)) # apply the current profile res = copy.copy(self.settings) if new_settings: # Invalidate the current subsettings if the parent setting changes # Example: new_settings declare a different "compiler", so invalidate the current "compiler.XXX" for name, value in new_settings.items(): if "." not in name: if name in self.settings and self.settings[name] != value: for cur_name, _ in self.settings.items(): if cur_name.startswith("%s." % name): del res[cur_name] # Now merge the new values res.update(new_settings) self.settings = res def update_package_settings(self, package_settings): """Mix the specified package settings with the specified profile. Specified package settings are prioritized to profile""" for package_name, settings in package_settings.items(): self.package_settings[package_name].update(settings)
<|file_name|>profile.py<|end_file_name|><|fim▁begin|>import copy from collections import OrderedDict from collections import defaultdict from conans.model.env_info import EnvValues from conans.model.options import OptionsValues from conans.model.values import Values class Profile(object): """A profile contains a set of setting (with values), environment variables """ def __init__(self): # Sections <|fim_middle|> @property def settings_values(self): return Values.from_list(list(self.settings.items())) @property def package_settings_values(self): result = {} for pkg, settings in self.package_settings.items(): result[pkg] = list(settings.items()) return result def dumps(self): result = ["[settings]"] for name, value in self.settings.items(): result.append("%s=%s" % (name, value)) for package, values in self.package_settings.items(): for name, value in values.items(): result.append("%s:%s=%s" % (package, name, value)) result.append("[options]") result.append(self.options.dumps()) result.append("[build_requires]") for pattern, req_list in self.build_requires.items(): result.append("%s: %s" % (pattern, ", ".join(str(r) for r in req_list))) result.append("[env]") result.append(self.env_values.dumps()) return "\n".join(result).replace("\n\n", "\n") def update(self, other): self.update_settings(other.settings) self.update_package_settings(other.package_settings) # this is the opposite other.env_values.update(self.env_values) self.env_values = other.env_values self.options.update(other.options) for pattern, req_list in other.build_requires.items(): self.build_requires.setdefault(pattern, []).extend(req_list) def update_settings(self, new_settings): """Mix the specified settings with the current profile. Specified settings are prioritized to profile""" assert(isinstance(new_settings, OrderedDict)) # apply the current profile res = copy.copy(self.settings) if new_settings: # Invalidate the current subsettings if the parent setting changes # Example: new_settings declare a different "compiler", so invalidate the current "compiler.XXX" for name, value in new_settings.items(): if "." not in name: if name in self.settings and self.settings[name] != value: for cur_name, _ in self.settings.items(): if cur_name.startswith("%s." % name): del res[cur_name] # Now merge the new values res.update(new_settings) self.settings = res def update_package_settings(self, package_settings): """Mix the specified package settings with the specified profile. Specified package settings are prioritized to profile""" for package_name, settings in package_settings.items(): self.package_settings[package_name].update(settings) <|fim▁end|>
self.settings = OrderedDict() self.package_settings = defaultdict(OrderedDict) self.env_values = EnvValues() self.options = OptionsValues() self.build_requires = OrderedDict() # conan_ref Pattern: list of conan_ref
<|file_name|>profile.py<|end_file_name|><|fim▁begin|>import copy from collections import OrderedDict from collections import defaultdict from conans.model.env_info import EnvValues from conans.model.options import OptionsValues from conans.model.values import Values class Profile(object): """A profile contains a set of setting (with values), environment variables """ def __init__(self): # Sections self.settings = OrderedDict() self.package_settings = defaultdict(OrderedDict) self.env_values = EnvValues() self.options = OptionsValues() self.build_requires = OrderedDict() # conan_ref Pattern: list of conan_ref @property def settings_values(self): <|fim_middle|> @property def package_settings_values(self): result = {} for pkg, settings in self.package_settings.items(): result[pkg] = list(settings.items()) return result def dumps(self): result = ["[settings]"] for name, value in self.settings.items(): result.append("%s=%s" % (name, value)) for package, values in self.package_settings.items(): for name, value in values.items(): result.append("%s:%s=%s" % (package, name, value)) result.append("[options]") result.append(self.options.dumps()) result.append("[build_requires]") for pattern, req_list in self.build_requires.items(): result.append("%s: %s" % (pattern, ", ".join(str(r) for r in req_list))) result.append("[env]") result.append(self.env_values.dumps()) return "\n".join(result).replace("\n\n", "\n") def update(self, other): self.update_settings(other.settings) self.update_package_settings(other.package_settings) # this is the opposite other.env_values.update(self.env_values) self.env_values = other.env_values self.options.update(other.options) for pattern, req_list in other.build_requires.items(): self.build_requires.setdefault(pattern, []).extend(req_list) def update_settings(self, new_settings): """Mix the specified settings with the current profile. Specified settings are prioritized to profile""" assert(isinstance(new_settings, OrderedDict)) # apply the current profile res = copy.copy(self.settings) if new_settings: # Invalidate the current subsettings if the parent setting changes # Example: new_settings declare a different "compiler", so invalidate the current "compiler.XXX" for name, value in new_settings.items(): if "." not in name: if name in self.settings and self.settings[name] != value: for cur_name, _ in self.settings.items(): if cur_name.startswith("%s." % name): del res[cur_name] # Now merge the new values res.update(new_settings) self.settings = res def update_package_settings(self, package_settings): """Mix the specified package settings with the specified profile. Specified package settings are prioritized to profile""" for package_name, settings in package_settings.items(): self.package_settings[package_name].update(settings) <|fim▁end|>
return Values.from_list(list(self.settings.items()))
<|file_name|>profile.py<|end_file_name|><|fim▁begin|>import copy from collections import OrderedDict from collections import defaultdict from conans.model.env_info import EnvValues from conans.model.options import OptionsValues from conans.model.values import Values class Profile(object): """A profile contains a set of setting (with values), environment variables """ def __init__(self): # Sections self.settings = OrderedDict() self.package_settings = defaultdict(OrderedDict) self.env_values = EnvValues() self.options = OptionsValues() self.build_requires = OrderedDict() # conan_ref Pattern: list of conan_ref @property def settings_values(self): return Values.from_list(list(self.settings.items())) @property def package_settings_values(self): <|fim_middle|> def dumps(self): result = ["[settings]"] for name, value in self.settings.items(): result.append("%s=%s" % (name, value)) for package, values in self.package_settings.items(): for name, value in values.items(): result.append("%s:%s=%s" % (package, name, value)) result.append("[options]") result.append(self.options.dumps()) result.append("[build_requires]") for pattern, req_list in self.build_requires.items(): result.append("%s: %s" % (pattern, ", ".join(str(r) for r in req_list))) result.append("[env]") result.append(self.env_values.dumps()) return "\n".join(result).replace("\n\n", "\n") def update(self, other): self.update_settings(other.settings) self.update_package_settings(other.package_settings) # this is the opposite other.env_values.update(self.env_values) self.env_values = other.env_values self.options.update(other.options) for pattern, req_list in other.build_requires.items(): self.build_requires.setdefault(pattern, []).extend(req_list) def update_settings(self, new_settings): """Mix the specified settings with the current profile. Specified settings are prioritized to profile""" assert(isinstance(new_settings, OrderedDict)) # apply the current profile res = copy.copy(self.settings) if new_settings: # Invalidate the current subsettings if the parent setting changes # Example: new_settings declare a different "compiler", so invalidate the current "compiler.XXX" for name, value in new_settings.items(): if "." not in name: if name in self.settings and self.settings[name] != value: for cur_name, _ in self.settings.items(): if cur_name.startswith("%s." % name): del res[cur_name] # Now merge the new values res.update(new_settings) self.settings = res def update_package_settings(self, package_settings): """Mix the specified package settings with the specified profile. Specified package settings are prioritized to profile""" for package_name, settings in package_settings.items(): self.package_settings[package_name].update(settings) <|fim▁end|>
result = {} for pkg, settings in self.package_settings.items(): result[pkg] = list(settings.items()) return result
<|file_name|>profile.py<|end_file_name|><|fim▁begin|>import copy from collections import OrderedDict from collections import defaultdict from conans.model.env_info import EnvValues from conans.model.options import OptionsValues from conans.model.values import Values class Profile(object): """A profile contains a set of setting (with values), environment variables """ def __init__(self): # Sections self.settings = OrderedDict() self.package_settings = defaultdict(OrderedDict) self.env_values = EnvValues() self.options = OptionsValues() self.build_requires = OrderedDict() # conan_ref Pattern: list of conan_ref @property def settings_values(self): return Values.from_list(list(self.settings.items())) @property def package_settings_values(self): result = {} for pkg, settings in self.package_settings.items(): result[pkg] = list(settings.items()) return result def dumps(self): <|fim_middle|> def update(self, other): self.update_settings(other.settings) self.update_package_settings(other.package_settings) # this is the opposite other.env_values.update(self.env_values) self.env_values = other.env_values self.options.update(other.options) for pattern, req_list in other.build_requires.items(): self.build_requires.setdefault(pattern, []).extend(req_list) def update_settings(self, new_settings): """Mix the specified settings with the current profile. Specified settings are prioritized to profile""" assert(isinstance(new_settings, OrderedDict)) # apply the current profile res = copy.copy(self.settings) if new_settings: # Invalidate the current subsettings if the parent setting changes # Example: new_settings declare a different "compiler", so invalidate the current "compiler.XXX" for name, value in new_settings.items(): if "." not in name: if name in self.settings and self.settings[name] != value: for cur_name, _ in self.settings.items(): if cur_name.startswith("%s." % name): del res[cur_name] # Now merge the new values res.update(new_settings) self.settings = res def update_package_settings(self, package_settings): """Mix the specified package settings with the specified profile. Specified package settings are prioritized to profile""" for package_name, settings in package_settings.items(): self.package_settings[package_name].update(settings) <|fim▁end|>
result = ["[settings]"] for name, value in self.settings.items(): result.append("%s=%s" % (name, value)) for package, values in self.package_settings.items(): for name, value in values.items(): result.append("%s:%s=%s" % (package, name, value)) result.append("[options]") result.append(self.options.dumps()) result.append("[build_requires]") for pattern, req_list in self.build_requires.items(): result.append("%s: %s" % (pattern, ", ".join(str(r) for r in req_list))) result.append("[env]") result.append(self.env_values.dumps()) return "\n".join(result).replace("\n\n", "\n")
<|file_name|>profile.py<|end_file_name|><|fim▁begin|>import copy from collections import OrderedDict from collections import defaultdict from conans.model.env_info import EnvValues from conans.model.options import OptionsValues from conans.model.values import Values class Profile(object): """A profile contains a set of setting (with values), environment variables """ def __init__(self): # Sections self.settings = OrderedDict() self.package_settings = defaultdict(OrderedDict) self.env_values = EnvValues() self.options = OptionsValues() self.build_requires = OrderedDict() # conan_ref Pattern: list of conan_ref @property def settings_values(self): return Values.from_list(list(self.settings.items())) @property def package_settings_values(self): result = {} for pkg, settings in self.package_settings.items(): result[pkg] = list(settings.items()) return result def dumps(self): result = ["[settings]"] for name, value in self.settings.items(): result.append("%s=%s" % (name, value)) for package, values in self.package_settings.items(): for name, value in values.items(): result.append("%s:%s=%s" % (package, name, value)) result.append("[options]") result.append(self.options.dumps()) result.append("[build_requires]") for pattern, req_list in self.build_requires.items(): result.append("%s: %s" % (pattern, ", ".join(str(r) for r in req_list))) result.append("[env]") result.append(self.env_values.dumps()) return "\n".join(result).replace("\n\n", "\n") def update(self, other): <|fim_middle|> def update_settings(self, new_settings): """Mix the specified settings with the current profile. Specified settings are prioritized to profile""" assert(isinstance(new_settings, OrderedDict)) # apply the current profile res = copy.copy(self.settings) if new_settings: # Invalidate the current subsettings if the parent setting changes # Example: new_settings declare a different "compiler", so invalidate the current "compiler.XXX" for name, value in new_settings.items(): if "." not in name: if name in self.settings and self.settings[name] != value: for cur_name, _ in self.settings.items(): if cur_name.startswith("%s." % name): del res[cur_name] # Now merge the new values res.update(new_settings) self.settings = res def update_package_settings(self, package_settings): """Mix the specified package settings with the specified profile. Specified package settings are prioritized to profile""" for package_name, settings in package_settings.items(): self.package_settings[package_name].update(settings) <|fim▁end|>
self.update_settings(other.settings) self.update_package_settings(other.package_settings) # this is the opposite other.env_values.update(self.env_values) self.env_values = other.env_values self.options.update(other.options) for pattern, req_list in other.build_requires.items(): self.build_requires.setdefault(pattern, []).extend(req_list)
<|file_name|>profile.py<|end_file_name|><|fim▁begin|>import copy from collections import OrderedDict from collections import defaultdict from conans.model.env_info import EnvValues from conans.model.options import OptionsValues from conans.model.values import Values class Profile(object): """A profile contains a set of setting (with values), environment variables """ def __init__(self): # Sections self.settings = OrderedDict() self.package_settings = defaultdict(OrderedDict) self.env_values = EnvValues() self.options = OptionsValues() self.build_requires = OrderedDict() # conan_ref Pattern: list of conan_ref @property def settings_values(self): return Values.from_list(list(self.settings.items())) @property def package_settings_values(self): result = {} for pkg, settings in self.package_settings.items(): result[pkg] = list(settings.items()) return result def dumps(self): result = ["[settings]"] for name, value in self.settings.items(): result.append("%s=%s" % (name, value)) for package, values in self.package_settings.items(): for name, value in values.items(): result.append("%s:%s=%s" % (package, name, value)) result.append("[options]") result.append(self.options.dumps()) result.append("[build_requires]") for pattern, req_list in self.build_requires.items(): result.append("%s: %s" % (pattern, ", ".join(str(r) for r in req_list))) result.append("[env]") result.append(self.env_values.dumps()) return "\n".join(result).replace("\n\n", "\n") def update(self, other): self.update_settings(other.settings) self.update_package_settings(other.package_settings) # this is the opposite other.env_values.update(self.env_values) self.env_values = other.env_values self.options.update(other.options) for pattern, req_list in other.build_requires.items(): self.build_requires.setdefault(pattern, []).extend(req_list) def update_settings(self, new_settings): <|fim_middle|> def update_package_settings(self, package_settings): """Mix the specified package settings with the specified profile. Specified package settings are prioritized to profile""" for package_name, settings in package_settings.items(): self.package_settings[package_name].update(settings) <|fim▁end|>
"""Mix the specified settings with the current profile. Specified settings are prioritized to profile""" assert(isinstance(new_settings, OrderedDict)) # apply the current profile res = copy.copy(self.settings) if new_settings: # Invalidate the current subsettings if the parent setting changes # Example: new_settings declare a different "compiler", so invalidate the current "compiler.XXX" for name, value in new_settings.items(): if "." not in name: if name in self.settings and self.settings[name] != value: for cur_name, _ in self.settings.items(): if cur_name.startswith("%s." % name): del res[cur_name] # Now merge the new values res.update(new_settings) self.settings = res
<|file_name|>profile.py<|end_file_name|><|fim▁begin|>import copy from collections import OrderedDict from collections import defaultdict from conans.model.env_info import EnvValues from conans.model.options import OptionsValues from conans.model.values import Values class Profile(object): """A profile contains a set of setting (with values), environment variables """ def __init__(self): # Sections self.settings = OrderedDict() self.package_settings = defaultdict(OrderedDict) self.env_values = EnvValues() self.options = OptionsValues() self.build_requires = OrderedDict() # conan_ref Pattern: list of conan_ref @property def settings_values(self): return Values.from_list(list(self.settings.items())) @property def package_settings_values(self): result = {} for pkg, settings in self.package_settings.items(): result[pkg] = list(settings.items()) return result def dumps(self): result = ["[settings]"] for name, value in self.settings.items(): result.append("%s=%s" % (name, value)) for package, values in self.package_settings.items(): for name, value in values.items(): result.append("%s:%s=%s" % (package, name, value)) result.append("[options]") result.append(self.options.dumps()) result.append("[build_requires]") for pattern, req_list in self.build_requires.items(): result.append("%s: %s" % (pattern, ", ".join(str(r) for r in req_list))) result.append("[env]") result.append(self.env_values.dumps()) return "\n".join(result).replace("\n\n", "\n") def update(self, other): self.update_settings(other.settings) self.update_package_settings(other.package_settings) # this is the opposite other.env_values.update(self.env_values) self.env_values = other.env_values self.options.update(other.options) for pattern, req_list in other.build_requires.items(): self.build_requires.setdefault(pattern, []).extend(req_list) def update_settings(self, new_settings): """Mix the specified settings with the current profile. Specified settings are prioritized to profile""" assert(isinstance(new_settings, OrderedDict)) # apply the current profile res = copy.copy(self.settings) if new_settings: # Invalidate the current subsettings if the parent setting changes # Example: new_settings declare a different "compiler", so invalidate the current "compiler.XXX" for name, value in new_settings.items(): if "." not in name: if name in self.settings and self.settings[name] != value: for cur_name, _ in self.settings.items(): if cur_name.startswith("%s." % name): del res[cur_name] # Now merge the new values res.update(new_settings) self.settings = res def update_package_settings(self, package_settings): <|fim_middle|> <|fim▁end|>
"""Mix the specified package settings with the specified profile. Specified package settings are prioritized to profile""" for package_name, settings in package_settings.items(): self.package_settings[package_name].update(settings)
<|file_name|>profile.py<|end_file_name|><|fim▁begin|>import copy from collections import OrderedDict from collections import defaultdict from conans.model.env_info import EnvValues from conans.model.options import OptionsValues from conans.model.values import Values class Profile(object): """A profile contains a set of setting (with values), environment variables """ def __init__(self): # Sections self.settings = OrderedDict() self.package_settings = defaultdict(OrderedDict) self.env_values = EnvValues() self.options = OptionsValues() self.build_requires = OrderedDict() # conan_ref Pattern: list of conan_ref @property def settings_values(self): return Values.from_list(list(self.settings.items())) @property def package_settings_values(self): result = {} for pkg, settings in self.package_settings.items(): result[pkg] = list(settings.items()) return result def dumps(self): result = ["[settings]"] for name, value in self.settings.items(): result.append("%s=%s" % (name, value)) for package, values in self.package_settings.items(): for name, value in values.items(): result.append("%s:%s=%s" % (package, name, value)) result.append("[options]") result.append(self.options.dumps()) result.append("[build_requires]") for pattern, req_list in self.build_requires.items(): result.append("%s: %s" % (pattern, ", ".join(str(r) for r in req_list))) result.append("[env]") result.append(self.env_values.dumps()) return "\n".join(result).replace("\n\n", "\n") def update(self, other): self.update_settings(other.settings) self.update_package_settings(other.package_settings) # this is the opposite other.env_values.update(self.env_values) self.env_values = other.env_values self.options.update(other.options) for pattern, req_list in other.build_requires.items(): self.build_requires.setdefault(pattern, []).extend(req_list) def update_settings(self, new_settings): """Mix the specified settings with the current profile. Specified settings are prioritized to profile""" assert(isinstance(new_settings, OrderedDict)) # apply the current profile res = copy.copy(self.settings) if new_settings: # Invalidate the current subsettings if the parent setting changes # Example: new_settings declare a different "compiler", so invalidate the current "compiler.XXX" <|fim_middle|> def update_package_settings(self, package_settings): """Mix the specified package settings with the specified profile. Specified package settings are prioritized to profile""" for package_name, settings in package_settings.items(): self.package_settings[package_name].update(settings) <|fim▁end|>
for name, value in new_settings.items(): if "." not in name: if name in self.settings and self.settings[name] != value: for cur_name, _ in self.settings.items(): if cur_name.startswith("%s." % name): del res[cur_name] # Now merge the new values res.update(new_settings) self.settings = res
<|file_name|>profile.py<|end_file_name|><|fim▁begin|>import copy from collections import OrderedDict from collections import defaultdict from conans.model.env_info import EnvValues from conans.model.options import OptionsValues from conans.model.values import Values class Profile(object): """A profile contains a set of setting (with values), environment variables """ def __init__(self): # Sections self.settings = OrderedDict() self.package_settings = defaultdict(OrderedDict) self.env_values = EnvValues() self.options = OptionsValues() self.build_requires = OrderedDict() # conan_ref Pattern: list of conan_ref @property def settings_values(self): return Values.from_list(list(self.settings.items())) @property def package_settings_values(self): result = {} for pkg, settings in self.package_settings.items(): result[pkg] = list(settings.items()) return result def dumps(self): result = ["[settings]"] for name, value in self.settings.items(): result.append("%s=%s" % (name, value)) for package, values in self.package_settings.items(): for name, value in values.items(): result.append("%s:%s=%s" % (package, name, value)) result.append("[options]") result.append(self.options.dumps()) result.append("[build_requires]") for pattern, req_list in self.build_requires.items(): result.append("%s: %s" % (pattern, ", ".join(str(r) for r in req_list))) result.append("[env]") result.append(self.env_values.dumps()) return "\n".join(result).replace("\n\n", "\n") def update(self, other): self.update_settings(other.settings) self.update_package_settings(other.package_settings) # this is the opposite other.env_values.update(self.env_values) self.env_values = other.env_values self.options.update(other.options) for pattern, req_list in other.build_requires.items(): self.build_requires.setdefault(pattern, []).extend(req_list) def update_settings(self, new_settings): """Mix the specified settings with the current profile. Specified settings are prioritized to profile""" assert(isinstance(new_settings, OrderedDict)) # apply the current profile res = copy.copy(self.settings) if new_settings: # Invalidate the current subsettings if the parent setting changes # Example: new_settings declare a different "compiler", so invalidate the current "compiler.XXX" for name, value in new_settings.items(): if "." not in name: <|fim_middle|> # Now merge the new values res.update(new_settings) self.settings = res def update_package_settings(self, package_settings): """Mix the specified package settings with the specified profile. Specified package settings are prioritized to profile""" for package_name, settings in package_settings.items(): self.package_settings[package_name].update(settings) <|fim▁end|>
if name in self.settings and self.settings[name] != value: for cur_name, _ in self.settings.items(): if cur_name.startswith("%s." % name): del res[cur_name]
<|file_name|>profile.py<|end_file_name|><|fim▁begin|>import copy from collections import OrderedDict from collections import defaultdict from conans.model.env_info import EnvValues from conans.model.options import OptionsValues from conans.model.values import Values class Profile(object): """A profile contains a set of setting (with values), environment variables """ def __init__(self): # Sections self.settings = OrderedDict() self.package_settings = defaultdict(OrderedDict) self.env_values = EnvValues() self.options = OptionsValues() self.build_requires = OrderedDict() # conan_ref Pattern: list of conan_ref @property def settings_values(self): return Values.from_list(list(self.settings.items())) @property def package_settings_values(self): result = {} for pkg, settings in self.package_settings.items(): result[pkg] = list(settings.items()) return result def dumps(self): result = ["[settings]"] for name, value in self.settings.items(): result.append("%s=%s" % (name, value)) for package, values in self.package_settings.items(): for name, value in values.items(): result.append("%s:%s=%s" % (package, name, value)) result.append("[options]") result.append(self.options.dumps()) result.append("[build_requires]") for pattern, req_list in self.build_requires.items(): result.append("%s: %s" % (pattern, ", ".join(str(r) for r in req_list))) result.append("[env]") result.append(self.env_values.dumps()) return "\n".join(result).replace("\n\n", "\n") def update(self, other): self.update_settings(other.settings) self.update_package_settings(other.package_settings) # this is the opposite other.env_values.update(self.env_values) self.env_values = other.env_values self.options.update(other.options) for pattern, req_list in other.build_requires.items(): self.build_requires.setdefault(pattern, []).extend(req_list) def update_settings(self, new_settings): """Mix the specified settings with the current profile. Specified settings are prioritized to profile""" assert(isinstance(new_settings, OrderedDict)) # apply the current profile res = copy.copy(self.settings) if new_settings: # Invalidate the current subsettings if the parent setting changes # Example: new_settings declare a different "compiler", so invalidate the current "compiler.XXX" for name, value in new_settings.items(): if "." not in name: if name in self.settings and self.settings[name] != value: <|fim_middle|> # Now merge the new values res.update(new_settings) self.settings = res def update_package_settings(self, package_settings): """Mix the specified package settings with the specified profile. Specified package settings are prioritized to profile""" for package_name, settings in package_settings.items(): self.package_settings[package_name].update(settings) <|fim▁end|>
for cur_name, _ in self.settings.items(): if cur_name.startswith("%s." % name): del res[cur_name]
<|file_name|>profile.py<|end_file_name|><|fim▁begin|>import copy from collections import OrderedDict from collections import defaultdict from conans.model.env_info import EnvValues from conans.model.options import OptionsValues from conans.model.values import Values class Profile(object): """A profile contains a set of setting (with values), environment variables """ def __init__(self): # Sections self.settings = OrderedDict() self.package_settings = defaultdict(OrderedDict) self.env_values = EnvValues() self.options = OptionsValues() self.build_requires = OrderedDict() # conan_ref Pattern: list of conan_ref @property def settings_values(self): return Values.from_list(list(self.settings.items())) @property def package_settings_values(self): result = {} for pkg, settings in self.package_settings.items(): result[pkg] = list(settings.items()) return result def dumps(self): result = ["[settings]"] for name, value in self.settings.items(): result.append("%s=%s" % (name, value)) for package, values in self.package_settings.items(): for name, value in values.items(): result.append("%s:%s=%s" % (package, name, value)) result.append("[options]") result.append(self.options.dumps()) result.append("[build_requires]") for pattern, req_list in self.build_requires.items(): result.append("%s: %s" % (pattern, ", ".join(str(r) for r in req_list))) result.append("[env]") result.append(self.env_values.dumps()) return "\n".join(result).replace("\n\n", "\n") def update(self, other): self.update_settings(other.settings) self.update_package_settings(other.package_settings) # this is the opposite other.env_values.update(self.env_values) self.env_values = other.env_values self.options.update(other.options) for pattern, req_list in other.build_requires.items(): self.build_requires.setdefault(pattern, []).extend(req_list) def update_settings(self, new_settings): """Mix the specified settings with the current profile. Specified settings are prioritized to profile""" assert(isinstance(new_settings, OrderedDict)) # apply the current profile res = copy.copy(self.settings) if new_settings: # Invalidate the current subsettings if the parent setting changes # Example: new_settings declare a different "compiler", so invalidate the current "compiler.XXX" for name, value in new_settings.items(): if "." not in name: if name in self.settings and self.settings[name] != value: for cur_name, _ in self.settings.items(): if cur_name.startswith("%s." % name): <|fim_middle|> # Now merge the new values res.update(new_settings) self.settings = res def update_package_settings(self, package_settings): """Mix the specified package settings with the specified profile. Specified package settings are prioritized to profile""" for package_name, settings in package_settings.items(): self.package_settings[package_name].update(settings) <|fim▁end|>
del res[cur_name]
<|file_name|>profile.py<|end_file_name|><|fim▁begin|>import copy from collections import OrderedDict from collections import defaultdict from conans.model.env_info import EnvValues from conans.model.options import OptionsValues from conans.model.values import Values class Profile(object): """A profile contains a set of setting (with values), environment variables """ def <|fim_middle|>(self): # Sections self.settings = OrderedDict() self.package_settings = defaultdict(OrderedDict) self.env_values = EnvValues() self.options = OptionsValues() self.build_requires = OrderedDict() # conan_ref Pattern: list of conan_ref @property def settings_values(self): return Values.from_list(list(self.settings.items())) @property def package_settings_values(self): result = {} for pkg, settings in self.package_settings.items(): result[pkg] = list(settings.items()) return result def dumps(self): result = ["[settings]"] for name, value in self.settings.items(): result.append("%s=%s" % (name, value)) for package, values in self.package_settings.items(): for name, value in values.items(): result.append("%s:%s=%s" % (package, name, value)) result.append("[options]") result.append(self.options.dumps()) result.append("[build_requires]") for pattern, req_list in self.build_requires.items(): result.append("%s: %s" % (pattern, ", ".join(str(r) for r in req_list))) result.append("[env]") result.append(self.env_values.dumps()) return "\n".join(result).replace("\n\n", "\n") def update(self, other): self.update_settings(other.settings) self.update_package_settings(other.package_settings) # this is the opposite other.env_values.update(self.env_values) self.env_values = other.env_values self.options.update(other.options) for pattern, req_list in other.build_requires.items(): self.build_requires.setdefault(pattern, []).extend(req_list) def update_settings(self, new_settings): """Mix the specified settings with the current profile. Specified settings are prioritized to profile""" assert(isinstance(new_settings, OrderedDict)) # apply the current profile res = copy.copy(self.settings) if new_settings: # Invalidate the current subsettings if the parent setting changes # Example: new_settings declare a different "compiler", so invalidate the current "compiler.XXX" for name, value in new_settings.items(): if "." not in name: if name in self.settings and self.settings[name] != value: for cur_name, _ in self.settings.items(): if cur_name.startswith("%s." % name): del res[cur_name] # Now merge the new values res.update(new_settings) self.settings = res def update_package_settings(self, package_settings): """Mix the specified package settings with the specified profile. Specified package settings are prioritized to profile""" for package_name, settings in package_settings.items(): self.package_settings[package_name].update(settings) <|fim▁end|>
__init__
<|file_name|>profile.py<|end_file_name|><|fim▁begin|>import copy from collections import OrderedDict from collections import defaultdict from conans.model.env_info import EnvValues from conans.model.options import OptionsValues from conans.model.values import Values class Profile(object): """A profile contains a set of setting (with values), environment variables """ def __init__(self): # Sections self.settings = OrderedDict() self.package_settings = defaultdict(OrderedDict) self.env_values = EnvValues() self.options = OptionsValues() self.build_requires = OrderedDict() # conan_ref Pattern: list of conan_ref @property def <|fim_middle|>(self): return Values.from_list(list(self.settings.items())) @property def package_settings_values(self): result = {} for pkg, settings in self.package_settings.items(): result[pkg] = list(settings.items()) return result def dumps(self): result = ["[settings]"] for name, value in self.settings.items(): result.append("%s=%s" % (name, value)) for package, values in self.package_settings.items(): for name, value in values.items(): result.append("%s:%s=%s" % (package, name, value)) result.append("[options]") result.append(self.options.dumps()) result.append("[build_requires]") for pattern, req_list in self.build_requires.items(): result.append("%s: %s" % (pattern, ", ".join(str(r) for r in req_list))) result.append("[env]") result.append(self.env_values.dumps()) return "\n".join(result).replace("\n\n", "\n") def update(self, other): self.update_settings(other.settings) self.update_package_settings(other.package_settings) # this is the opposite other.env_values.update(self.env_values) self.env_values = other.env_values self.options.update(other.options) for pattern, req_list in other.build_requires.items(): self.build_requires.setdefault(pattern, []).extend(req_list) def update_settings(self, new_settings): """Mix the specified settings with the current profile. Specified settings are prioritized to profile""" assert(isinstance(new_settings, OrderedDict)) # apply the current profile res = copy.copy(self.settings) if new_settings: # Invalidate the current subsettings if the parent setting changes # Example: new_settings declare a different "compiler", so invalidate the current "compiler.XXX" for name, value in new_settings.items(): if "." not in name: if name in self.settings and self.settings[name] != value: for cur_name, _ in self.settings.items(): if cur_name.startswith("%s." % name): del res[cur_name] # Now merge the new values res.update(new_settings) self.settings = res def update_package_settings(self, package_settings): """Mix the specified package settings with the specified profile. Specified package settings are prioritized to profile""" for package_name, settings in package_settings.items(): self.package_settings[package_name].update(settings) <|fim▁end|>
settings_values
<|file_name|>profile.py<|end_file_name|><|fim▁begin|>import copy from collections import OrderedDict from collections import defaultdict from conans.model.env_info import EnvValues from conans.model.options import OptionsValues from conans.model.values import Values class Profile(object): """A profile contains a set of setting (with values), environment variables """ def __init__(self): # Sections self.settings = OrderedDict() self.package_settings = defaultdict(OrderedDict) self.env_values = EnvValues() self.options = OptionsValues() self.build_requires = OrderedDict() # conan_ref Pattern: list of conan_ref @property def settings_values(self): return Values.from_list(list(self.settings.items())) @property def <|fim_middle|>(self): result = {} for pkg, settings in self.package_settings.items(): result[pkg] = list(settings.items()) return result def dumps(self): result = ["[settings]"] for name, value in self.settings.items(): result.append("%s=%s" % (name, value)) for package, values in self.package_settings.items(): for name, value in values.items(): result.append("%s:%s=%s" % (package, name, value)) result.append("[options]") result.append(self.options.dumps()) result.append("[build_requires]") for pattern, req_list in self.build_requires.items(): result.append("%s: %s" % (pattern, ", ".join(str(r) for r in req_list))) result.append("[env]") result.append(self.env_values.dumps()) return "\n".join(result).replace("\n\n", "\n") def update(self, other): self.update_settings(other.settings) self.update_package_settings(other.package_settings) # this is the opposite other.env_values.update(self.env_values) self.env_values = other.env_values self.options.update(other.options) for pattern, req_list in other.build_requires.items(): self.build_requires.setdefault(pattern, []).extend(req_list) def update_settings(self, new_settings): """Mix the specified settings with the current profile. Specified settings are prioritized to profile""" assert(isinstance(new_settings, OrderedDict)) # apply the current profile res = copy.copy(self.settings) if new_settings: # Invalidate the current subsettings if the parent setting changes # Example: new_settings declare a different "compiler", so invalidate the current "compiler.XXX" for name, value in new_settings.items(): if "." not in name: if name in self.settings and self.settings[name] != value: for cur_name, _ in self.settings.items(): if cur_name.startswith("%s." % name): del res[cur_name] # Now merge the new values res.update(new_settings) self.settings = res def update_package_settings(self, package_settings): """Mix the specified package settings with the specified profile. Specified package settings are prioritized to profile""" for package_name, settings in package_settings.items(): self.package_settings[package_name].update(settings) <|fim▁end|>
package_settings_values
<|file_name|>profile.py<|end_file_name|><|fim▁begin|>import copy from collections import OrderedDict from collections import defaultdict from conans.model.env_info import EnvValues from conans.model.options import OptionsValues from conans.model.values import Values class Profile(object): """A profile contains a set of setting (with values), environment variables """ def __init__(self): # Sections self.settings = OrderedDict() self.package_settings = defaultdict(OrderedDict) self.env_values = EnvValues() self.options = OptionsValues() self.build_requires = OrderedDict() # conan_ref Pattern: list of conan_ref @property def settings_values(self): return Values.from_list(list(self.settings.items())) @property def package_settings_values(self): result = {} for pkg, settings in self.package_settings.items(): result[pkg] = list(settings.items()) return result def <|fim_middle|>(self): result = ["[settings]"] for name, value in self.settings.items(): result.append("%s=%s" % (name, value)) for package, values in self.package_settings.items(): for name, value in values.items(): result.append("%s:%s=%s" % (package, name, value)) result.append("[options]") result.append(self.options.dumps()) result.append("[build_requires]") for pattern, req_list in self.build_requires.items(): result.append("%s: %s" % (pattern, ", ".join(str(r) for r in req_list))) result.append("[env]") result.append(self.env_values.dumps()) return "\n".join(result).replace("\n\n", "\n") def update(self, other): self.update_settings(other.settings) self.update_package_settings(other.package_settings) # this is the opposite other.env_values.update(self.env_values) self.env_values = other.env_values self.options.update(other.options) for pattern, req_list in other.build_requires.items(): self.build_requires.setdefault(pattern, []).extend(req_list) def update_settings(self, new_settings): """Mix the specified settings with the current profile. Specified settings are prioritized to profile""" assert(isinstance(new_settings, OrderedDict)) # apply the current profile res = copy.copy(self.settings) if new_settings: # Invalidate the current subsettings if the parent setting changes # Example: new_settings declare a different "compiler", so invalidate the current "compiler.XXX" for name, value in new_settings.items(): if "." not in name: if name in self.settings and self.settings[name] != value: for cur_name, _ in self.settings.items(): if cur_name.startswith("%s." % name): del res[cur_name] # Now merge the new values res.update(new_settings) self.settings = res def update_package_settings(self, package_settings): """Mix the specified package settings with the specified profile. Specified package settings are prioritized to profile""" for package_name, settings in package_settings.items(): self.package_settings[package_name].update(settings) <|fim▁end|>
dumps
<|file_name|>profile.py<|end_file_name|><|fim▁begin|>import copy from collections import OrderedDict from collections import defaultdict from conans.model.env_info import EnvValues from conans.model.options import OptionsValues from conans.model.values import Values class Profile(object): """A profile contains a set of setting (with values), environment variables """ def __init__(self): # Sections self.settings = OrderedDict() self.package_settings = defaultdict(OrderedDict) self.env_values = EnvValues() self.options = OptionsValues() self.build_requires = OrderedDict() # conan_ref Pattern: list of conan_ref @property def settings_values(self): return Values.from_list(list(self.settings.items())) @property def package_settings_values(self): result = {} for pkg, settings in self.package_settings.items(): result[pkg] = list(settings.items()) return result def dumps(self): result = ["[settings]"] for name, value in self.settings.items(): result.append("%s=%s" % (name, value)) for package, values in self.package_settings.items(): for name, value in values.items(): result.append("%s:%s=%s" % (package, name, value)) result.append("[options]") result.append(self.options.dumps()) result.append("[build_requires]") for pattern, req_list in self.build_requires.items(): result.append("%s: %s" % (pattern, ", ".join(str(r) for r in req_list))) result.append("[env]") result.append(self.env_values.dumps()) return "\n".join(result).replace("\n\n", "\n") def <|fim_middle|>(self, other): self.update_settings(other.settings) self.update_package_settings(other.package_settings) # this is the opposite other.env_values.update(self.env_values) self.env_values = other.env_values self.options.update(other.options) for pattern, req_list in other.build_requires.items(): self.build_requires.setdefault(pattern, []).extend(req_list) def update_settings(self, new_settings): """Mix the specified settings with the current profile. Specified settings are prioritized to profile""" assert(isinstance(new_settings, OrderedDict)) # apply the current profile res = copy.copy(self.settings) if new_settings: # Invalidate the current subsettings if the parent setting changes # Example: new_settings declare a different "compiler", so invalidate the current "compiler.XXX" for name, value in new_settings.items(): if "." not in name: if name in self.settings and self.settings[name] != value: for cur_name, _ in self.settings.items(): if cur_name.startswith("%s." % name): del res[cur_name] # Now merge the new values res.update(new_settings) self.settings = res def update_package_settings(self, package_settings): """Mix the specified package settings with the specified profile. Specified package settings are prioritized to profile""" for package_name, settings in package_settings.items(): self.package_settings[package_name].update(settings) <|fim▁end|>
update
<|file_name|>profile.py<|end_file_name|><|fim▁begin|>import copy from collections import OrderedDict from collections import defaultdict from conans.model.env_info import EnvValues from conans.model.options import OptionsValues from conans.model.values import Values class Profile(object): """A profile contains a set of setting (with values), environment variables """ def __init__(self): # Sections self.settings = OrderedDict() self.package_settings = defaultdict(OrderedDict) self.env_values = EnvValues() self.options = OptionsValues() self.build_requires = OrderedDict() # conan_ref Pattern: list of conan_ref @property def settings_values(self): return Values.from_list(list(self.settings.items())) @property def package_settings_values(self): result = {} for pkg, settings in self.package_settings.items(): result[pkg] = list(settings.items()) return result def dumps(self): result = ["[settings]"] for name, value in self.settings.items(): result.append("%s=%s" % (name, value)) for package, values in self.package_settings.items(): for name, value in values.items(): result.append("%s:%s=%s" % (package, name, value)) result.append("[options]") result.append(self.options.dumps()) result.append("[build_requires]") for pattern, req_list in self.build_requires.items(): result.append("%s: %s" % (pattern, ", ".join(str(r) for r in req_list))) result.append("[env]") result.append(self.env_values.dumps()) return "\n".join(result).replace("\n\n", "\n") def update(self, other): self.update_settings(other.settings) self.update_package_settings(other.package_settings) # this is the opposite other.env_values.update(self.env_values) self.env_values = other.env_values self.options.update(other.options) for pattern, req_list in other.build_requires.items(): self.build_requires.setdefault(pattern, []).extend(req_list) def <|fim_middle|>(self, new_settings): """Mix the specified settings with the current profile. Specified settings are prioritized to profile""" assert(isinstance(new_settings, OrderedDict)) # apply the current profile res = copy.copy(self.settings) if new_settings: # Invalidate the current subsettings if the parent setting changes # Example: new_settings declare a different "compiler", so invalidate the current "compiler.XXX" for name, value in new_settings.items(): if "." not in name: if name in self.settings and self.settings[name] != value: for cur_name, _ in self.settings.items(): if cur_name.startswith("%s." % name): del res[cur_name] # Now merge the new values res.update(new_settings) self.settings = res def update_package_settings(self, package_settings): """Mix the specified package settings with the specified profile. Specified package settings are prioritized to profile""" for package_name, settings in package_settings.items(): self.package_settings[package_name].update(settings) <|fim▁end|>
update_settings
<|file_name|>profile.py<|end_file_name|><|fim▁begin|>import copy from collections import OrderedDict from collections import defaultdict from conans.model.env_info import EnvValues from conans.model.options import OptionsValues from conans.model.values import Values class Profile(object): """A profile contains a set of setting (with values), environment variables """ def __init__(self): # Sections self.settings = OrderedDict() self.package_settings = defaultdict(OrderedDict) self.env_values = EnvValues() self.options = OptionsValues() self.build_requires = OrderedDict() # conan_ref Pattern: list of conan_ref @property def settings_values(self): return Values.from_list(list(self.settings.items())) @property def package_settings_values(self): result = {} for pkg, settings in self.package_settings.items(): result[pkg] = list(settings.items()) return result def dumps(self): result = ["[settings]"] for name, value in self.settings.items(): result.append("%s=%s" % (name, value)) for package, values in self.package_settings.items(): for name, value in values.items(): result.append("%s:%s=%s" % (package, name, value)) result.append("[options]") result.append(self.options.dumps()) result.append("[build_requires]") for pattern, req_list in self.build_requires.items(): result.append("%s: %s" % (pattern, ", ".join(str(r) for r in req_list))) result.append("[env]") result.append(self.env_values.dumps()) return "\n".join(result).replace("\n\n", "\n") def update(self, other): self.update_settings(other.settings) self.update_package_settings(other.package_settings) # this is the opposite other.env_values.update(self.env_values) self.env_values = other.env_values self.options.update(other.options) for pattern, req_list in other.build_requires.items(): self.build_requires.setdefault(pattern, []).extend(req_list) def update_settings(self, new_settings): """Mix the specified settings with the current profile. Specified settings are prioritized to profile""" assert(isinstance(new_settings, OrderedDict)) # apply the current profile res = copy.copy(self.settings) if new_settings: # Invalidate the current subsettings if the parent setting changes # Example: new_settings declare a different "compiler", so invalidate the current "compiler.XXX" for name, value in new_settings.items(): if "." not in name: if name in self.settings and self.settings[name] != value: for cur_name, _ in self.settings.items(): if cur_name.startswith("%s." % name): del res[cur_name] # Now merge the new values res.update(new_settings) self.settings = res def <|fim_middle|>(self, package_settings): """Mix the specified package settings with the specified profile. Specified package settings are prioritized to profile""" for package_name, settings in package_settings.items(): self.package_settings[package_name].update(settings) <|fim▁end|>
update_package_settings
<|file_name|>__init__.py<|end_file_name|><|fim▁begin|>from __future__ import absolute_import # Copyright (c) 2010-2017 openpyxl from .cell import Cell, WriteOnlyCell<|fim▁hole|><|fim▁end|>
from .read_only import ReadOnlyCell
<|file_name|>del_cluster_systemlist.py<|end_file_name|><|fim▁begin|># -*- cpy-indent-level: 4; indent-tabs-mode: nil -*- # ex: set expandtab softtabstop=4 shiftwidth=4: # # Copyright (C) 2009,2010,2011,2012,2013,2014,2015,2016,2017 Contributor # # Licensed under the Apache License, Version 2.0 (the "License"); # you may not use this file except in compliance with the License. # You may obtain a copy of the License at # # http://www.apache.org/licenses/LICENSE-2.0 # # Unless required by applicable law or agreed to in writing, software # distributed under the License is distributed on an "AS IS" BASIS, # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. # See the License for the specific language governing permissions and # limitations under the License. """ Contains the logic for `aq del cluster systemlist --hostname`. """ <|fim▁hole|> class CommandDelClusterSystemList(CommandDelClusterMemberPriority): required_parameters = ["cluster", "hostname"] resource_class = SystemList def render(self, hostname, **kwargs): super(CommandDelClusterSystemList, self).render(hostname=None, metacluster=None, comments=None, member=hostname, **kwargs)<|fim▁end|>
from aquilon.aqdb.model import SystemList from aquilon.worker.broker import BrokerCommand # pylint: disable=W0611 from aquilon.worker.commands.del_cluster_member_priority import \ CommandDelClusterMemberPriority
<|file_name|>del_cluster_systemlist.py<|end_file_name|><|fim▁begin|># -*- cpy-indent-level: 4; indent-tabs-mode: nil -*- # ex: set expandtab softtabstop=4 shiftwidth=4: # # Copyright (C) 2009,2010,2011,2012,2013,2014,2015,2016,2017 Contributor # # Licensed under the Apache License, Version 2.0 (the "License"); # you may not use this file except in compliance with the License. # You may obtain a copy of the License at # # http://www.apache.org/licenses/LICENSE-2.0 # # Unless required by applicable law or agreed to in writing, software # distributed under the License is distributed on an "AS IS" BASIS, # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. # See the License for the specific language governing permissions and # limitations under the License. """ Contains the logic for `aq del cluster systemlist --hostname`. """ from aquilon.aqdb.model import SystemList from aquilon.worker.broker import BrokerCommand # pylint: disable=W0611 from aquilon.worker.commands.del_cluster_member_priority import \ CommandDelClusterMemberPriority class CommandDelClusterSystemList(CommandDelClusterMemberPriority): <|fim_middle|> <|fim▁end|>
required_parameters = ["cluster", "hostname"] resource_class = SystemList def render(self, hostname, **kwargs): super(CommandDelClusterSystemList, self).render(hostname=None, metacluster=None, comments=None, member=hostname, **kwargs)
<|file_name|>del_cluster_systemlist.py<|end_file_name|><|fim▁begin|># -*- cpy-indent-level: 4; indent-tabs-mode: nil -*- # ex: set expandtab softtabstop=4 shiftwidth=4: # # Copyright (C) 2009,2010,2011,2012,2013,2014,2015,2016,2017 Contributor # # Licensed under the Apache License, Version 2.0 (the "License"); # you may not use this file except in compliance with the License. # You may obtain a copy of the License at # # http://www.apache.org/licenses/LICENSE-2.0 # # Unless required by applicable law or agreed to in writing, software # distributed under the License is distributed on an "AS IS" BASIS, # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. # See the License for the specific language governing permissions and # limitations under the License. """ Contains the logic for `aq del cluster systemlist --hostname`. """ from aquilon.aqdb.model import SystemList from aquilon.worker.broker import BrokerCommand # pylint: disable=W0611 from aquilon.worker.commands.del_cluster_member_priority import \ CommandDelClusterMemberPriority class CommandDelClusterSystemList(CommandDelClusterMemberPriority): required_parameters = ["cluster", "hostname"] resource_class = SystemList def render(self, hostname, **kwargs): <|fim_middle|> <|fim▁end|>
super(CommandDelClusterSystemList, self).render(hostname=None, metacluster=None, comments=None, member=hostname, **kwargs)
<|file_name|>del_cluster_systemlist.py<|end_file_name|><|fim▁begin|># -*- cpy-indent-level: 4; indent-tabs-mode: nil -*- # ex: set expandtab softtabstop=4 shiftwidth=4: # # Copyright (C) 2009,2010,2011,2012,2013,2014,2015,2016,2017 Contributor # # Licensed under the Apache License, Version 2.0 (the "License"); # you may not use this file except in compliance with the License. # You may obtain a copy of the License at # # http://www.apache.org/licenses/LICENSE-2.0 # # Unless required by applicable law or agreed to in writing, software # distributed under the License is distributed on an "AS IS" BASIS, # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. # See the License for the specific language governing permissions and # limitations under the License. """ Contains the logic for `aq del cluster systemlist --hostname`. """ from aquilon.aqdb.model import SystemList from aquilon.worker.broker import BrokerCommand # pylint: disable=W0611 from aquilon.worker.commands.del_cluster_member_priority import \ CommandDelClusterMemberPriority class CommandDelClusterSystemList(CommandDelClusterMemberPriority): required_parameters = ["cluster", "hostname"] resource_class = SystemList def <|fim_middle|>(self, hostname, **kwargs): super(CommandDelClusterSystemList, self).render(hostname=None, metacluster=None, comments=None, member=hostname, **kwargs) <|fim▁end|>
render
<|file_name|>models.py<|end_file_name|><|fim▁begin|>from django.db.models import Transform from django.db.models import DateTimeField, TimeField from django.utils.functional import cached_property class TimeValue(Transform): lookup_name = 'time' function = 'time' def as_sql(self, compiler, connection): lhs, params = compiler.compile(self.lhs) return 'TIME({})'.format(lhs), params @cached_property def output_field(self): return TimeField() <|fim▁hole|><|fim▁end|>
DateTimeField.register_lookup(TimeValue)
<|file_name|>models.py<|end_file_name|><|fim▁begin|>from django.db.models import Transform from django.db.models import DateTimeField, TimeField from django.utils.functional import cached_property class TimeValue(Transform): <|fim_middle|> DateTimeField.register_lookup(TimeValue)<|fim▁end|>
lookup_name = 'time' function = 'time' def as_sql(self, compiler, connection): lhs, params = compiler.compile(self.lhs) return 'TIME({})'.format(lhs), params @cached_property def output_field(self): return TimeField()
<|file_name|>models.py<|end_file_name|><|fim▁begin|>from django.db.models import Transform from django.db.models import DateTimeField, TimeField from django.utils.functional import cached_property class TimeValue(Transform): lookup_name = 'time' function = 'time' def as_sql(self, compiler, connection): <|fim_middle|> @cached_property def output_field(self): return TimeField() DateTimeField.register_lookup(TimeValue)<|fim▁end|>
lhs, params = compiler.compile(self.lhs) return 'TIME({})'.format(lhs), params
<|file_name|>models.py<|end_file_name|><|fim▁begin|>from django.db.models import Transform from django.db.models import DateTimeField, TimeField from django.utils.functional import cached_property class TimeValue(Transform): lookup_name = 'time' function = 'time' def as_sql(self, compiler, connection): lhs, params = compiler.compile(self.lhs) return 'TIME({})'.format(lhs), params @cached_property def output_field(self): <|fim_middle|> DateTimeField.register_lookup(TimeValue)<|fim▁end|>
return TimeField()
<|file_name|>models.py<|end_file_name|><|fim▁begin|>from django.db.models import Transform from django.db.models import DateTimeField, TimeField from django.utils.functional import cached_property class TimeValue(Transform): lookup_name = 'time' function = 'time' def <|fim_middle|>(self, compiler, connection): lhs, params = compiler.compile(self.lhs) return 'TIME({})'.format(lhs), params @cached_property def output_field(self): return TimeField() DateTimeField.register_lookup(TimeValue)<|fim▁end|>
as_sql
<|file_name|>models.py<|end_file_name|><|fim▁begin|>from django.db.models import Transform from django.db.models import DateTimeField, TimeField from django.utils.functional import cached_property class TimeValue(Transform): lookup_name = 'time' function = 'time' def as_sql(self, compiler, connection): lhs, params = compiler.compile(self.lhs) return 'TIME({})'.format(lhs), params @cached_property def <|fim_middle|>(self): return TimeField() DateTimeField.register_lookup(TimeValue)<|fim▁end|>
output_field
<|file_name|>euctwprober.py<|end_file_name|><|fim▁begin|>######################## BEGIN LICENSE BLOCK ######################## # The Original Code is mozilla.org code. # # The Initial Developer of the Original Code is # Netscape Communications Corporation. # Portions created by the Initial Developer are Copyright (C) 1998 # the Initial Developer. All Rights Reserved. # # Contributor(s): # Mark Pilgrim - port to Python # # This library is free software; you can redistribute it and/or # modify it under the terms of the GNU Lesser General Public # License as published by the Free Software Foundation; either # version 2.1 of the License, or (at your option) any later version. # # This library is distributed in the hope that it will be useful, # but WITHOUT ANY WARRANTY; without even the implied warranty of # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU # Lesser General Public License for more details. # # You should have received a copy of the GNU Lesser General Public # License along with this library; if not, write to the Free Software # Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA # 02110-1301 USA ######################### END LICENSE BLOCK ######################### from .mbcharsetprober import MultiByteCharSetProber from .codingstatemachine import CodingStateMachine from .chardistribution import EUCTWDistributionAnalysis from .mbcssm import EUCTW_SM_MODEL class EUCTWProber(MultiByteCharSetProber): def __init__(self): super(EUCTWProber, self).__init__() self.coding_sm = CodingStateMachine(EUCTW_SM_MODEL) self.distribution_analyzer = EUCTWDistributionAnalysis() self.reset() <|fim▁hole|> @property def charset_name(self): return "EUC-TW" @property def language(self): return "Taiwan"<|fim▁end|>
<|file_name|>euctwprober.py<|end_file_name|><|fim▁begin|>######################## BEGIN LICENSE BLOCK ######################## # The Original Code is mozilla.org code. # # The Initial Developer of the Original Code is # Netscape Communications Corporation. # Portions created by the Initial Developer are Copyright (C) 1998 # the Initial Developer. All Rights Reserved. # # Contributor(s): # Mark Pilgrim - port to Python # # This library is free software; you can redistribute it and/or # modify it under the terms of the GNU Lesser General Public # License as published by the Free Software Foundation; either # version 2.1 of the License, or (at your option) any later version. # # This library is distributed in the hope that it will be useful, # but WITHOUT ANY WARRANTY; without even the implied warranty of # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU # Lesser General Public License for more details. # # You should have received a copy of the GNU Lesser General Public # License along with this library; if not, write to the Free Software # Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA # 02110-1301 USA ######################### END LICENSE BLOCK ######################### from .mbcharsetprober import MultiByteCharSetProber from .codingstatemachine import CodingStateMachine from .chardistribution import EUCTWDistributionAnalysis from .mbcssm import EUCTW_SM_MODEL class EUCTWProber(MultiByteCharSetProber): <|fim_middle|> <|fim▁end|>
def __init__(self): super(EUCTWProber, self).__init__() self.coding_sm = CodingStateMachine(EUCTW_SM_MODEL) self.distribution_analyzer = EUCTWDistributionAnalysis() self.reset() @property def charset_name(self): return "EUC-TW" @property def language(self): return "Taiwan"
<|file_name|>euctwprober.py<|end_file_name|><|fim▁begin|>######################## BEGIN LICENSE BLOCK ######################## # The Original Code is mozilla.org code. # # The Initial Developer of the Original Code is # Netscape Communications Corporation. # Portions created by the Initial Developer are Copyright (C) 1998 # the Initial Developer. All Rights Reserved. # # Contributor(s): # Mark Pilgrim - port to Python # # This library is free software; you can redistribute it and/or # modify it under the terms of the GNU Lesser General Public # License as published by the Free Software Foundation; either # version 2.1 of the License, or (at your option) any later version. # # This library is distributed in the hope that it will be useful, # but WITHOUT ANY WARRANTY; without even the implied warranty of # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU # Lesser General Public License for more details. # # You should have received a copy of the GNU Lesser General Public # License along with this library; if not, write to the Free Software # Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA # 02110-1301 USA ######################### END LICENSE BLOCK ######################### from .mbcharsetprober import MultiByteCharSetProber from .codingstatemachine import CodingStateMachine from .chardistribution import EUCTWDistributionAnalysis from .mbcssm import EUCTW_SM_MODEL class EUCTWProber(MultiByteCharSetProber): def __init__(self): <|fim_middle|> @property def charset_name(self): return "EUC-TW" @property def language(self): return "Taiwan" <|fim▁end|>
super(EUCTWProber, self).__init__() self.coding_sm = CodingStateMachine(EUCTW_SM_MODEL) self.distribution_analyzer = EUCTWDistributionAnalysis() self.reset()
<|file_name|>euctwprober.py<|end_file_name|><|fim▁begin|>######################## BEGIN LICENSE BLOCK ######################## # The Original Code is mozilla.org code. # # The Initial Developer of the Original Code is # Netscape Communications Corporation. # Portions created by the Initial Developer are Copyright (C) 1998 # the Initial Developer. All Rights Reserved. # # Contributor(s): # Mark Pilgrim - port to Python # # This library is free software; you can redistribute it and/or # modify it under the terms of the GNU Lesser General Public # License as published by the Free Software Foundation; either # version 2.1 of the License, or (at your option) any later version. # # This library is distributed in the hope that it will be useful, # but WITHOUT ANY WARRANTY; without even the implied warranty of # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU # Lesser General Public License for more details. # # You should have received a copy of the GNU Lesser General Public # License along with this library; if not, write to the Free Software # Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA # 02110-1301 USA ######################### END LICENSE BLOCK ######################### from .mbcharsetprober import MultiByteCharSetProber from .codingstatemachine import CodingStateMachine from .chardistribution import EUCTWDistributionAnalysis from .mbcssm import EUCTW_SM_MODEL class EUCTWProber(MultiByteCharSetProber): def __init__(self): super(EUCTWProber, self).__init__() self.coding_sm = CodingStateMachine(EUCTW_SM_MODEL) self.distribution_analyzer = EUCTWDistributionAnalysis() self.reset() @property def charset_name(self): <|fim_middle|> @property def language(self): return "Taiwan" <|fim▁end|>
return "EUC-TW"
<|file_name|>euctwprober.py<|end_file_name|><|fim▁begin|>######################## BEGIN LICENSE BLOCK ######################## # The Original Code is mozilla.org code. # # The Initial Developer of the Original Code is # Netscape Communications Corporation. # Portions created by the Initial Developer are Copyright (C) 1998 # the Initial Developer. All Rights Reserved. # # Contributor(s): # Mark Pilgrim - port to Python # # This library is free software; you can redistribute it and/or # modify it under the terms of the GNU Lesser General Public # License as published by the Free Software Foundation; either # version 2.1 of the License, or (at your option) any later version. # # This library is distributed in the hope that it will be useful, # but WITHOUT ANY WARRANTY; without even the implied warranty of # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU # Lesser General Public License for more details. # # You should have received a copy of the GNU Lesser General Public # License along with this library; if not, write to the Free Software # Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA # 02110-1301 USA ######################### END LICENSE BLOCK ######################### from .mbcharsetprober import MultiByteCharSetProber from .codingstatemachine import CodingStateMachine from .chardistribution import EUCTWDistributionAnalysis from .mbcssm import EUCTW_SM_MODEL class EUCTWProber(MultiByteCharSetProber): def __init__(self): super(EUCTWProber, self).__init__() self.coding_sm = CodingStateMachine(EUCTW_SM_MODEL) self.distribution_analyzer = EUCTWDistributionAnalysis() self.reset() @property def charset_name(self): return "EUC-TW" @property def language(self): <|fim_middle|> <|fim▁end|>
return "Taiwan"
<|file_name|>euctwprober.py<|end_file_name|><|fim▁begin|>######################## BEGIN LICENSE BLOCK ######################## # The Original Code is mozilla.org code. # # The Initial Developer of the Original Code is # Netscape Communications Corporation. # Portions created by the Initial Developer are Copyright (C) 1998 # the Initial Developer. All Rights Reserved. # # Contributor(s): # Mark Pilgrim - port to Python # # This library is free software; you can redistribute it and/or # modify it under the terms of the GNU Lesser General Public # License as published by the Free Software Foundation; either # version 2.1 of the License, or (at your option) any later version. # # This library is distributed in the hope that it will be useful, # but WITHOUT ANY WARRANTY; without even the implied warranty of # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU # Lesser General Public License for more details. # # You should have received a copy of the GNU Lesser General Public # License along with this library; if not, write to the Free Software # Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA # 02110-1301 USA ######################### END LICENSE BLOCK ######################### from .mbcharsetprober import MultiByteCharSetProber from .codingstatemachine import CodingStateMachine from .chardistribution import EUCTWDistributionAnalysis from .mbcssm import EUCTW_SM_MODEL class EUCTWProber(MultiByteCharSetProber): def <|fim_middle|>(self): super(EUCTWProber, self).__init__() self.coding_sm = CodingStateMachine(EUCTW_SM_MODEL) self.distribution_analyzer = EUCTWDistributionAnalysis() self.reset() @property def charset_name(self): return "EUC-TW" @property def language(self): return "Taiwan" <|fim▁end|>
__init__
<|file_name|>euctwprober.py<|end_file_name|><|fim▁begin|>######################## BEGIN LICENSE BLOCK ######################## # The Original Code is mozilla.org code. # # The Initial Developer of the Original Code is # Netscape Communications Corporation. # Portions created by the Initial Developer are Copyright (C) 1998 # the Initial Developer. All Rights Reserved. # # Contributor(s): # Mark Pilgrim - port to Python # # This library is free software; you can redistribute it and/or # modify it under the terms of the GNU Lesser General Public # License as published by the Free Software Foundation; either # version 2.1 of the License, or (at your option) any later version. # # This library is distributed in the hope that it will be useful, # but WITHOUT ANY WARRANTY; without even the implied warranty of # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU # Lesser General Public License for more details. # # You should have received a copy of the GNU Lesser General Public # License along with this library; if not, write to the Free Software # Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA # 02110-1301 USA ######################### END LICENSE BLOCK ######################### from .mbcharsetprober import MultiByteCharSetProber from .codingstatemachine import CodingStateMachine from .chardistribution import EUCTWDistributionAnalysis from .mbcssm import EUCTW_SM_MODEL class EUCTWProber(MultiByteCharSetProber): def __init__(self): super(EUCTWProber, self).__init__() self.coding_sm = CodingStateMachine(EUCTW_SM_MODEL) self.distribution_analyzer = EUCTWDistributionAnalysis() self.reset() @property def <|fim_middle|>(self): return "EUC-TW" @property def language(self): return "Taiwan" <|fim▁end|>
charset_name
<|file_name|>euctwprober.py<|end_file_name|><|fim▁begin|>######################## BEGIN LICENSE BLOCK ######################## # The Original Code is mozilla.org code. # # The Initial Developer of the Original Code is # Netscape Communications Corporation. # Portions created by the Initial Developer are Copyright (C) 1998 # the Initial Developer. All Rights Reserved. # # Contributor(s): # Mark Pilgrim - port to Python # # This library is free software; you can redistribute it and/or # modify it under the terms of the GNU Lesser General Public # License as published by the Free Software Foundation; either # version 2.1 of the License, or (at your option) any later version. # # This library is distributed in the hope that it will be useful, # but WITHOUT ANY WARRANTY; without even the implied warranty of # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU # Lesser General Public License for more details. # # You should have received a copy of the GNU Lesser General Public # License along with this library; if not, write to the Free Software # Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA # 02110-1301 USA ######################### END LICENSE BLOCK ######################### from .mbcharsetprober import MultiByteCharSetProber from .codingstatemachine import CodingStateMachine from .chardistribution import EUCTWDistributionAnalysis from .mbcssm import EUCTW_SM_MODEL class EUCTWProber(MultiByteCharSetProber): def __init__(self): super(EUCTWProber, self).__init__() self.coding_sm = CodingStateMachine(EUCTW_SM_MODEL) self.distribution_analyzer = EUCTWDistributionAnalysis() self.reset() @property def charset_name(self): return "EUC-TW" @property def <|fim_middle|>(self): return "Taiwan" <|fim▁end|>
language
<|file_name|>plot_error.py<|end_file_name|><|fim▁begin|>from matplotlib import pyplot as plt path = "C:/Temp/mnisterrors/chunk" + str(input("chunk: ")) + ".txt" <|fim▁hole|>plt.plot(errorhistory) plt.show()<|fim▁end|>
with open(path, "r") as f: errorhistory = [float(line.rstrip('\n')) for line in f]
<|file_name|>summary_key_matcher.py<|end_file_name|><|fim▁begin|>from ert.cwrap import CWrapper, BaseCClass from ert.enkf import ENKF_LIB from ert.util import StringList class SummaryKeyMatcher(BaseCClass): def __init__(self): c_ptr = SummaryKeyMatcher.cNamespace().alloc() super(SummaryKeyMatcher, self).__init__(c_ptr) def addSummaryKey(self, key): assert isinstance(key, str) return SummaryKeyMatcher.cNamespace().add_key(self, key) def __len__(self): return SummaryKeyMatcher.cNamespace().size(self) def __contains__(self, key): return SummaryKeyMatcher.cNamespace().match_key(self, key) def isRequired(self, key): """ @rtype: bool """ return SummaryKeyMatcher.cNamespace().is_required(self, key) def keys(self): """ @rtype: StringList """ return SummaryKeyMatcher.cNamespace().keys(self)<|fim▁hole|> def free(self): SummaryKeyMatcher.cNamespace().free(self) cwrapper = CWrapper(ENKF_LIB) cwrapper.registerObjectType("summary_key_matcher", SummaryKeyMatcher) SummaryKeyMatcher.cNamespace().alloc = cwrapper.prototype("c_void_p summary_key_matcher_alloc()") SummaryKeyMatcher.cNamespace().free = cwrapper.prototype("void summary_key_matcher_free(summary_key_matcher)") SummaryKeyMatcher.cNamespace().size = cwrapper.prototype("int summary_key_matcher_get_size(summary_key_matcher)") SummaryKeyMatcher.cNamespace().add_key = cwrapper.prototype("void summary_key_matcher_add_summary_key(summary_key_matcher, char*)") SummaryKeyMatcher.cNamespace().match_key = cwrapper.prototype("bool summary_key_matcher_match_summary_key(summary_key_matcher, char*)") SummaryKeyMatcher.cNamespace().keys = cwrapper.prototype("stringlist_obj summary_key_matcher_get_keys(summary_key_matcher)") SummaryKeyMatcher.cNamespace().is_required = cwrapper.prototype("bool summary_key_matcher_summary_key_is_required(summary_key_matcher, char*)")<|fim▁end|>
<|file_name|>summary_key_matcher.py<|end_file_name|><|fim▁begin|>from ert.cwrap import CWrapper, BaseCClass from ert.enkf import ENKF_LIB from ert.util import StringList class SummaryKeyMatcher(BaseCClass): <|fim_middle|> cwrapper = CWrapper(ENKF_LIB) cwrapper.registerObjectType("summary_key_matcher", SummaryKeyMatcher) SummaryKeyMatcher.cNamespace().alloc = cwrapper.prototype("c_void_p summary_key_matcher_alloc()") SummaryKeyMatcher.cNamespace().free = cwrapper.prototype("void summary_key_matcher_free(summary_key_matcher)") SummaryKeyMatcher.cNamespace().size = cwrapper.prototype("int summary_key_matcher_get_size(summary_key_matcher)") SummaryKeyMatcher.cNamespace().add_key = cwrapper.prototype("void summary_key_matcher_add_summary_key(summary_key_matcher, char*)") SummaryKeyMatcher.cNamespace().match_key = cwrapper.prototype("bool summary_key_matcher_match_summary_key(summary_key_matcher, char*)") SummaryKeyMatcher.cNamespace().keys = cwrapper.prototype("stringlist_obj summary_key_matcher_get_keys(summary_key_matcher)") SummaryKeyMatcher.cNamespace().is_required = cwrapper.prototype("bool summary_key_matcher_summary_key_is_required(summary_key_matcher, char*)") <|fim▁end|>
def __init__(self): c_ptr = SummaryKeyMatcher.cNamespace().alloc() super(SummaryKeyMatcher, self).__init__(c_ptr) def addSummaryKey(self, key): assert isinstance(key, str) return SummaryKeyMatcher.cNamespace().add_key(self, key) def __len__(self): return SummaryKeyMatcher.cNamespace().size(self) def __contains__(self, key): return SummaryKeyMatcher.cNamespace().match_key(self, key) def isRequired(self, key): """ @rtype: bool """ return SummaryKeyMatcher.cNamespace().is_required(self, key) def keys(self): """ @rtype: StringList """ return SummaryKeyMatcher.cNamespace().keys(self) def free(self): SummaryKeyMatcher.cNamespace().free(self)
<|file_name|>summary_key_matcher.py<|end_file_name|><|fim▁begin|>from ert.cwrap import CWrapper, BaseCClass from ert.enkf import ENKF_LIB from ert.util import StringList class SummaryKeyMatcher(BaseCClass): def __init__(self): <|fim_middle|> def addSummaryKey(self, key): assert isinstance(key, str) return SummaryKeyMatcher.cNamespace().add_key(self, key) def __len__(self): return SummaryKeyMatcher.cNamespace().size(self) def __contains__(self, key): return SummaryKeyMatcher.cNamespace().match_key(self, key) def isRequired(self, key): """ @rtype: bool """ return SummaryKeyMatcher.cNamespace().is_required(self, key) def keys(self): """ @rtype: StringList """ return SummaryKeyMatcher.cNamespace().keys(self) def free(self): SummaryKeyMatcher.cNamespace().free(self) cwrapper = CWrapper(ENKF_LIB) cwrapper.registerObjectType("summary_key_matcher", SummaryKeyMatcher) SummaryKeyMatcher.cNamespace().alloc = cwrapper.prototype("c_void_p summary_key_matcher_alloc()") SummaryKeyMatcher.cNamespace().free = cwrapper.prototype("void summary_key_matcher_free(summary_key_matcher)") SummaryKeyMatcher.cNamespace().size = cwrapper.prototype("int summary_key_matcher_get_size(summary_key_matcher)") SummaryKeyMatcher.cNamespace().add_key = cwrapper.prototype("void summary_key_matcher_add_summary_key(summary_key_matcher, char*)") SummaryKeyMatcher.cNamespace().match_key = cwrapper.prototype("bool summary_key_matcher_match_summary_key(summary_key_matcher, char*)") SummaryKeyMatcher.cNamespace().keys = cwrapper.prototype("stringlist_obj summary_key_matcher_get_keys(summary_key_matcher)") SummaryKeyMatcher.cNamespace().is_required = cwrapper.prototype("bool summary_key_matcher_summary_key_is_required(summary_key_matcher, char*)") <|fim▁end|>
c_ptr = SummaryKeyMatcher.cNamespace().alloc() super(SummaryKeyMatcher, self).__init__(c_ptr)
<|file_name|>summary_key_matcher.py<|end_file_name|><|fim▁begin|>from ert.cwrap import CWrapper, BaseCClass from ert.enkf import ENKF_LIB from ert.util import StringList class SummaryKeyMatcher(BaseCClass): def __init__(self): c_ptr = SummaryKeyMatcher.cNamespace().alloc() super(SummaryKeyMatcher, self).__init__(c_ptr) def addSummaryKey(self, key): <|fim_middle|> def __len__(self): return SummaryKeyMatcher.cNamespace().size(self) def __contains__(self, key): return SummaryKeyMatcher.cNamespace().match_key(self, key) def isRequired(self, key): """ @rtype: bool """ return SummaryKeyMatcher.cNamespace().is_required(self, key) def keys(self): """ @rtype: StringList """ return SummaryKeyMatcher.cNamespace().keys(self) def free(self): SummaryKeyMatcher.cNamespace().free(self) cwrapper = CWrapper(ENKF_LIB) cwrapper.registerObjectType("summary_key_matcher", SummaryKeyMatcher) SummaryKeyMatcher.cNamespace().alloc = cwrapper.prototype("c_void_p summary_key_matcher_alloc()") SummaryKeyMatcher.cNamespace().free = cwrapper.prototype("void summary_key_matcher_free(summary_key_matcher)") SummaryKeyMatcher.cNamespace().size = cwrapper.prototype("int summary_key_matcher_get_size(summary_key_matcher)") SummaryKeyMatcher.cNamespace().add_key = cwrapper.prototype("void summary_key_matcher_add_summary_key(summary_key_matcher, char*)") SummaryKeyMatcher.cNamespace().match_key = cwrapper.prototype("bool summary_key_matcher_match_summary_key(summary_key_matcher, char*)") SummaryKeyMatcher.cNamespace().keys = cwrapper.prototype("stringlist_obj summary_key_matcher_get_keys(summary_key_matcher)") SummaryKeyMatcher.cNamespace().is_required = cwrapper.prototype("bool summary_key_matcher_summary_key_is_required(summary_key_matcher, char*)") <|fim▁end|>
assert isinstance(key, str) return SummaryKeyMatcher.cNamespace().add_key(self, key)
<|file_name|>summary_key_matcher.py<|end_file_name|><|fim▁begin|>from ert.cwrap import CWrapper, BaseCClass from ert.enkf import ENKF_LIB from ert.util import StringList class SummaryKeyMatcher(BaseCClass): def __init__(self): c_ptr = SummaryKeyMatcher.cNamespace().alloc() super(SummaryKeyMatcher, self).__init__(c_ptr) def addSummaryKey(self, key): assert isinstance(key, str) return SummaryKeyMatcher.cNamespace().add_key(self, key) def __len__(self): <|fim_middle|> def __contains__(self, key): return SummaryKeyMatcher.cNamespace().match_key(self, key) def isRequired(self, key): """ @rtype: bool """ return SummaryKeyMatcher.cNamespace().is_required(self, key) def keys(self): """ @rtype: StringList """ return SummaryKeyMatcher.cNamespace().keys(self) def free(self): SummaryKeyMatcher.cNamespace().free(self) cwrapper = CWrapper(ENKF_LIB) cwrapper.registerObjectType("summary_key_matcher", SummaryKeyMatcher) SummaryKeyMatcher.cNamespace().alloc = cwrapper.prototype("c_void_p summary_key_matcher_alloc()") SummaryKeyMatcher.cNamespace().free = cwrapper.prototype("void summary_key_matcher_free(summary_key_matcher)") SummaryKeyMatcher.cNamespace().size = cwrapper.prototype("int summary_key_matcher_get_size(summary_key_matcher)") SummaryKeyMatcher.cNamespace().add_key = cwrapper.prototype("void summary_key_matcher_add_summary_key(summary_key_matcher, char*)") SummaryKeyMatcher.cNamespace().match_key = cwrapper.prototype("bool summary_key_matcher_match_summary_key(summary_key_matcher, char*)") SummaryKeyMatcher.cNamespace().keys = cwrapper.prototype("stringlist_obj summary_key_matcher_get_keys(summary_key_matcher)") SummaryKeyMatcher.cNamespace().is_required = cwrapper.prototype("bool summary_key_matcher_summary_key_is_required(summary_key_matcher, char*)") <|fim▁end|>
return SummaryKeyMatcher.cNamespace().size(self)
<|file_name|>summary_key_matcher.py<|end_file_name|><|fim▁begin|>from ert.cwrap import CWrapper, BaseCClass from ert.enkf import ENKF_LIB from ert.util import StringList class SummaryKeyMatcher(BaseCClass): def __init__(self): c_ptr = SummaryKeyMatcher.cNamespace().alloc() super(SummaryKeyMatcher, self).__init__(c_ptr) def addSummaryKey(self, key): assert isinstance(key, str) return SummaryKeyMatcher.cNamespace().add_key(self, key) def __len__(self): return SummaryKeyMatcher.cNamespace().size(self) def __contains__(self, key): <|fim_middle|> def isRequired(self, key): """ @rtype: bool """ return SummaryKeyMatcher.cNamespace().is_required(self, key) def keys(self): """ @rtype: StringList """ return SummaryKeyMatcher.cNamespace().keys(self) def free(self): SummaryKeyMatcher.cNamespace().free(self) cwrapper = CWrapper(ENKF_LIB) cwrapper.registerObjectType("summary_key_matcher", SummaryKeyMatcher) SummaryKeyMatcher.cNamespace().alloc = cwrapper.prototype("c_void_p summary_key_matcher_alloc()") SummaryKeyMatcher.cNamespace().free = cwrapper.prototype("void summary_key_matcher_free(summary_key_matcher)") SummaryKeyMatcher.cNamespace().size = cwrapper.prototype("int summary_key_matcher_get_size(summary_key_matcher)") SummaryKeyMatcher.cNamespace().add_key = cwrapper.prototype("void summary_key_matcher_add_summary_key(summary_key_matcher, char*)") SummaryKeyMatcher.cNamespace().match_key = cwrapper.prototype("bool summary_key_matcher_match_summary_key(summary_key_matcher, char*)") SummaryKeyMatcher.cNamespace().keys = cwrapper.prototype("stringlist_obj summary_key_matcher_get_keys(summary_key_matcher)") SummaryKeyMatcher.cNamespace().is_required = cwrapper.prototype("bool summary_key_matcher_summary_key_is_required(summary_key_matcher, char*)") <|fim▁end|>
return SummaryKeyMatcher.cNamespace().match_key(self, key)
<|file_name|>summary_key_matcher.py<|end_file_name|><|fim▁begin|>from ert.cwrap import CWrapper, BaseCClass from ert.enkf import ENKF_LIB from ert.util import StringList class SummaryKeyMatcher(BaseCClass): def __init__(self): c_ptr = SummaryKeyMatcher.cNamespace().alloc() super(SummaryKeyMatcher, self).__init__(c_ptr) def addSummaryKey(self, key): assert isinstance(key, str) return SummaryKeyMatcher.cNamespace().add_key(self, key) def __len__(self): return SummaryKeyMatcher.cNamespace().size(self) def __contains__(self, key): return SummaryKeyMatcher.cNamespace().match_key(self, key) def isRequired(self, key): <|fim_middle|> def keys(self): """ @rtype: StringList """ return SummaryKeyMatcher.cNamespace().keys(self) def free(self): SummaryKeyMatcher.cNamespace().free(self) cwrapper = CWrapper(ENKF_LIB) cwrapper.registerObjectType("summary_key_matcher", SummaryKeyMatcher) SummaryKeyMatcher.cNamespace().alloc = cwrapper.prototype("c_void_p summary_key_matcher_alloc()") SummaryKeyMatcher.cNamespace().free = cwrapper.prototype("void summary_key_matcher_free(summary_key_matcher)") SummaryKeyMatcher.cNamespace().size = cwrapper.prototype("int summary_key_matcher_get_size(summary_key_matcher)") SummaryKeyMatcher.cNamespace().add_key = cwrapper.prototype("void summary_key_matcher_add_summary_key(summary_key_matcher, char*)") SummaryKeyMatcher.cNamespace().match_key = cwrapper.prototype("bool summary_key_matcher_match_summary_key(summary_key_matcher, char*)") SummaryKeyMatcher.cNamespace().keys = cwrapper.prototype("stringlist_obj summary_key_matcher_get_keys(summary_key_matcher)") SummaryKeyMatcher.cNamespace().is_required = cwrapper.prototype("bool summary_key_matcher_summary_key_is_required(summary_key_matcher, char*)") <|fim▁end|>
""" @rtype: bool """ return SummaryKeyMatcher.cNamespace().is_required(self, key)
<|file_name|>summary_key_matcher.py<|end_file_name|><|fim▁begin|>from ert.cwrap import CWrapper, BaseCClass from ert.enkf import ENKF_LIB from ert.util import StringList class SummaryKeyMatcher(BaseCClass): def __init__(self): c_ptr = SummaryKeyMatcher.cNamespace().alloc() super(SummaryKeyMatcher, self).__init__(c_ptr) def addSummaryKey(self, key): assert isinstance(key, str) return SummaryKeyMatcher.cNamespace().add_key(self, key) def __len__(self): return SummaryKeyMatcher.cNamespace().size(self) def __contains__(self, key): return SummaryKeyMatcher.cNamespace().match_key(self, key) def isRequired(self, key): """ @rtype: bool """ return SummaryKeyMatcher.cNamespace().is_required(self, key) def keys(self): <|fim_middle|> def free(self): SummaryKeyMatcher.cNamespace().free(self) cwrapper = CWrapper(ENKF_LIB) cwrapper.registerObjectType("summary_key_matcher", SummaryKeyMatcher) SummaryKeyMatcher.cNamespace().alloc = cwrapper.prototype("c_void_p summary_key_matcher_alloc()") SummaryKeyMatcher.cNamespace().free = cwrapper.prototype("void summary_key_matcher_free(summary_key_matcher)") SummaryKeyMatcher.cNamespace().size = cwrapper.prototype("int summary_key_matcher_get_size(summary_key_matcher)") SummaryKeyMatcher.cNamespace().add_key = cwrapper.prototype("void summary_key_matcher_add_summary_key(summary_key_matcher, char*)") SummaryKeyMatcher.cNamespace().match_key = cwrapper.prototype("bool summary_key_matcher_match_summary_key(summary_key_matcher, char*)") SummaryKeyMatcher.cNamespace().keys = cwrapper.prototype("stringlist_obj summary_key_matcher_get_keys(summary_key_matcher)") SummaryKeyMatcher.cNamespace().is_required = cwrapper.prototype("bool summary_key_matcher_summary_key_is_required(summary_key_matcher, char*)") <|fim▁end|>
""" @rtype: StringList """ return SummaryKeyMatcher.cNamespace().keys(self)
<|file_name|>summary_key_matcher.py<|end_file_name|><|fim▁begin|>from ert.cwrap import CWrapper, BaseCClass from ert.enkf import ENKF_LIB from ert.util import StringList class SummaryKeyMatcher(BaseCClass): def __init__(self): c_ptr = SummaryKeyMatcher.cNamespace().alloc() super(SummaryKeyMatcher, self).__init__(c_ptr) def addSummaryKey(self, key): assert isinstance(key, str) return SummaryKeyMatcher.cNamespace().add_key(self, key) def __len__(self): return SummaryKeyMatcher.cNamespace().size(self) def __contains__(self, key): return SummaryKeyMatcher.cNamespace().match_key(self, key) def isRequired(self, key): """ @rtype: bool """ return SummaryKeyMatcher.cNamespace().is_required(self, key) def keys(self): """ @rtype: StringList """ return SummaryKeyMatcher.cNamespace().keys(self) def free(self): <|fim_middle|> cwrapper = CWrapper(ENKF_LIB) cwrapper.registerObjectType("summary_key_matcher", SummaryKeyMatcher) SummaryKeyMatcher.cNamespace().alloc = cwrapper.prototype("c_void_p summary_key_matcher_alloc()") SummaryKeyMatcher.cNamespace().free = cwrapper.prototype("void summary_key_matcher_free(summary_key_matcher)") SummaryKeyMatcher.cNamespace().size = cwrapper.prototype("int summary_key_matcher_get_size(summary_key_matcher)") SummaryKeyMatcher.cNamespace().add_key = cwrapper.prototype("void summary_key_matcher_add_summary_key(summary_key_matcher, char*)") SummaryKeyMatcher.cNamespace().match_key = cwrapper.prototype("bool summary_key_matcher_match_summary_key(summary_key_matcher, char*)") SummaryKeyMatcher.cNamespace().keys = cwrapper.prototype("stringlist_obj summary_key_matcher_get_keys(summary_key_matcher)") SummaryKeyMatcher.cNamespace().is_required = cwrapper.prototype("bool summary_key_matcher_summary_key_is_required(summary_key_matcher, char*)") <|fim▁end|>
SummaryKeyMatcher.cNamespace().free(self)
<|file_name|>summary_key_matcher.py<|end_file_name|><|fim▁begin|>from ert.cwrap import CWrapper, BaseCClass from ert.enkf import ENKF_LIB from ert.util import StringList class SummaryKeyMatcher(BaseCClass): def <|fim_middle|>(self): c_ptr = SummaryKeyMatcher.cNamespace().alloc() super(SummaryKeyMatcher, self).__init__(c_ptr) def addSummaryKey(self, key): assert isinstance(key, str) return SummaryKeyMatcher.cNamespace().add_key(self, key) def __len__(self): return SummaryKeyMatcher.cNamespace().size(self) def __contains__(self, key): return SummaryKeyMatcher.cNamespace().match_key(self, key) def isRequired(self, key): """ @rtype: bool """ return SummaryKeyMatcher.cNamespace().is_required(self, key) def keys(self): """ @rtype: StringList """ return SummaryKeyMatcher.cNamespace().keys(self) def free(self): SummaryKeyMatcher.cNamespace().free(self) cwrapper = CWrapper(ENKF_LIB) cwrapper.registerObjectType("summary_key_matcher", SummaryKeyMatcher) SummaryKeyMatcher.cNamespace().alloc = cwrapper.prototype("c_void_p summary_key_matcher_alloc()") SummaryKeyMatcher.cNamespace().free = cwrapper.prototype("void summary_key_matcher_free(summary_key_matcher)") SummaryKeyMatcher.cNamespace().size = cwrapper.prototype("int summary_key_matcher_get_size(summary_key_matcher)") SummaryKeyMatcher.cNamespace().add_key = cwrapper.prototype("void summary_key_matcher_add_summary_key(summary_key_matcher, char*)") SummaryKeyMatcher.cNamespace().match_key = cwrapper.prototype("bool summary_key_matcher_match_summary_key(summary_key_matcher, char*)") SummaryKeyMatcher.cNamespace().keys = cwrapper.prototype("stringlist_obj summary_key_matcher_get_keys(summary_key_matcher)") SummaryKeyMatcher.cNamespace().is_required = cwrapper.prototype("bool summary_key_matcher_summary_key_is_required(summary_key_matcher, char*)") <|fim▁end|>
__init__
<|file_name|>summary_key_matcher.py<|end_file_name|><|fim▁begin|>from ert.cwrap import CWrapper, BaseCClass from ert.enkf import ENKF_LIB from ert.util import StringList class SummaryKeyMatcher(BaseCClass): def __init__(self): c_ptr = SummaryKeyMatcher.cNamespace().alloc() super(SummaryKeyMatcher, self).__init__(c_ptr) def <|fim_middle|>(self, key): assert isinstance(key, str) return SummaryKeyMatcher.cNamespace().add_key(self, key) def __len__(self): return SummaryKeyMatcher.cNamespace().size(self) def __contains__(self, key): return SummaryKeyMatcher.cNamespace().match_key(self, key) def isRequired(self, key): """ @rtype: bool """ return SummaryKeyMatcher.cNamespace().is_required(self, key) def keys(self): """ @rtype: StringList """ return SummaryKeyMatcher.cNamespace().keys(self) def free(self): SummaryKeyMatcher.cNamespace().free(self) cwrapper = CWrapper(ENKF_LIB) cwrapper.registerObjectType("summary_key_matcher", SummaryKeyMatcher) SummaryKeyMatcher.cNamespace().alloc = cwrapper.prototype("c_void_p summary_key_matcher_alloc()") SummaryKeyMatcher.cNamespace().free = cwrapper.prototype("void summary_key_matcher_free(summary_key_matcher)") SummaryKeyMatcher.cNamespace().size = cwrapper.prototype("int summary_key_matcher_get_size(summary_key_matcher)") SummaryKeyMatcher.cNamespace().add_key = cwrapper.prototype("void summary_key_matcher_add_summary_key(summary_key_matcher, char*)") SummaryKeyMatcher.cNamespace().match_key = cwrapper.prototype("bool summary_key_matcher_match_summary_key(summary_key_matcher, char*)") SummaryKeyMatcher.cNamespace().keys = cwrapper.prototype("stringlist_obj summary_key_matcher_get_keys(summary_key_matcher)") SummaryKeyMatcher.cNamespace().is_required = cwrapper.prototype("bool summary_key_matcher_summary_key_is_required(summary_key_matcher, char*)") <|fim▁end|>
addSummaryKey
<|file_name|>summary_key_matcher.py<|end_file_name|><|fim▁begin|>from ert.cwrap import CWrapper, BaseCClass from ert.enkf import ENKF_LIB from ert.util import StringList class SummaryKeyMatcher(BaseCClass): def __init__(self): c_ptr = SummaryKeyMatcher.cNamespace().alloc() super(SummaryKeyMatcher, self).__init__(c_ptr) def addSummaryKey(self, key): assert isinstance(key, str) return SummaryKeyMatcher.cNamespace().add_key(self, key) def <|fim_middle|>(self): return SummaryKeyMatcher.cNamespace().size(self) def __contains__(self, key): return SummaryKeyMatcher.cNamespace().match_key(self, key) def isRequired(self, key): """ @rtype: bool """ return SummaryKeyMatcher.cNamespace().is_required(self, key) def keys(self): """ @rtype: StringList """ return SummaryKeyMatcher.cNamespace().keys(self) def free(self): SummaryKeyMatcher.cNamespace().free(self) cwrapper = CWrapper(ENKF_LIB) cwrapper.registerObjectType("summary_key_matcher", SummaryKeyMatcher) SummaryKeyMatcher.cNamespace().alloc = cwrapper.prototype("c_void_p summary_key_matcher_alloc()") SummaryKeyMatcher.cNamespace().free = cwrapper.prototype("void summary_key_matcher_free(summary_key_matcher)") SummaryKeyMatcher.cNamespace().size = cwrapper.prototype("int summary_key_matcher_get_size(summary_key_matcher)") SummaryKeyMatcher.cNamespace().add_key = cwrapper.prototype("void summary_key_matcher_add_summary_key(summary_key_matcher, char*)") SummaryKeyMatcher.cNamespace().match_key = cwrapper.prototype("bool summary_key_matcher_match_summary_key(summary_key_matcher, char*)") SummaryKeyMatcher.cNamespace().keys = cwrapper.prototype("stringlist_obj summary_key_matcher_get_keys(summary_key_matcher)") SummaryKeyMatcher.cNamespace().is_required = cwrapper.prototype("bool summary_key_matcher_summary_key_is_required(summary_key_matcher, char*)") <|fim▁end|>
__len__
<|file_name|>summary_key_matcher.py<|end_file_name|><|fim▁begin|>from ert.cwrap import CWrapper, BaseCClass from ert.enkf import ENKF_LIB from ert.util import StringList class SummaryKeyMatcher(BaseCClass): def __init__(self): c_ptr = SummaryKeyMatcher.cNamespace().alloc() super(SummaryKeyMatcher, self).__init__(c_ptr) def addSummaryKey(self, key): assert isinstance(key, str) return SummaryKeyMatcher.cNamespace().add_key(self, key) def __len__(self): return SummaryKeyMatcher.cNamespace().size(self) def <|fim_middle|>(self, key): return SummaryKeyMatcher.cNamespace().match_key(self, key) def isRequired(self, key): """ @rtype: bool """ return SummaryKeyMatcher.cNamespace().is_required(self, key) def keys(self): """ @rtype: StringList """ return SummaryKeyMatcher.cNamespace().keys(self) def free(self): SummaryKeyMatcher.cNamespace().free(self) cwrapper = CWrapper(ENKF_LIB) cwrapper.registerObjectType("summary_key_matcher", SummaryKeyMatcher) SummaryKeyMatcher.cNamespace().alloc = cwrapper.prototype("c_void_p summary_key_matcher_alloc()") SummaryKeyMatcher.cNamespace().free = cwrapper.prototype("void summary_key_matcher_free(summary_key_matcher)") SummaryKeyMatcher.cNamespace().size = cwrapper.prototype("int summary_key_matcher_get_size(summary_key_matcher)") SummaryKeyMatcher.cNamespace().add_key = cwrapper.prototype("void summary_key_matcher_add_summary_key(summary_key_matcher, char*)") SummaryKeyMatcher.cNamespace().match_key = cwrapper.prototype("bool summary_key_matcher_match_summary_key(summary_key_matcher, char*)") SummaryKeyMatcher.cNamespace().keys = cwrapper.prototype("stringlist_obj summary_key_matcher_get_keys(summary_key_matcher)") SummaryKeyMatcher.cNamespace().is_required = cwrapper.prototype("bool summary_key_matcher_summary_key_is_required(summary_key_matcher, char*)") <|fim▁end|>
__contains__
<|file_name|>summary_key_matcher.py<|end_file_name|><|fim▁begin|>from ert.cwrap import CWrapper, BaseCClass from ert.enkf import ENKF_LIB from ert.util import StringList class SummaryKeyMatcher(BaseCClass): def __init__(self): c_ptr = SummaryKeyMatcher.cNamespace().alloc() super(SummaryKeyMatcher, self).__init__(c_ptr) def addSummaryKey(self, key): assert isinstance(key, str) return SummaryKeyMatcher.cNamespace().add_key(self, key) def __len__(self): return SummaryKeyMatcher.cNamespace().size(self) def __contains__(self, key): return SummaryKeyMatcher.cNamespace().match_key(self, key) def <|fim_middle|>(self, key): """ @rtype: bool """ return SummaryKeyMatcher.cNamespace().is_required(self, key) def keys(self): """ @rtype: StringList """ return SummaryKeyMatcher.cNamespace().keys(self) def free(self): SummaryKeyMatcher.cNamespace().free(self) cwrapper = CWrapper(ENKF_LIB) cwrapper.registerObjectType("summary_key_matcher", SummaryKeyMatcher) SummaryKeyMatcher.cNamespace().alloc = cwrapper.prototype("c_void_p summary_key_matcher_alloc()") SummaryKeyMatcher.cNamespace().free = cwrapper.prototype("void summary_key_matcher_free(summary_key_matcher)") SummaryKeyMatcher.cNamespace().size = cwrapper.prototype("int summary_key_matcher_get_size(summary_key_matcher)") SummaryKeyMatcher.cNamespace().add_key = cwrapper.prototype("void summary_key_matcher_add_summary_key(summary_key_matcher, char*)") SummaryKeyMatcher.cNamespace().match_key = cwrapper.prototype("bool summary_key_matcher_match_summary_key(summary_key_matcher, char*)") SummaryKeyMatcher.cNamespace().keys = cwrapper.prototype("stringlist_obj summary_key_matcher_get_keys(summary_key_matcher)") SummaryKeyMatcher.cNamespace().is_required = cwrapper.prototype("bool summary_key_matcher_summary_key_is_required(summary_key_matcher, char*)") <|fim▁end|>
isRequired
<|file_name|>summary_key_matcher.py<|end_file_name|><|fim▁begin|>from ert.cwrap import CWrapper, BaseCClass from ert.enkf import ENKF_LIB from ert.util import StringList class SummaryKeyMatcher(BaseCClass): def __init__(self): c_ptr = SummaryKeyMatcher.cNamespace().alloc() super(SummaryKeyMatcher, self).__init__(c_ptr) def addSummaryKey(self, key): assert isinstance(key, str) return SummaryKeyMatcher.cNamespace().add_key(self, key) def __len__(self): return SummaryKeyMatcher.cNamespace().size(self) def __contains__(self, key): return SummaryKeyMatcher.cNamespace().match_key(self, key) def isRequired(self, key): """ @rtype: bool """ return SummaryKeyMatcher.cNamespace().is_required(self, key) def <|fim_middle|>(self): """ @rtype: StringList """ return SummaryKeyMatcher.cNamespace().keys(self) def free(self): SummaryKeyMatcher.cNamespace().free(self) cwrapper = CWrapper(ENKF_LIB) cwrapper.registerObjectType("summary_key_matcher", SummaryKeyMatcher) SummaryKeyMatcher.cNamespace().alloc = cwrapper.prototype("c_void_p summary_key_matcher_alloc()") SummaryKeyMatcher.cNamespace().free = cwrapper.prototype("void summary_key_matcher_free(summary_key_matcher)") SummaryKeyMatcher.cNamespace().size = cwrapper.prototype("int summary_key_matcher_get_size(summary_key_matcher)") SummaryKeyMatcher.cNamespace().add_key = cwrapper.prototype("void summary_key_matcher_add_summary_key(summary_key_matcher, char*)") SummaryKeyMatcher.cNamespace().match_key = cwrapper.prototype("bool summary_key_matcher_match_summary_key(summary_key_matcher, char*)") SummaryKeyMatcher.cNamespace().keys = cwrapper.prototype("stringlist_obj summary_key_matcher_get_keys(summary_key_matcher)") SummaryKeyMatcher.cNamespace().is_required = cwrapper.prototype("bool summary_key_matcher_summary_key_is_required(summary_key_matcher, char*)") <|fim▁end|>
keys
<|file_name|>summary_key_matcher.py<|end_file_name|><|fim▁begin|>from ert.cwrap import CWrapper, BaseCClass from ert.enkf import ENKF_LIB from ert.util import StringList class SummaryKeyMatcher(BaseCClass): def __init__(self): c_ptr = SummaryKeyMatcher.cNamespace().alloc() super(SummaryKeyMatcher, self).__init__(c_ptr) def addSummaryKey(self, key): assert isinstance(key, str) return SummaryKeyMatcher.cNamespace().add_key(self, key) def __len__(self): return SummaryKeyMatcher.cNamespace().size(self) def __contains__(self, key): return SummaryKeyMatcher.cNamespace().match_key(self, key) def isRequired(self, key): """ @rtype: bool """ return SummaryKeyMatcher.cNamespace().is_required(self, key) def keys(self): """ @rtype: StringList """ return SummaryKeyMatcher.cNamespace().keys(self) def <|fim_middle|>(self): SummaryKeyMatcher.cNamespace().free(self) cwrapper = CWrapper(ENKF_LIB) cwrapper.registerObjectType("summary_key_matcher", SummaryKeyMatcher) SummaryKeyMatcher.cNamespace().alloc = cwrapper.prototype("c_void_p summary_key_matcher_alloc()") SummaryKeyMatcher.cNamespace().free = cwrapper.prototype("void summary_key_matcher_free(summary_key_matcher)") SummaryKeyMatcher.cNamespace().size = cwrapper.prototype("int summary_key_matcher_get_size(summary_key_matcher)") SummaryKeyMatcher.cNamespace().add_key = cwrapper.prototype("void summary_key_matcher_add_summary_key(summary_key_matcher, char*)") SummaryKeyMatcher.cNamespace().match_key = cwrapper.prototype("bool summary_key_matcher_match_summary_key(summary_key_matcher, char*)") SummaryKeyMatcher.cNamespace().keys = cwrapper.prototype("stringlist_obj summary_key_matcher_get_keys(summary_key_matcher)") SummaryKeyMatcher.cNamespace().is_required = cwrapper.prototype("bool summary_key_matcher_summary_key_is_required(summary_key_matcher, char*)") <|fim▁end|>
free
<|file_name|>simpleSound.py<|end_file_name|><|fim▁begin|># simpleSound.py # Plays audio files on Linux and Windows. # Written Jan-2008 by Timothy Weber. # Based on (reconstituted) code posted by Bill Dandreta at <http://www.velocityreviews.com/forums/t337346-how-to-play-sound-in-python.html>. import platform if platform.system().startswith('Win'): from winsound import PlaySound, SND_FILENAME, SND_ASYNC elif platform.system().startswith('Linux'): from wave import open as waveOpen from ossaudiodev import open as ossOpen try: from ossaudiodev import AFMT_S16_NE except ImportError: if byteorder == "little": AFMT_S16_NE = ossaudiodev.AFMT_S16_LE else: AFMT_S16_NE = ossaudiodev.AFMT_S16_BE def Play(filename): """Plays the sound in the given filename, asynchronously.""" if platform.system().startswith('Win'): PlaySound(filename, SND_FILENAME|SND_ASYNC) elif platform.system().startswith('Linux'): try: s = waveOpen(filename,'rb') (nc,sw,fr,nf,comptype, compname) = s.getparams( ) dsp = ossOpen('/dev/dsp','w') dsp.setparameters(AFMT_S16_NE, nc, fr) data = s.readframes(nf) s.close()<|fim▁hole|> except: pass<|fim▁end|>
dsp.write(data) dsp.close()
<|file_name|>simpleSound.py<|end_file_name|><|fim▁begin|># simpleSound.py # Plays audio files on Linux and Windows. # Written Jan-2008 by Timothy Weber. # Based on (reconstituted) code posted by Bill Dandreta at <http://www.velocityreviews.com/forums/t337346-how-to-play-sound-in-python.html>. import platform if platform.system().startswith('Win'): from winsound import PlaySound, SND_FILENAME, SND_ASYNC elif platform.system().startswith('Linux'): from wave import open as waveOpen from ossaudiodev import open as ossOpen try: from ossaudiodev import AFMT_S16_NE except ImportError: if byteorder == "little": AFMT_S16_NE = ossaudiodev.AFMT_S16_LE else: AFMT_S16_NE = ossaudiodev.AFMT_S16_BE def Play(filename): <|fim_middle|> <|fim▁end|>
"""Plays the sound in the given filename, asynchronously.""" if platform.system().startswith('Win'): PlaySound(filename, SND_FILENAME|SND_ASYNC) elif platform.system().startswith('Linux'): try: s = waveOpen(filename,'rb') (nc,sw,fr,nf,comptype, compname) = s.getparams( ) dsp = ossOpen('/dev/dsp','w') dsp.setparameters(AFMT_S16_NE, nc, fr) data = s.readframes(nf) s.close() dsp.write(data) dsp.close() except: pass
<|file_name|>simpleSound.py<|end_file_name|><|fim▁begin|># simpleSound.py # Plays audio files on Linux and Windows. # Written Jan-2008 by Timothy Weber. # Based on (reconstituted) code posted by Bill Dandreta at <http://www.velocityreviews.com/forums/t337346-how-to-play-sound-in-python.html>. import platform if platform.system().startswith('Win'): <|fim_middle|> elif platform.system().startswith('Linux'): from wave import open as waveOpen from ossaudiodev import open as ossOpen try: from ossaudiodev import AFMT_S16_NE except ImportError: if byteorder == "little": AFMT_S16_NE = ossaudiodev.AFMT_S16_LE else: AFMT_S16_NE = ossaudiodev.AFMT_S16_BE def Play(filename): """Plays the sound in the given filename, asynchronously.""" if platform.system().startswith('Win'): PlaySound(filename, SND_FILENAME|SND_ASYNC) elif platform.system().startswith('Linux'): try: s = waveOpen(filename,'rb') (nc,sw,fr,nf,comptype, compname) = s.getparams( ) dsp = ossOpen('/dev/dsp','w') dsp.setparameters(AFMT_S16_NE, nc, fr) data = s.readframes(nf) s.close() dsp.write(data) dsp.close() except: pass <|fim▁end|>
from winsound import PlaySound, SND_FILENAME, SND_ASYNC
<|file_name|>simpleSound.py<|end_file_name|><|fim▁begin|># simpleSound.py # Plays audio files on Linux and Windows. # Written Jan-2008 by Timothy Weber. # Based on (reconstituted) code posted by Bill Dandreta at <http://www.velocityreviews.com/forums/t337346-how-to-play-sound-in-python.html>. import platform if platform.system().startswith('Win'): from winsound import PlaySound, SND_FILENAME, SND_ASYNC elif platform.system().startswith('Linux'): <|fim_middle|> def Play(filename): """Plays the sound in the given filename, asynchronously.""" if platform.system().startswith('Win'): PlaySound(filename, SND_FILENAME|SND_ASYNC) elif platform.system().startswith('Linux'): try: s = waveOpen(filename,'rb') (nc,sw,fr,nf,comptype, compname) = s.getparams( ) dsp = ossOpen('/dev/dsp','w') dsp.setparameters(AFMT_S16_NE, nc, fr) data = s.readframes(nf) s.close() dsp.write(data) dsp.close() except: pass <|fim▁end|>
from wave import open as waveOpen from ossaudiodev import open as ossOpen try: from ossaudiodev import AFMT_S16_NE except ImportError: if byteorder == "little": AFMT_S16_NE = ossaudiodev.AFMT_S16_LE else: AFMT_S16_NE = ossaudiodev.AFMT_S16_BE
<|file_name|>simpleSound.py<|end_file_name|><|fim▁begin|># simpleSound.py # Plays audio files on Linux and Windows. # Written Jan-2008 by Timothy Weber. # Based on (reconstituted) code posted by Bill Dandreta at <http://www.velocityreviews.com/forums/t337346-how-to-play-sound-in-python.html>. import platform if platform.system().startswith('Win'): from winsound import PlaySound, SND_FILENAME, SND_ASYNC elif platform.system().startswith('Linux'): from wave import open as waveOpen from ossaudiodev import open as ossOpen try: from ossaudiodev import AFMT_S16_NE except ImportError: if byteorder == "little": <|fim_middle|> else: AFMT_S16_NE = ossaudiodev.AFMT_S16_BE def Play(filename): """Plays the sound in the given filename, asynchronously.""" if platform.system().startswith('Win'): PlaySound(filename, SND_FILENAME|SND_ASYNC) elif platform.system().startswith('Linux'): try: s = waveOpen(filename,'rb') (nc,sw,fr,nf,comptype, compname) = s.getparams( ) dsp = ossOpen('/dev/dsp','w') dsp.setparameters(AFMT_S16_NE, nc, fr) data = s.readframes(nf) s.close() dsp.write(data) dsp.close() except: pass <|fim▁end|>
AFMT_S16_NE = ossaudiodev.AFMT_S16_LE
<|file_name|>simpleSound.py<|end_file_name|><|fim▁begin|># simpleSound.py # Plays audio files on Linux and Windows. # Written Jan-2008 by Timothy Weber. # Based on (reconstituted) code posted by Bill Dandreta at <http://www.velocityreviews.com/forums/t337346-how-to-play-sound-in-python.html>. import platform if platform.system().startswith('Win'): from winsound import PlaySound, SND_FILENAME, SND_ASYNC elif platform.system().startswith('Linux'): from wave import open as waveOpen from ossaudiodev import open as ossOpen try: from ossaudiodev import AFMT_S16_NE except ImportError: if byteorder == "little": AFMT_S16_NE = ossaudiodev.AFMT_S16_LE else: <|fim_middle|> def Play(filename): """Plays the sound in the given filename, asynchronously.""" if platform.system().startswith('Win'): PlaySound(filename, SND_FILENAME|SND_ASYNC) elif platform.system().startswith('Linux'): try: s = waveOpen(filename,'rb') (nc,sw,fr,nf,comptype, compname) = s.getparams( ) dsp = ossOpen('/dev/dsp','w') dsp.setparameters(AFMT_S16_NE, nc, fr) data = s.readframes(nf) s.close() dsp.write(data) dsp.close() except: pass <|fim▁end|>
AFMT_S16_NE = ossaudiodev.AFMT_S16_BE
<|file_name|>simpleSound.py<|end_file_name|><|fim▁begin|># simpleSound.py # Plays audio files on Linux and Windows. # Written Jan-2008 by Timothy Weber. # Based on (reconstituted) code posted by Bill Dandreta at <http://www.velocityreviews.com/forums/t337346-how-to-play-sound-in-python.html>. import platform if platform.system().startswith('Win'): from winsound import PlaySound, SND_FILENAME, SND_ASYNC elif platform.system().startswith('Linux'): from wave import open as waveOpen from ossaudiodev import open as ossOpen try: from ossaudiodev import AFMT_S16_NE except ImportError: if byteorder == "little": AFMT_S16_NE = ossaudiodev.AFMT_S16_LE else: AFMT_S16_NE = ossaudiodev.AFMT_S16_BE def Play(filename): """Plays the sound in the given filename, asynchronously.""" if platform.system().startswith('Win'): <|fim_middle|> elif platform.system().startswith('Linux'): try: s = waveOpen(filename,'rb') (nc,sw,fr,nf,comptype, compname) = s.getparams( ) dsp = ossOpen('/dev/dsp','w') dsp.setparameters(AFMT_S16_NE, nc, fr) data = s.readframes(nf) s.close() dsp.write(data) dsp.close() except: pass <|fim▁end|>
PlaySound(filename, SND_FILENAME|SND_ASYNC)
<|file_name|>simpleSound.py<|end_file_name|><|fim▁begin|># simpleSound.py # Plays audio files on Linux and Windows. # Written Jan-2008 by Timothy Weber. # Based on (reconstituted) code posted by Bill Dandreta at <http://www.velocityreviews.com/forums/t337346-how-to-play-sound-in-python.html>. import platform if platform.system().startswith('Win'): from winsound import PlaySound, SND_FILENAME, SND_ASYNC elif platform.system().startswith('Linux'): from wave import open as waveOpen from ossaudiodev import open as ossOpen try: from ossaudiodev import AFMT_S16_NE except ImportError: if byteorder == "little": AFMT_S16_NE = ossaudiodev.AFMT_S16_LE else: AFMT_S16_NE = ossaudiodev.AFMT_S16_BE def Play(filename): """Plays the sound in the given filename, asynchronously.""" if platform.system().startswith('Win'): PlaySound(filename, SND_FILENAME|SND_ASYNC) elif platform.system().startswith('Linux'): <|fim_middle|> <|fim▁end|>
try: s = waveOpen(filename,'rb') (nc,sw,fr,nf,comptype, compname) = s.getparams( ) dsp = ossOpen('/dev/dsp','w') dsp.setparameters(AFMT_S16_NE, nc, fr) data = s.readframes(nf) s.close() dsp.write(data) dsp.close() except: pass
<|file_name|>simpleSound.py<|end_file_name|><|fim▁begin|># simpleSound.py # Plays audio files on Linux and Windows. # Written Jan-2008 by Timothy Weber. # Based on (reconstituted) code posted by Bill Dandreta at <http://www.velocityreviews.com/forums/t337346-how-to-play-sound-in-python.html>. import platform if platform.system().startswith('Win'): from winsound import PlaySound, SND_FILENAME, SND_ASYNC elif platform.system().startswith('Linux'): from wave import open as waveOpen from ossaudiodev import open as ossOpen try: from ossaudiodev import AFMT_S16_NE except ImportError: if byteorder == "little": AFMT_S16_NE = ossaudiodev.AFMT_S16_LE else: AFMT_S16_NE = ossaudiodev.AFMT_S16_BE def <|fim_middle|>(filename): """Plays the sound in the given filename, asynchronously.""" if platform.system().startswith('Win'): PlaySound(filename, SND_FILENAME|SND_ASYNC) elif platform.system().startswith('Linux'): try: s = waveOpen(filename,'rb') (nc,sw,fr,nf,comptype, compname) = s.getparams( ) dsp = ossOpen('/dev/dsp','w') dsp.setparameters(AFMT_S16_NE, nc, fr) data = s.readframes(nf) s.close() dsp.write(data) dsp.close() except: pass <|fim▁end|>
Play
<|file_name|>voter.py<|end_file_name|><|fim▁begin|># This file is part of VoltDB. # Copyright (C) 2008-2018 VoltDB Inc. # # Permission is hereby granted, free of charge, to any person obtaining # a copy of this software and associated documentation files (the # "Software"), to deal in the Software without restriction, including # without limitation the rights to use, copy, modify, merge, publish, # distribute, sublicense, and/or sell copies of the Software, and to # permit persons to whom the Software is furnished to do so, subject to # the following conditions: # # The above copyright notice and this permission notice shall be # included in all copies or substantial portions of the Software. # # THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, # EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF # MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. # IN NO EVENT SHALL THE AUTHORS BE LIABLE FOR ANY CLAIM, DAMAGES OR # OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, # ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR # OTHER DEALINGS IN THE SOFTWARE. # All the commands supported by the Voter application. import os @VOLT.Command(description = 'Build the Voter application and catalog.', options = VOLT.BooleanOption('-C', '--conditional', 'conditional', 'only build when the catalog file is missing')) def build(runner): if not runner.opts.conditional or not os.path.exists('voter.jar'): runner.java.compile('obj', 'src/voter/*.java', 'src/voter/procedures/*.java') runner.call('volt.compile', '-c', 'obj', '-o', 'voter.jar', 'ddl.sql') @VOLT.Command(description = 'Clean the Voter build output.') def clean(runner): runner.shell('rm', '-rfv', 'obj', 'debugoutput', 'voter.jar', 'voltdbroot') @VOLT.Server('create', description = 'Start the Voter VoltDB server.', command_arguments = 'voter.jar', classpath = 'obj') def server(runner): runner.call('build', '-C') runner.go() @VOLT.Java('voter.AsyncBenchmark', classpath = 'obj', description = 'Run the Voter asynchronous benchmark.') def async(runner): runner.call('build', '-C') runner.go() @VOLT.Java('voter.SyncBenchmark', classpath = 'obj',<|fim▁hole|> @VOLT.Java('voter.JDBCBenchmark', classpath = 'obj', description = 'Run the Voter JDBC benchmark.') def jdbc(runner): runner.call('build', '-C') runner.go() @VOLT.Java('voter.SimpleBenchmark', classpath = 'obj', description = 'Run the Voter simple benchmark.') def simple(runner): runner.call('build', '-C') runner.go()<|fim▁end|>
description = 'Run the Voter synchronous benchmark.') def sync(runner): runner.call('build', '-C') runner.go()
<|file_name|>voter.py<|end_file_name|><|fim▁begin|># This file is part of VoltDB. # Copyright (C) 2008-2018 VoltDB Inc. # # Permission is hereby granted, free of charge, to any person obtaining # a copy of this software and associated documentation files (the # "Software"), to deal in the Software without restriction, including # without limitation the rights to use, copy, modify, merge, publish, # distribute, sublicense, and/or sell copies of the Software, and to # permit persons to whom the Software is furnished to do so, subject to # the following conditions: # # The above copyright notice and this permission notice shall be # included in all copies or substantial portions of the Software. # # THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, # EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF # MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. # IN NO EVENT SHALL THE AUTHORS BE LIABLE FOR ANY CLAIM, DAMAGES OR # OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, # ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR # OTHER DEALINGS IN THE SOFTWARE. # All the commands supported by the Voter application. import os @VOLT.Command(description = 'Build the Voter application and catalog.', options = VOLT.BooleanOption('-C', '--conditional', 'conditional', 'only build when the catalog file is missing')) def build(runner): <|fim_middle|> @VOLT.Command(description = 'Clean the Voter build output.') def clean(runner): runner.shell('rm', '-rfv', 'obj', 'debugoutput', 'voter.jar', 'voltdbroot') @VOLT.Server('create', description = 'Start the Voter VoltDB server.', command_arguments = 'voter.jar', classpath = 'obj') def server(runner): runner.call('build', '-C') runner.go() @VOLT.Java('voter.AsyncBenchmark', classpath = 'obj', description = 'Run the Voter asynchronous benchmark.') def async(runner): runner.call('build', '-C') runner.go() @VOLT.Java('voter.SyncBenchmark', classpath = 'obj', description = 'Run the Voter synchronous benchmark.') def sync(runner): runner.call('build', '-C') runner.go() @VOLT.Java('voter.JDBCBenchmark', classpath = 'obj', description = 'Run the Voter JDBC benchmark.') def jdbc(runner): runner.call('build', '-C') runner.go() @VOLT.Java('voter.SimpleBenchmark', classpath = 'obj', description = 'Run the Voter simple benchmark.') def simple(runner): runner.call('build', '-C') runner.go() <|fim▁end|>
if not runner.opts.conditional or not os.path.exists('voter.jar'): runner.java.compile('obj', 'src/voter/*.java', 'src/voter/procedures/*.java') runner.call('volt.compile', '-c', 'obj', '-o', 'voter.jar', 'ddl.sql')
<|file_name|>voter.py<|end_file_name|><|fim▁begin|># This file is part of VoltDB. # Copyright (C) 2008-2018 VoltDB Inc. # # Permission is hereby granted, free of charge, to any person obtaining # a copy of this software and associated documentation files (the # "Software"), to deal in the Software without restriction, including # without limitation the rights to use, copy, modify, merge, publish, # distribute, sublicense, and/or sell copies of the Software, and to # permit persons to whom the Software is furnished to do so, subject to # the following conditions: # # The above copyright notice and this permission notice shall be # included in all copies or substantial portions of the Software. # # THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, # EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF # MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. # IN NO EVENT SHALL THE AUTHORS BE LIABLE FOR ANY CLAIM, DAMAGES OR # OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, # ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR # OTHER DEALINGS IN THE SOFTWARE. # All the commands supported by the Voter application. import os @VOLT.Command(description = 'Build the Voter application and catalog.', options = VOLT.BooleanOption('-C', '--conditional', 'conditional', 'only build when the catalog file is missing')) def build(runner): if not runner.opts.conditional or not os.path.exists('voter.jar'): runner.java.compile('obj', 'src/voter/*.java', 'src/voter/procedures/*.java') runner.call('volt.compile', '-c', 'obj', '-o', 'voter.jar', 'ddl.sql') @VOLT.Command(description = 'Clean the Voter build output.') def clean(runner): <|fim_middle|> @VOLT.Server('create', description = 'Start the Voter VoltDB server.', command_arguments = 'voter.jar', classpath = 'obj') def server(runner): runner.call('build', '-C') runner.go() @VOLT.Java('voter.AsyncBenchmark', classpath = 'obj', description = 'Run the Voter asynchronous benchmark.') def async(runner): runner.call('build', '-C') runner.go() @VOLT.Java('voter.SyncBenchmark', classpath = 'obj', description = 'Run the Voter synchronous benchmark.') def sync(runner): runner.call('build', '-C') runner.go() @VOLT.Java('voter.JDBCBenchmark', classpath = 'obj', description = 'Run the Voter JDBC benchmark.') def jdbc(runner): runner.call('build', '-C') runner.go() @VOLT.Java('voter.SimpleBenchmark', classpath = 'obj', description = 'Run the Voter simple benchmark.') def simple(runner): runner.call('build', '-C') runner.go() <|fim▁end|>
runner.shell('rm', '-rfv', 'obj', 'debugoutput', 'voter.jar', 'voltdbroot')
<|file_name|>voter.py<|end_file_name|><|fim▁begin|># This file is part of VoltDB. # Copyright (C) 2008-2018 VoltDB Inc. # # Permission is hereby granted, free of charge, to any person obtaining # a copy of this software and associated documentation files (the # "Software"), to deal in the Software without restriction, including # without limitation the rights to use, copy, modify, merge, publish, # distribute, sublicense, and/or sell copies of the Software, and to # permit persons to whom the Software is furnished to do so, subject to # the following conditions: # # The above copyright notice and this permission notice shall be # included in all copies or substantial portions of the Software. # # THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, # EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF # MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. # IN NO EVENT SHALL THE AUTHORS BE LIABLE FOR ANY CLAIM, DAMAGES OR # OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, # ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR # OTHER DEALINGS IN THE SOFTWARE. # All the commands supported by the Voter application. import os @VOLT.Command(description = 'Build the Voter application and catalog.', options = VOLT.BooleanOption('-C', '--conditional', 'conditional', 'only build when the catalog file is missing')) def build(runner): if not runner.opts.conditional or not os.path.exists('voter.jar'): runner.java.compile('obj', 'src/voter/*.java', 'src/voter/procedures/*.java') runner.call('volt.compile', '-c', 'obj', '-o', 'voter.jar', 'ddl.sql') @VOLT.Command(description = 'Clean the Voter build output.') def clean(runner): runner.shell('rm', '-rfv', 'obj', 'debugoutput', 'voter.jar', 'voltdbroot') @VOLT.Server('create', description = 'Start the Voter VoltDB server.', command_arguments = 'voter.jar', classpath = 'obj') def server(runner): <|fim_middle|> @VOLT.Java('voter.AsyncBenchmark', classpath = 'obj', description = 'Run the Voter asynchronous benchmark.') def async(runner): runner.call('build', '-C') runner.go() @VOLT.Java('voter.SyncBenchmark', classpath = 'obj', description = 'Run the Voter synchronous benchmark.') def sync(runner): runner.call('build', '-C') runner.go() @VOLT.Java('voter.JDBCBenchmark', classpath = 'obj', description = 'Run the Voter JDBC benchmark.') def jdbc(runner): runner.call('build', '-C') runner.go() @VOLT.Java('voter.SimpleBenchmark', classpath = 'obj', description = 'Run the Voter simple benchmark.') def simple(runner): runner.call('build', '-C') runner.go() <|fim▁end|>
runner.call('build', '-C') runner.go()
<|file_name|>voter.py<|end_file_name|><|fim▁begin|># This file is part of VoltDB. # Copyright (C) 2008-2018 VoltDB Inc. # # Permission is hereby granted, free of charge, to any person obtaining # a copy of this software and associated documentation files (the # "Software"), to deal in the Software without restriction, including # without limitation the rights to use, copy, modify, merge, publish, # distribute, sublicense, and/or sell copies of the Software, and to # permit persons to whom the Software is furnished to do so, subject to # the following conditions: # # The above copyright notice and this permission notice shall be # included in all copies or substantial portions of the Software. # # THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, # EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF # MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. # IN NO EVENT SHALL THE AUTHORS BE LIABLE FOR ANY CLAIM, DAMAGES OR # OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, # ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR # OTHER DEALINGS IN THE SOFTWARE. # All the commands supported by the Voter application. import os @VOLT.Command(description = 'Build the Voter application and catalog.', options = VOLT.BooleanOption('-C', '--conditional', 'conditional', 'only build when the catalog file is missing')) def build(runner): if not runner.opts.conditional or not os.path.exists('voter.jar'): runner.java.compile('obj', 'src/voter/*.java', 'src/voter/procedures/*.java') runner.call('volt.compile', '-c', 'obj', '-o', 'voter.jar', 'ddl.sql') @VOLT.Command(description = 'Clean the Voter build output.') def clean(runner): runner.shell('rm', '-rfv', 'obj', 'debugoutput', 'voter.jar', 'voltdbroot') @VOLT.Server('create', description = 'Start the Voter VoltDB server.', command_arguments = 'voter.jar', classpath = 'obj') def server(runner): runner.call('build', '-C') runner.go() @VOLT.Java('voter.AsyncBenchmark', classpath = 'obj', description = 'Run the Voter asynchronous benchmark.') def async(runner): <|fim_middle|> @VOLT.Java('voter.SyncBenchmark', classpath = 'obj', description = 'Run the Voter synchronous benchmark.') def sync(runner): runner.call('build', '-C') runner.go() @VOLT.Java('voter.JDBCBenchmark', classpath = 'obj', description = 'Run the Voter JDBC benchmark.') def jdbc(runner): runner.call('build', '-C') runner.go() @VOLT.Java('voter.SimpleBenchmark', classpath = 'obj', description = 'Run the Voter simple benchmark.') def simple(runner): runner.call('build', '-C') runner.go() <|fim▁end|>
runner.call('build', '-C') runner.go()
<|file_name|>voter.py<|end_file_name|><|fim▁begin|># This file is part of VoltDB. # Copyright (C) 2008-2018 VoltDB Inc. # # Permission is hereby granted, free of charge, to any person obtaining # a copy of this software and associated documentation files (the # "Software"), to deal in the Software without restriction, including # without limitation the rights to use, copy, modify, merge, publish, # distribute, sublicense, and/or sell copies of the Software, and to # permit persons to whom the Software is furnished to do so, subject to # the following conditions: # # The above copyright notice and this permission notice shall be # included in all copies or substantial portions of the Software. # # THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, # EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF # MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. # IN NO EVENT SHALL THE AUTHORS BE LIABLE FOR ANY CLAIM, DAMAGES OR # OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, # ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR # OTHER DEALINGS IN THE SOFTWARE. # All the commands supported by the Voter application. import os @VOLT.Command(description = 'Build the Voter application and catalog.', options = VOLT.BooleanOption('-C', '--conditional', 'conditional', 'only build when the catalog file is missing')) def build(runner): if not runner.opts.conditional or not os.path.exists('voter.jar'): runner.java.compile('obj', 'src/voter/*.java', 'src/voter/procedures/*.java') runner.call('volt.compile', '-c', 'obj', '-o', 'voter.jar', 'ddl.sql') @VOLT.Command(description = 'Clean the Voter build output.') def clean(runner): runner.shell('rm', '-rfv', 'obj', 'debugoutput', 'voter.jar', 'voltdbroot') @VOLT.Server('create', description = 'Start the Voter VoltDB server.', command_arguments = 'voter.jar', classpath = 'obj') def server(runner): runner.call('build', '-C') runner.go() @VOLT.Java('voter.AsyncBenchmark', classpath = 'obj', description = 'Run the Voter asynchronous benchmark.') def async(runner): runner.call('build', '-C') runner.go() @VOLT.Java('voter.SyncBenchmark', classpath = 'obj', description = 'Run the Voter synchronous benchmark.') def sync(runner): <|fim_middle|> @VOLT.Java('voter.JDBCBenchmark', classpath = 'obj', description = 'Run the Voter JDBC benchmark.') def jdbc(runner): runner.call('build', '-C') runner.go() @VOLT.Java('voter.SimpleBenchmark', classpath = 'obj', description = 'Run the Voter simple benchmark.') def simple(runner): runner.call('build', '-C') runner.go() <|fim▁end|>
runner.call('build', '-C') runner.go()
<|file_name|>voter.py<|end_file_name|><|fim▁begin|># This file is part of VoltDB. # Copyright (C) 2008-2018 VoltDB Inc. # # Permission is hereby granted, free of charge, to any person obtaining # a copy of this software and associated documentation files (the # "Software"), to deal in the Software without restriction, including # without limitation the rights to use, copy, modify, merge, publish, # distribute, sublicense, and/or sell copies of the Software, and to # permit persons to whom the Software is furnished to do so, subject to # the following conditions: # # The above copyright notice and this permission notice shall be # included in all copies or substantial portions of the Software. # # THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, # EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF # MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. # IN NO EVENT SHALL THE AUTHORS BE LIABLE FOR ANY CLAIM, DAMAGES OR # OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, # ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR # OTHER DEALINGS IN THE SOFTWARE. # All the commands supported by the Voter application. import os @VOLT.Command(description = 'Build the Voter application and catalog.', options = VOLT.BooleanOption('-C', '--conditional', 'conditional', 'only build when the catalog file is missing')) def build(runner): if not runner.opts.conditional or not os.path.exists('voter.jar'): runner.java.compile('obj', 'src/voter/*.java', 'src/voter/procedures/*.java') runner.call('volt.compile', '-c', 'obj', '-o', 'voter.jar', 'ddl.sql') @VOLT.Command(description = 'Clean the Voter build output.') def clean(runner): runner.shell('rm', '-rfv', 'obj', 'debugoutput', 'voter.jar', 'voltdbroot') @VOLT.Server('create', description = 'Start the Voter VoltDB server.', command_arguments = 'voter.jar', classpath = 'obj') def server(runner): runner.call('build', '-C') runner.go() @VOLT.Java('voter.AsyncBenchmark', classpath = 'obj', description = 'Run the Voter asynchronous benchmark.') def async(runner): runner.call('build', '-C') runner.go() @VOLT.Java('voter.SyncBenchmark', classpath = 'obj', description = 'Run the Voter synchronous benchmark.') def sync(runner): runner.call('build', '-C') runner.go() @VOLT.Java('voter.JDBCBenchmark', classpath = 'obj', description = 'Run the Voter JDBC benchmark.') def jdbc(runner): <|fim_middle|> @VOLT.Java('voter.SimpleBenchmark', classpath = 'obj', description = 'Run the Voter simple benchmark.') def simple(runner): runner.call('build', '-C') runner.go() <|fim▁end|>
runner.call('build', '-C') runner.go()
<|file_name|>voter.py<|end_file_name|><|fim▁begin|># This file is part of VoltDB. # Copyright (C) 2008-2018 VoltDB Inc. # # Permission is hereby granted, free of charge, to any person obtaining # a copy of this software and associated documentation files (the # "Software"), to deal in the Software without restriction, including # without limitation the rights to use, copy, modify, merge, publish, # distribute, sublicense, and/or sell copies of the Software, and to # permit persons to whom the Software is furnished to do so, subject to # the following conditions: # # The above copyright notice and this permission notice shall be # included in all copies or substantial portions of the Software. # # THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, # EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF # MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. # IN NO EVENT SHALL THE AUTHORS BE LIABLE FOR ANY CLAIM, DAMAGES OR # OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, # ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR # OTHER DEALINGS IN THE SOFTWARE. # All the commands supported by the Voter application. import os @VOLT.Command(description = 'Build the Voter application and catalog.', options = VOLT.BooleanOption('-C', '--conditional', 'conditional', 'only build when the catalog file is missing')) def build(runner): if not runner.opts.conditional or not os.path.exists('voter.jar'): runner.java.compile('obj', 'src/voter/*.java', 'src/voter/procedures/*.java') runner.call('volt.compile', '-c', 'obj', '-o', 'voter.jar', 'ddl.sql') @VOLT.Command(description = 'Clean the Voter build output.') def clean(runner): runner.shell('rm', '-rfv', 'obj', 'debugoutput', 'voter.jar', 'voltdbroot') @VOLT.Server('create', description = 'Start the Voter VoltDB server.', command_arguments = 'voter.jar', classpath = 'obj') def server(runner): runner.call('build', '-C') runner.go() @VOLT.Java('voter.AsyncBenchmark', classpath = 'obj', description = 'Run the Voter asynchronous benchmark.') def async(runner): runner.call('build', '-C') runner.go() @VOLT.Java('voter.SyncBenchmark', classpath = 'obj', description = 'Run the Voter synchronous benchmark.') def sync(runner): runner.call('build', '-C') runner.go() @VOLT.Java('voter.JDBCBenchmark', classpath = 'obj', description = 'Run the Voter JDBC benchmark.') def jdbc(runner): runner.call('build', '-C') runner.go() @VOLT.Java('voter.SimpleBenchmark', classpath = 'obj', description = 'Run the Voter simple benchmark.') def simple(runner): <|fim_middle|> <|fim▁end|>
runner.call('build', '-C') runner.go()
<|file_name|>voter.py<|end_file_name|><|fim▁begin|># This file is part of VoltDB. # Copyright (C) 2008-2018 VoltDB Inc. # # Permission is hereby granted, free of charge, to any person obtaining # a copy of this software and associated documentation files (the # "Software"), to deal in the Software without restriction, including # without limitation the rights to use, copy, modify, merge, publish, # distribute, sublicense, and/or sell copies of the Software, and to # permit persons to whom the Software is furnished to do so, subject to # the following conditions: # # The above copyright notice and this permission notice shall be # included in all copies or substantial portions of the Software. # # THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, # EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF # MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. # IN NO EVENT SHALL THE AUTHORS BE LIABLE FOR ANY CLAIM, DAMAGES OR # OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, # ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR # OTHER DEALINGS IN THE SOFTWARE. # All the commands supported by the Voter application. import os @VOLT.Command(description = 'Build the Voter application and catalog.', options = VOLT.BooleanOption('-C', '--conditional', 'conditional', 'only build when the catalog file is missing')) def build(runner): if not runner.opts.conditional or not os.path.exists('voter.jar'): <|fim_middle|> runner.call('volt.compile', '-c', 'obj', '-o', 'voter.jar', 'ddl.sql') @VOLT.Command(description = 'Clean the Voter build output.') def clean(runner): runner.shell('rm', '-rfv', 'obj', 'debugoutput', 'voter.jar', 'voltdbroot') @VOLT.Server('create', description = 'Start the Voter VoltDB server.', command_arguments = 'voter.jar', classpath = 'obj') def server(runner): runner.call('build', '-C') runner.go() @VOLT.Java('voter.AsyncBenchmark', classpath = 'obj', description = 'Run the Voter asynchronous benchmark.') def async(runner): runner.call('build', '-C') runner.go() @VOLT.Java('voter.SyncBenchmark', classpath = 'obj', description = 'Run the Voter synchronous benchmark.') def sync(runner): runner.call('build', '-C') runner.go() @VOLT.Java('voter.JDBCBenchmark', classpath = 'obj', description = 'Run the Voter JDBC benchmark.') def jdbc(runner): runner.call('build', '-C') runner.go() @VOLT.Java('voter.SimpleBenchmark', classpath = 'obj', description = 'Run the Voter simple benchmark.') def simple(runner): runner.call('build', '-C') runner.go() <|fim▁end|>
runner.java.compile('obj', 'src/voter/*.java', 'src/voter/procedures/*.java')
<|file_name|>voter.py<|end_file_name|><|fim▁begin|># This file is part of VoltDB. # Copyright (C) 2008-2018 VoltDB Inc. # # Permission is hereby granted, free of charge, to any person obtaining # a copy of this software and associated documentation files (the # "Software"), to deal in the Software without restriction, including # without limitation the rights to use, copy, modify, merge, publish, # distribute, sublicense, and/or sell copies of the Software, and to # permit persons to whom the Software is furnished to do so, subject to # the following conditions: # # The above copyright notice and this permission notice shall be # included in all copies or substantial portions of the Software. # # THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, # EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF # MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. # IN NO EVENT SHALL THE AUTHORS BE LIABLE FOR ANY CLAIM, DAMAGES OR # OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, # ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR # OTHER DEALINGS IN THE SOFTWARE. # All the commands supported by the Voter application. import os @VOLT.Command(description = 'Build the Voter application and catalog.', options = VOLT.BooleanOption('-C', '--conditional', 'conditional', 'only build when the catalog file is missing')) def <|fim_middle|>(runner): if not runner.opts.conditional or not os.path.exists('voter.jar'): runner.java.compile('obj', 'src/voter/*.java', 'src/voter/procedures/*.java') runner.call('volt.compile', '-c', 'obj', '-o', 'voter.jar', 'ddl.sql') @VOLT.Command(description = 'Clean the Voter build output.') def clean(runner): runner.shell('rm', '-rfv', 'obj', 'debugoutput', 'voter.jar', 'voltdbroot') @VOLT.Server('create', description = 'Start the Voter VoltDB server.', command_arguments = 'voter.jar', classpath = 'obj') def server(runner): runner.call('build', '-C') runner.go() @VOLT.Java('voter.AsyncBenchmark', classpath = 'obj', description = 'Run the Voter asynchronous benchmark.') def async(runner): runner.call('build', '-C') runner.go() @VOLT.Java('voter.SyncBenchmark', classpath = 'obj', description = 'Run the Voter synchronous benchmark.') def sync(runner): runner.call('build', '-C') runner.go() @VOLT.Java('voter.JDBCBenchmark', classpath = 'obj', description = 'Run the Voter JDBC benchmark.') def jdbc(runner): runner.call('build', '-C') runner.go() @VOLT.Java('voter.SimpleBenchmark', classpath = 'obj', description = 'Run the Voter simple benchmark.') def simple(runner): runner.call('build', '-C') runner.go() <|fim▁end|>
build
<|file_name|>voter.py<|end_file_name|><|fim▁begin|># This file is part of VoltDB. # Copyright (C) 2008-2018 VoltDB Inc. # # Permission is hereby granted, free of charge, to any person obtaining # a copy of this software and associated documentation files (the # "Software"), to deal in the Software without restriction, including # without limitation the rights to use, copy, modify, merge, publish, # distribute, sublicense, and/or sell copies of the Software, and to # permit persons to whom the Software is furnished to do so, subject to # the following conditions: # # The above copyright notice and this permission notice shall be # included in all copies or substantial portions of the Software. # # THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, # EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF # MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. # IN NO EVENT SHALL THE AUTHORS BE LIABLE FOR ANY CLAIM, DAMAGES OR # OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, # ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR # OTHER DEALINGS IN THE SOFTWARE. # All the commands supported by the Voter application. import os @VOLT.Command(description = 'Build the Voter application and catalog.', options = VOLT.BooleanOption('-C', '--conditional', 'conditional', 'only build when the catalog file is missing')) def build(runner): if not runner.opts.conditional or not os.path.exists('voter.jar'): runner.java.compile('obj', 'src/voter/*.java', 'src/voter/procedures/*.java') runner.call('volt.compile', '-c', 'obj', '-o', 'voter.jar', 'ddl.sql') @VOLT.Command(description = 'Clean the Voter build output.') def <|fim_middle|>(runner): runner.shell('rm', '-rfv', 'obj', 'debugoutput', 'voter.jar', 'voltdbroot') @VOLT.Server('create', description = 'Start the Voter VoltDB server.', command_arguments = 'voter.jar', classpath = 'obj') def server(runner): runner.call('build', '-C') runner.go() @VOLT.Java('voter.AsyncBenchmark', classpath = 'obj', description = 'Run the Voter asynchronous benchmark.') def async(runner): runner.call('build', '-C') runner.go() @VOLT.Java('voter.SyncBenchmark', classpath = 'obj', description = 'Run the Voter synchronous benchmark.') def sync(runner): runner.call('build', '-C') runner.go() @VOLT.Java('voter.JDBCBenchmark', classpath = 'obj', description = 'Run the Voter JDBC benchmark.') def jdbc(runner): runner.call('build', '-C') runner.go() @VOLT.Java('voter.SimpleBenchmark', classpath = 'obj', description = 'Run the Voter simple benchmark.') def simple(runner): runner.call('build', '-C') runner.go() <|fim▁end|>
clean
<|file_name|>voter.py<|end_file_name|><|fim▁begin|># This file is part of VoltDB. # Copyright (C) 2008-2018 VoltDB Inc. # # Permission is hereby granted, free of charge, to any person obtaining # a copy of this software and associated documentation files (the # "Software"), to deal in the Software without restriction, including # without limitation the rights to use, copy, modify, merge, publish, # distribute, sublicense, and/or sell copies of the Software, and to # permit persons to whom the Software is furnished to do so, subject to # the following conditions: # # The above copyright notice and this permission notice shall be # included in all copies or substantial portions of the Software. # # THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, # EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF # MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. # IN NO EVENT SHALL THE AUTHORS BE LIABLE FOR ANY CLAIM, DAMAGES OR # OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, # ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR # OTHER DEALINGS IN THE SOFTWARE. # All the commands supported by the Voter application. import os @VOLT.Command(description = 'Build the Voter application and catalog.', options = VOLT.BooleanOption('-C', '--conditional', 'conditional', 'only build when the catalog file is missing')) def build(runner): if not runner.opts.conditional or not os.path.exists('voter.jar'): runner.java.compile('obj', 'src/voter/*.java', 'src/voter/procedures/*.java') runner.call('volt.compile', '-c', 'obj', '-o', 'voter.jar', 'ddl.sql') @VOLT.Command(description = 'Clean the Voter build output.') def clean(runner): runner.shell('rm', '-rfv', 'obj', 'debugoutput', 'voter.jar', 'voltdbroot') @VOLT.Server('create', description = 'Start the Voter VoltDB server.', command_arguments = 'voter.jar', classpath = 'obj') def <|fim_middle|>(runner): runner.call('build', '-C') runner.go() @VOLT.Java('voter.AsyncBenchmark', classpath = 'obj', description = 'Run the Voter asynchronous benchmark.') def async(runner): runner.call('build', '-C') runner.go() @VOLT.Java('voter.SyncBenchmark', classpath = 'obj', description = 'Run the Voter synchronous benchmark.') def sync(runner): runner.call('build', '-C') runner.go() @VOLT.Java('voter.JDBCBenchmark', classpath = 'obj', description = 'Run the Voter JDBC benchmark.') def jdbc(runner): runner.call('build', '-C') runner.go() @VOLT.Java('voter.SimpleBenchmark', classpath = 'obj', description = 'Run the Voter simple benchmark.') def simple(runner): runner.call('build', '-C') runner.go() <|fim▁end|>
server
<|file_name|>voter.py<|end_file_name|><|fim▁begin|># This file is part of VoltDB. # Copyright (C) 2008-2018 VoltDB Inc. # # Permission is hereby granted, free of charge, to any person obtaining # a copy of this software and associated documentation files (the # "Software"), to deal in the Software without restriction, including # without limitation the rights to use, copy, modify, merge, publish, # distribute, sublicense, and/or sell copies of the Software, and to # permit persons to whom the Software is furnished to do so, subject to # the following conditions: # # The above copyright notice and this permission notice shall be # included in all copies or substantial portions of the Software. # # THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, # EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF # MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. # IN NO EVENT SHALL THE AUTHORS BE LIABLE FOR ANY CLAIM, DAMAGES OR # OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, # ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR # OTHER DEALINGS IN THE SOFTWARE. # All the commands supported by the Voter application. import os @VOLT.Command(description = 'Build the Voter application and catalog.', options = VOLT.BooleanOption('-C', '--conditional', 'conditional', 'only build when the catalog file is missing')) def build(runner): if not runner.opts.conditional or not os.path.exists('voter.jar'): runner.java.compile('obj', 'src/voter/*.java', 'src/voter/procedures/*.java') runner.call('volt.compile', '-c', 'obj', '-o', 'voter.jar', 'ddl.sql') @VOLT.Command(description = 'Clean the Voter build output.') def clean(runner): runner.shell('rm', '-rfv', 'obj', 'debugoutput', 'voter.jar', 'voltdbroot') @VOLT.Server('create', description = 'Start the Voter VoltDB server.', command_arguments = 'voter.jar', classpath = 'obj') def server(runner): runner.call('build', '-C') runner.go() @VOLT.Java('voter.AsyncBenchmark', classpath = 'obj', description = 'Run the Voter asynchronous benchmark.') def <|fim_middle|>(runner): runner.call('build', '-C') runner.go() @VOLT.Java('voter.SyncBenchmark', classpath = 'obj', description = 'Run the Voter synchronous benchmark.') def sync(runner): runner.call('build', '-C') runner.go() @VOLT.Java('voter.JDBCBenchmark', classpath = 'obj', description = 'Run the Voter JDBC benchmark.') def jdbc(runner): runner.call('build', '-C') runner.go() @VOLT.Java('voter.SimpleBenchmark', classpath = 'obj', description = 'Run the Voter simple benchmark.') def simple(runner): runner.call('build', '-C') runner.go() <|fim▁end|>
async
<|file_name|>voter.py<|end_file_name|><|fim▁begin|># This file is part of VoltDB. # Copyright (C) 2008-2018 VoltDB Inc. # # Permission is hereby granted, free of charge, to any person obtaining # a copy of this software and associated documentation files (the # "Software"), to deal in the Software without restriction, including # without limitation the rights to use, copy, modify, merge, publish, # distribute, sublicense, and/or sell copies of the Software, and to # permit persons to whom the Software is furnished to do so, subject to # the following conditions: # # The above copyright notice and this permission notice shall be # included in all copies or substantial portions of the Software. # # THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, # EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF # MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. # IN NO EVENT SHALL THE AUTHORS BE LIABLE FOR ANY CLAIM, DAMAGES OR # OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, # ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR # OTHER DEALINGS IN THE SOFTWARE. # All the commands supported by the Voter application. import os @VOLT.Command(description = 'Build the Voter application and catalog.', options = VOLT.BooleanOption('-C', '--conditional', 'conditional', 'only build when the catalog file is missing')) def build(runner): if not runner.opts.conditional or not os.path.exists('voter.jar'): runner.java.compile('obj', 'src/voter/*.java', 'src/voter/procedures/*.java') runner.call('volt.compile', '-c', 'obj', '-o', 'voter.jar', 'ddl.sql') @VOLT.Command(description = 'Clean the Voter build output.') def clean(runner): runner.shell('rm', '-rfv', 'obj', 'debugoutput', 'voter.jar', 'voltdbroot') @VOLT.Server('create', description = 'Start the Voter VoltDB server.', command_arguments = 'voter.jar', classpath = 'obj') def server(runner): runner.call('build', '-C') runner.go() @VOLT.Java('voter.AsyncBenchmark', classpath = 'obj', description = 'Run the Voter asynchronous benchmark.') def async(runner): runner.call('build', '-C') runner.go() @VOLT.Java('voter.SyncBenchmark', classpath = 'obj', description = 'Run the Voter synchronous benchmark.') def <|fim_middle|>(runner): runner.call('build', '-C') runner.go() @VOLT.Java('voter.JDBCBenchmark', classpath = 'obj', description = 'Run the Voter JDBC benchmark.') def jdbc(runner): runner.call('build', '-C') runner.go() @VOLT.Java('voter.SimpleBenchmark', classpath = 'obj', description = 'Run the Voter simple benchmark.') def simple(runner): runner.call('build', '-C') runner.go() <|fim▁end|>
sync
<|file_name|>voter.py<|end_file_name|><|fim▁begin|># This file is part of VoltDB. # Copyright (C) 2008-2018 VoltDB Inc. # # Permission is hereby granted, free of charge, to any person obtaining # a copy of this software and associated documentation files (the # "Software"), to deal in the Software without restriction, including # without limitation the rights to use, copy, modify, merge, publish, # distribute, sublicense, and/or sell copies of the Software, and to # permit persons to whom the Software is furnished to do so, subject to # the following conditions: # # The above copyright notice and this permission notice shall be # included in all copies or substantial portions of the Software. # # THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, # EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF # MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. # IN NO EVENT SHALL THE AUTHORS BE LIABLE FOR ANY CLAIM, DAMAGES OR # OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, # ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR # OTHER DEALINGS IN THE SOFTWARE. # All the commands supported by the Voter application. import os @VOLT.Command(description = 'Build the Voter application and catalog.', options = VOLT.BooleanOption('-C', '--conditional', 'conditional', 'only build when the catalog file is missing')) def build(runner): if not runner.opts.conditional or not os.path.exists('voter.jar'): runner.java.compile('obj', 'src/voter/*.java', 'src/voter/procedures/*.java') runner.call('volt.compile', '-c', 'obj', '-o', 'voter.jar', 'ddl.sql') @VOLT.Command(description = 'Clean the Voter build output.') def clean(runner): runner.shell('rm', '-rfv', 'obj', 'debugoutput', 'voter.jar', 'voltdbroot') @VOLT.Server('create', description = 'Start the Voter VoltDB server.', command_arguments = 'voter.jar', classpath = 'obj') def server(runner): runner.call('build', '-C') runner.go() @VOLT.Java('voter.AsyncBenchmark', classpath = 'obj', description = 'Run the Voter asynchronous benchmark.') def async(runner): runner.call('build', '-C') runner.go() @VOLT.Java('voter.SyncBenchmark', classpath = 'obj', description = 'Run the Voter synchronous benchmark.') def sync(runner): runner.call('build', '-C') runner.go() @VOLT.Java('voter.JDBCBenchmark', classpath = 'obj', description = 'Run the Voter JDBC benchmark.') def <|fim_middle|>(runner): runner.call('build', '-C') runner.go() @VOLT.Java('voter.SimpleBenchmark', classpath = 'obj', description = 'Run the Voter simple benchmark.') def simple(runner): runner.call('build', '-C') runner.go() <|fim▁end|>
jdbc
<|file_name|>voter.py<|end_file_name|><|fim▁begin|># This file is part of VoltDB. # Copyright (C) 2008-2018 VoltDB Inc. # # Permission is hereby granted, free of charge, to any person obtaining # a copy of this software and associated documentation files (the # "Software"), to deal in the Software without restriction, including # without limitation the rights to use, copy, modify, merge, publish, # distribute, sublicense, and/or sell copies of the Software, and to # permit persons to whom the Software is furnished to do so, subject to # the following conditions: # # The above copyright notice and this permission notice shall be # included in all copies or substantial portions of the Software. # # THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, # EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF # MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. # IN NO EVENT SHALL THE AUTHORS BE LIABLE FOR ANY CLAIM, DAMAGES OR # OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, # ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR # OTHER DEALINGS IN THE SOFTWARE. # All the commands supported by the Voter application. import os @VOLT.Command(description = 'Build the Voter application and catalog.', options = VOLT.BooleanOption('-C', '--conditional', 'conditional', 'only build when the catalog file is missing')) def build(runner): if not runner.opts.conditional or not os.path.exists('voter.jar'): runner.java.compile('obj', 'src/voter/*.java', 'src/voter/procedures/*.java') runner.call('volt.compile', '-c', 'obj', '-o', 'voter.jar', 'ddl.sql') @VOLT.Command(description = 'Clean the Voter build output.') def clean(runner): runner.shell('rm', '-rfv', 'obj', 'debugoutput', 'voter.jar', 'voltdbroot') @VOLT.Server('create', description = 'Start the Voter VoltDB server.', command_arguments = 'voter.jar', classpath = 'obj') def server(runner): runner.call('build', '-C') runner.go() @VOLT.Java('voter.AsyncBenchmark', classpath = 'obj', description = 'Run the Voter asynchronous benchmark.') def async(runner): runner.call('build', '-C') runner.go() @VOLT.Java('voter.SyncBenchmark', classpath = 'obj', description = 'Run the Voter synchronous benchmark.') def sync(runner): runner.call('build', '-C') runner.go() @VOLT.Java('voter.JDBCBenchmark', classpath = 'obj', description = 'Run the Voter JDBC benchmark.') def jdbc(runner): runner.call('build', '-C') runner.go() @VOLT.Java('voter.SimpleBenchmark', classpath = 'obj', description = 'Run the Voter simple benchmark.') def <|fim_middle|>(runner): runner.call('build', '-C') runner.go() <|fim▁end|>
simple
<|file_name|>urls.py<|end_file_name|><|fim▁begin|><|fim▁hole|> The `urlpatterns` list routes URLs to views. For more information please see: https://docs.djangoproject.com/en/1.8/topics/http/urls/ Examples: Function views 1. Add an import: from my_app import views 2. Add a URL to urlpatterns: url(r'^$', views.home, name='home') Class-based views 1. Add an import: from other_app.views import Home 2. Add a URL to urlpatterns: url(r'^$', Home.as_view(), name='home') Including another URLconf 1. Add an import: from blog import urls as blog_urls 2. Add a URL to urlpatterns: url(r'^blog/', include(blog_urls)) """ from django.conf.urls import include, url, patterns from django.contrib import admin from Workinout import views from django.conf import settings urlpatterns = [ url(r'^admin/', include(admin.site.urls)), url(r'^Workinout/', include('Workinout.urls')), # ADD THIS NEW TUPLE!media/(?P<path>.*) ] if settings.DEBUG: urlpatterns += patterns( 'django.views.static', (r'media/(?P<path>.*)', 'serve', {'document_root': settings.MEDIA_ROOT}), ) else: urlpatterns += patterns('', url(r'^static/(?P<path>.*)$', 'django.views.static.serve', {'document_root': settings.STATIC_PATH}), )<|fim▁end|>
# -*- coding: utf-8 -*- """proyectoP4 URL Configuration
<|file_name|>urls.py<|end_file_name|><|fim▁begin|># -*- coding: utf-8 -*- """proyectoP4 URL Configuration The `urlpatterns` list routes URLs to views. For more information please see: https://docs.djangoproject.com/en/1.8/topics/http/urls/ Examples: Function views 1. Add an import: from my_app import views 2. Add a URL to urlpatterns: url(r'^$', views.home, name='home') Class-based views 1. Add an import: from other_app.views import Home 2. Add a URL to urlpatterns: url(r'^$', Home.as_view(), name='home') Including another URLconf 1. Add an import: from blog import urls as blog_urls 2. Add a URL to urlpatterns: url(r'^blog/', include(blog_urls)) """ from django.conf.urls import include, url, patterns from django.contrib import admin from Workinout import views from django.conf import settings urlpatterns = [ url(r'^admin/', include(admin.site.urls)), url(r'^Workinout/', include('Workinout.urls')), # ADD THIS NEW TUPLE!media/(?P<path>.*) ] if settings.DEBUG: <|fim_middle|> else: urlpatterns += patterns('', url(r'^static/(?P<path>.*)$', 'django.views.static.serve', {'document_root': settings.STATIC_PATH}), ) <|fim▁end|>
urlpatterns += patterns( 'django.views.static', (r'media/(?P<path>.*)', 'serve', {'document_root': settings.MEDIA_ROOT}), )
<|file_name|>urls.py<|end_file_name|><|fim▁begin|># -*- coding: utf-8 -*- """proyectoP4 URL Configuration The `urlpatterns` list routes URLs to views. For more information please see: https://docs.djangoproject.com/en/1.8/topics/http/urls/ Examples: Function views 1. Add an import: from my_app import views 2. Add a URL to urlpatterns: url(r'^$', views.home, name='home') Class-based views 1. Add an import: from other_app.views import Home 2. Add a URL to urlpatterns: url(r'^$', Home.as_view(), name='home') Including another URLconf 1. Add an import: from blog import urls as blog_urls 2. Add a URL to urlpatterns: url(r'^blog/', include(blog_urls)) """ from django.conf.urls import include, url, patterns from django.contrib import admin from Workinout import views from django.conf import settings urlpatterns = [ url(r'^admin/', include(admin.site.urls)), url(r'^Workinout/', include('Workinout.urls')), # ADD THIS NEW TUPLE!media/(?P<path>.*) ] if settings.DEBUG: urlpatterns += patterns( 'django.views.static', (r'media/(?P<path>.*)', 'serve', {'document_root': settings.MEDIA_ROOT}), ) else: <|fim_middle|> <|fim▁end|>
urlpatterns += patterns('', url(r'^static/(?P<path>.*)$', 'django.views.static.serve', {'document_root': settings.STATIC_PATH}), )
<|file_name|>R6.1A.py<|end_file_name|><|fim▁begin|># Given the list values = [] , write code that fills the list with each set of numbers below. # a.1 2 3 4 5 6 7 8 9 10 list = [] <|fim▁hole|> list.append(i) print(list)<|fim▁end|>
for i in range(11):
<|file_name|>q2.py<|end_file_name|><|fim▁begin|>test = { 'name': 'Question 2', 'points': 2, 'suites': [ { 'type': 'sqlite', 'setup': r""" sqlite> .open hw1.db """, 'cases': [ { 'code': r""" sqlite> select * from colors; red|primary blue|primary green|secondary yellow|primary """, }, {<|fim▁hole|> 'code': r""" sqlite> select color from colors; red blue green yellow """, }, ], } ] }<|fim▁end|>
<|file_name|>plot_afq_reco80.py<|end_file_name|><|fim▁begin|>""" ========================== RecoBundles80 using AFQ API ========================== An example using the AFQ API to run recobundles with the `80 bundle atlas <https://figshare.com/articles/Advanced_Atlas_of_80_Bundles_in_MNI_space/7375883>`_. """ import os.path as op import plotly from AFQ.api.group import GroupAFQ import AFQ.data.fetch as afd ########################################################################## # Get some example data # --------------------- # # Retrieves `Stanford HARDI dataset <https://purl.stanford.edu/ng782rw8378>`_. #<|fim▁hole|>afd.organize_stanford_data(clear_previous_afq=True) ########################################################################## # Set tractography parameters (optional) # --------------------- # We make this tracking_params which we will pass to the AFQ object # which specifies that we want 50,000 seeds randomly distributed # in the white matter. # # We only do this to make this example faster and consume less space. tracking_params = dict(n_seeds=50000, random_seeds=True, rng_seed=42) ########################################################################## # Initialize an AFQ object: # ------------------------- # # We specify seg_algo as reco80 in segmentation_params. This tells the AFQ # object to perform RecoBundles using the 80 bundles atlas in the # segmentation step. myafq = GroupAFQ(bids_path=op.join(afd.afq_home, 'stanford_hardi'), preproc_pipeline='vistasoft', segmentation_params={"seg_algo": "reco80"}, tracking_params=tracking_params) ########################################################################## # Visualizing bundles and tract profiles: # --------------------------------------- # This would run the script and visualize the bundles using the plotly # interactive visualization, which should automatically open in a # new browser window. bundle_html = myafq.all_bundles_figure plotly.io.show(bundle_html["01"])<|fim▁end|>
<|file_name|>setup.py<|end_file_name|><|fim▁begin|>from setuptools import setup, find_packages setup( name = "CyprjToMakefile", version = "0.1", author = "Simon Marchi", author_email = "[email protected]", description = "Generate Makefiles from Cypress cyprj files.", license = "GPLv3", url = "https://github.com/simark/cyprj-to-makefile", packages = find_packages(), install_requires = ['jinja2'], package_data = { 'cyprj_to_makefile': ['Makefile.tpl'], },<|fim▁hole|> ], }, )<|fim▁end|>
entry_points = { 'console_scripts': [ 'cyprj-to-makefile = cyprj_to_makefile.cyprj_to_makefile:main',
<|file_name|>jano.py<|end_file_name|><|fim▁begin|>import sys from services.spawn import MobileTemplate from services.spawn import WeaponTemplate from resources.datatables import WeaponType from resources.datatables import Difficulty from resources.datatables import Options from java.util import Vector def addTemplate(core): mobileTemplate = MobileTemplate() mobileTemplate.setCreatureName('tatooine_opening_jano') mobileTemplate.setLevel(1)<|fim▁hole|> mobileTemplate.setDifficulty(Difficulty.NORMAL) mobileTemplate.setSocialGroup("township") mobileTemplate.setOptionsBitmask(Options.INVULNERABLE | Options.CONVERSABLE) templates = Vector() templates.add('object/mobile/shared_dressed_tatooine_opening_jano.iff') mobileTemplate.setTemplates(templates) weaponTemplates = Vector() weapontemplate = WeaponTemplate('object/weapon/melee/unarmed/shared_unarmed_default.iff', WeaponType.UNARMED, 1.0, 6, 'kinetic') weaponTemplates.add(weapontemplate) mobileTemplate.setWeaponTemplateVector(weaponTemplates) attacks = Vector() mobileTemplate.setDefaultAttack('creatureMeleeAttack') mobileTemplate.setAttacks(attacks) core.spawnService.addMobileTemplate('jano', mobileTemplate) return<|fim▁end|>
<|file_name|>jano.py<|end_file_name|><|fim▁begin|>import sys from services.spawn import MobileTemplate from services.spawn import WeaponTemplate from resources.datatables import WeaponType from resources.datatables import Difficulty from resources.datatables import Options from java.util import Vector def addTemplate(core): <|fim_middle|> <|fim▁end|>
mobileTemplate = MobileTemplate() mobileTemplate.setCreatureName('tatooine_opening_jano') mobileTemplate.setLevel(1) mobileTemplate.setDifficulty(Difficulty.NORMAL) mobileTemplate.setSocialGroup("township") mobileTemplate.setOptionsBitmask(Options.INVULNERABLE | Options.CONVERSABLE) templates = Vector() templates.add('object/mobile/shared_dressed_tatooine_opening_jano.iff') mobileTemplate.setTemplates(templates) weaponTemplates = Vector() weapontemplate = WeaponTemplate('object/weapon/melee/unarmed/shared_unarmed_default.iff', WeaponType.UNARMED, 1.0, 6, 'kinetic') weaponTemplates.add(weapontemplate) mobileTemplate.setWeaponTemplateVector(weaponTemplates) attacks = Vector() mobileTemplate.setDefaultAttack('creatureMeleeAttack') mobileTemplate.setAttacks(attacks) core.spawnService.addMobileTemplate('jano', mobileTemplate) return
<|file_name|>jano.py<|end_file_name|><|fim▁begin|>import sys from services.spawn import MobileTemplate from services.spawn import WeaponTemplate from resources.datatables import WeaponType from resources.datatables import Difficulty from resources.datatables import Options from java.util import Vector def <|fim_middle|>(core): mobileTemplate = MobileTemplate() mobileTemplate.setCreatureName('tatooine_opening_jano') mobileTemplate.setLevel(1) mobileTemplate.setDifficulty(Difficulty.NORMAL) mobileTemplate.setSocialGroup("township") mobileTemplate.setOptionsBitmask(Options.INVULNERABLE | Options.CONVERSABLE) templates = Vector() templates.add('object/mobile/shared_dressed_tatooine_opening_jano.iff') mobileTemplate.setTemplates(templates) weaponTemplates = Vector() weapontemplate = WeaponTemplate('object/weapon/melee/unarmed/shared_unarmed_default.iff', WeaponType.UNARMED, 1.0, 6, 'kinetic') weaponTemplates.add(weapontemplate) mobileTemplate.setWeaponTemplateVector(weaponTemplates) attacks = Vector() mobileTemplate.setDefaultAttack('creatureMeleeAttack') mobileTemplate.setAttacks(attacks) core.spawnService.addMobileTemplate('jano', mobileTemplate) return<|fim▁end|>
addTemplate
<|file_name|>alertview.py<|end_file_name|><|fim▁begin|>import kivy kivy.require('1.9.1') from kivy.uix.popup import Popup from kivy.uix.label import Label from kivy.uix.gridlayout import GridLayout from kivy.metrics import dp from kivy.app import Builder from kivy.properties import StringProperty, ObjectProperty from kivy.clock import Clock from kivy.metrics import sp from kivy.metrics import dp from iconbutton import IconButton __all__ = ('alertPopup, confirmPopup, okPopup, editor_popup') Builder.load_string(''' <ConfirmPopup>: cols:1 Label: text: root.text GridLayout: cols: 2 size_hint_y: None height: '44sp' spacing: '5sp' IconButton: text: u'\uf00c' on_press: root.dispatch('on_answer', True) IconButton: text: u'\uf00d' color: ColorScheme.get_primary() on_release: root.dispatch('on_answer', False) <OkPopup>: cols:1 Label: text: root.text GridLayout: cols: 2 size_hint_y: None height: '44sp' spacing: '5sp' IconButton: text: u'\uf00c' on_press: root.dispatch('on_answer', True) <EditorPopup>: id: editor_popup cols:1 BoxLayout: id: content GridLayout: id: buttons cols: 2 size_hint_y: None height: '44sp' spacing: '5sp' IconButton: text: u'\uf00c' on_press: root.dispatch('on_answer', True) IconButton: text: u'\uf00d' color: ColorScheme.get_primary() on_release: root.dispatch('on_answer', False) ''') def alertPopup(title, msg): popup = Popup(title = title, content=Label(text = msg), size_hint=(None, None), size=(dp(600), dp(200))) popup.open() def confirmPopup(title, msg, answerCallback): content = ConfirmPopup(text=msg) content.bind(on_answer=answerCallback) popup = Popup(title=title, content=content, size_hint=(None, None), size=(dp(600),dp(200)), auto_dismiss= False) popup.open() return popup class ConfirmPopup(GridLayout): text = StringProperty() def __init__(self,**kwargs): self.register_event_type('on_answer') super(ConfirmPopup,self).__init__(**kwargs) def on_answer(self, *args): pass def editor_popup(title, content, answerCallback): content = EditorPopup(content=content) content.bind(on_answer=answerCallback) popup = Popup(title=title, content=content, size_hint=(0.7, 0.8), auto_dismiss= False, title_size=sp(18)) popup.open() return popup class EditorPopup(GridLayout): content = ObjectProperty(None) def __init__(self,**kwargs): self.register_event_type('on_answer') super(EditorPopup,self).__init__(**kwargs) def on_content(self, instance, value): Clock.schedule_once(lambda dt: self.ids.content.add_widget(value)) def on_answer(self, *args): pass def okPopup(title, msg, answerCallback): content = OkPopup(text=msg) content.bind(on_ok=answerCallback) popup = Popup(title=title, content=content, size_hint=(None, None), size=(dp(600),dp(200)), auto_dismiss= False) popup.open() return popup class OkPopup(GridLayout): text = StringProperty() def __init__(self,**kwargs): self.register_event_type('on_ok') super(OkPopup,self).__init__(**kwargs) <|fim▁hole|> def on_ok(self, *args): pass<|fim▁end|>
<|file_name|>alertview.py<|end_file_name|><|fim▁begin|>import kivy kivy.require('1.9.1') from kivy.uix.popup import Popup from kivy.uix.label import Label from kivy.uix.gridlayout import GridLayout from kivy.metrics import dp from kivy.app import Builder from kivy.properties import StringProperty, ObjectProperty from kivy.clock import Clock from kivy.metrics import sp from kivy.metrics import dp from iconbutton import IconButton __all__ = ('alertPopup, confirmPopup, okPopup, editor_popup') Builder.load_string(''' <ConfirmPopup>: cols:1 Label: text: root.text GridLayout: cols: 2 size_hint_y: None height: '44sp' spacing: '5sp' IconButton: text: u'\uf00c' on_press: root.dispatch('on_answer', True) IconButton: text: u'\uf00d' color: ColorScheme.get_primary() on_release: root.dispatch('on_answer', False) <OkPopup>: cols:1 Label: text: root.text GridLayout: cols: 2 size_hint_y: None height: '44sp' spacing: '5sp' IconButton: text: u'\uf00c' on_press: root.dispatch('on_answer', True) <EditorPopup>: id: editor_popup cols:1 BoxLayout: id: content GridLayout: id: buttons cols: 2 size_hint_y: None height: '44sp' spacing: '5sp' IconButton: text: u'\uf00c' on_press: root.dispatch('on_answer', True) IconButton: text: u'\uf00d' color: ColorScheme.get_primary() on_release: root.dispatch('on_answer', False) ''') def alertPopup(title, msg): <|fim_middle|> def confirmPopup(title, msg, answerCallback): content = ConfirmPopup(text=msg) content.bind(on_answer=answerCallback) popup = Popup(title=title, content=content, size_hint=(None, None), size=(dp(600),dp(200)), auto_dismiss= False) popup.open() return popup class ConfirmPopup(GridLayout): text = StringProperty() def __init__(self,**kwargs): self.register_event_type('on_answer') super(ConfirmPopup,self).__init__(**kwargs) def on_answer(self, *args): pass def editor_popup(title, content, answerCallback): content = EditorPopup(content=content) content.bind(on_answer=answerCallback) popup = Popup(title=title, content=content, size_hint=(0.7, 0.8), auto_dismiss= False, title_size=sp(18)) popup.open() return popup class EditorPopup(GridLayout): content = ObjectProperty(None) def __init__(self,**kwargs): self.register_event_type('on_answer') super(EditorPopup,self).__init__(**kwargs) def on_content(self, instance, value): Clock.schedule_once(lambda dt: self.ids.content.add_widget(value)) def on_answer(self, *args): pass def okPopup(title, msg, answerCallback): content = OkPopup(text=msg) content.bind(on_ok=answerCallback) popup = Popup(title=title, content=content, size_hint=(None, None), size=(dp(600),dp(200)), auto_dismiss= False) popup.open() return popup class OkPopup(GridLayout): text = StringProperty() def __init__(self,**kwargs): self.register_event_type('on_ok') super(OkPopup,self).__init__(**kwargs) def on_ok(self, *args): pass <|fim▁end|>
popup = Popup(title = title, content=Label(text = msg), size_hint=(None, None), size=(dp(600), dp(200))) popup.open()
<|file_name|>alertview.py<|end_file_name|><|fim▁begin|>import kivy kivy.require('1.9.1') from kivy.uix.popup import Popup from kivy.uix.label import Label from kivy.uix.gridlayout import GridLayout from kivy.metrics import dp from kivy.app import Builder from kivy.properties import StringProperty, ObjectProperty from kivy.clock import Clock from kivy.metrics import sp from kivy.metrics import dp from iconbutton import IconButton __all__ = ('alertPopup, confirmPopup, okPopup, editor_popup') Builder.load_string(''' <ConfirmPopup>: cols:1 Label: text: root.text GridLayout: cols: 2 size_hint_y: None height: '44sp' spacing: '5sp' IconButton: text: u'\uf00c' on_press: root.dispatch('on_answer', True) IconButton: text: u'\uf00d' color: ColorScheme.get_primary() on_release: root.dispatch('on_answer', False) <OkPopup>: cols:1 Label: text: root.text GridLayout: cols: 2 size_hint_y: None height: '44sp' spacing: '5sp' IconButton: text: u'\uf00c' on_press: root.dispatch('on_answer', True) <EditorPopup>: id: editor_popup cols:1 BoxLayout: id: content GridLayout: id: buttons cols: 2 size_hint_y: None height: '44sp' spacing: '5sp' IconButton: text: u'\uf00c' on_press: root.dispatch('on_answer', True) IconButton: text: u'\uf00d' color: ColorScheme.get_primary() on_release: root.dispatch('on_answer', False) ''') def alertPopup(title, msg): popup = Popup(title = title, content=Label(text = msg), size_hint=(None, None), size=(dp(600), dp(200))) popup.open() def confirmPopup(title, msg, answerCallback): <|fim_middle|> class ConfirmPopup(GridLayout): text = StringProperty() def __init__(self,**kwargs): self.register_event_type('on_answer') super(ConfirmPopup,self).__init__(**kwargs) def on_answer(self, *args): pass def editor_popup(title, content, answerCallback): content = EditorPopup(content=content) content.bind(on_answer=answerCallback) popup = Popup(title=title, content=content, size_hint=(0.7, 0.8), auto_dismiss= False, title_size=sp(18)) popup.open() return popup class EditorPopup(GridLayout): content = ObjectProperty(None) def __init__(self,**kwargs): self.register_event_type('on_answer') super(EditorPopup,self).__init__(**kwargs) def on_content(self, instance, value): Clock.schedule_once(lambda dt: self.ids.content.add_widget(value)) def on_answer(self, *args): pass def okPopup(title, msg, answerCallback): content = OkPopup(text=msg) content.bind(on_ok=answerCallback) popup = Popup(title=title, content=content, size_hint=(None, None), size=(dp(600),dp(200)), auto_dismiss= False) popup.open() return popup class OkPopup(GridLayout): text = StringProperty() def __init__(self,**kwargs): self.register_event_type('on_ok') super(OkPopup,self).__init__(**kwargs) def on_ok(self, *args): pass <|fim▁end|>
content = ConfirmPopup(text=msg) content.bind(on_answer=answerCallback) popup = Popup(title=title, content=content, size_hint=(None, None), size=(dp(600),dp(200)), auto_dismiss= False) popup.open() return popup
<|file_name|>alertview.py<|end_file_name|><|fim▁begin|>import kivy kivy.require('1.9.1') from kivy.uix.popup import Popup from kivy.uix.label import Label from kivy.uix.gridlayout import GridLayout from kivy.metrics import dp from kivy.app import Builder from kivy.properties import StringProperty, ObjectProperty from kivy.clock import Clock from kivy.metrics import sp from kivy.metrics import dp from iconbutton import IconButton __all__ = ('alertPopup, confirmPopup, okPopup, editor_popup') Builder.load_string(''' <ConfirmPopup>: cols:1 Label: text: root.text GridLayout: cols: 2 size_hint_y: None height: '44sp' spacing: '5sp' IconButton: text: u'\uf00c' on_press: root.dispatch('on_answer', True) IconButton: text: u'\uf00d' color: ColorScheme.get_primary() on_release: root.dispatch('on_answer', False) <OkPopup>: cols:1 Label: text: root.text GridLayout: cols: 2 size_hint_y: None height: '44sp' spacing: '5sp' IconButton: text: u'\uf00c' on_press: root.dispatch('on_answer', True) <EditorPopup>: id: editor_popup cols:1 BoxLayout: id: content GridLayout: id: buttons cols: 2 size_hint_y: None height: '44sp' spacing: '5sp' IconButton: text: u'\uf00c' on_press: root.dispatch('on_answer', True) IconButton: text: u'\uf00d' color: ColorScheme.get_primary() on_release: root.dispatch('on_answer', False) ''') def alertPopup(title, msg): popup = Popup(title = title, content=Label(text = msg), size_hint=(None, None), size=(dp(600), dp(200))) popup.open() def confirmPopup(title, msg, answerCallback): content = ConfirmPopup(text=msg) content.bind(on_answer=answerCallback) popup = Popup(title=title, content=content, size_hint=(None, None), size=(dp(600),dp(200)), auto_dismiss= False) popup.open() return popup class ConfirmPopup(GridLayout): <|fim_middle|> def editor_popup(title, content, answerCallback): content = EditorPopup(content=content) content.bind(on_answer=answerCallback) popup = Popup(title=title, content=content, size_hint=(0.7, 0.8), auto_dismiss= False, title_size=sp(18)) popup.open() return popup class EditorPopup(GridLayout): content = ObjectProperty(None) def __init__(self,**kwargs): self.register_event_type('on_answer') super(EditorPopup,self).__init__(**kwargs) def on_content(self, instance, value): Clock.schedule_once(lambda dt: self.ids.content.add_widget(value)) def on_answer(self, *args): pass def okPopup(title, msg, answerCallback): content = OkPopup(text=msg) content.bind(on_ok=answerCallback) popup = Popup(title=title, content=content, size_hint=(None, None), size=(dp(600),dp(200)), auto_dismiss= False) popup.open() return popup class OkPopup(GridLayout): text = StringProperty() def __init__(self,**kwargs): self.register_event_type('on_ok') super(OkPopup,self).__init__(**kwargs) def on_ok(self, *args): pass <|fim▁end|>
text = StringProperty() def __init__(self,**kwargs): self.register_event_type('on_answer') super(ConfirmPopup,self).__init__(**kwargs) def on_answer(self, *args): pass
<|file_name|>alertview.py<|end_file_name|><|fim▁begin|>import kivy kivy.require('1.9.1') from kivy.uix.popup import Popup from kivy.uix.label import Label from kivy.uix.gridlayout import GridLayout from kivy.metrics import dp from kivy.app import Builder from kivy.properties import StringProperty, ObjectProperty from kivy.clock import Clock from kivy.metrics import sp from kivy.metrics import dp from iconbutton import IconButton __all__ = ('alertPopup, confirmPopup, okPopup, editor_popup') Builder.load_string(''' <ConfirmPopup>: cols:1 Label: text: root.text GridLayout: cols: 2 size_hint_y: None height: '44sp' spacing: '5sp' IconButton: text: u'\uf00c' on_press: root.dispatch('on_answer', True) IconButton: text: u'\uf00d' color: ColorScheme.get_primary() on_release: root.dispatch('on_answer', False) <OkPopup>: cols:1 Label: text: root.text GridLayout: cols: 2 size_hint_y: None height: '44sp' spacing: '5sp' IconButton: text: u'\uf00c' on_press: root.dispatch('on_answer', True) <EditorPopup>: id: editor_popup cols:1 BoxLayout: id: content GridLayout: id: buttons cols: 2 size_hint_y: None height: '44sp' spacing: '5sp' IconButton: text: u'\uf00c' on_press: root.dispatch('on_answer', True) IconButton: text: u'\uf00d' color: ColorScheme.get_primary() on_release: root.dispatch('on_answer', False) ''') def alertPopup(title, msg): popup = Popup(title = title, content=Label(text = msg), size_hint=(None, None), size=(dp(600), dp(200))) popup.open() def confirmPopup(title, msg, answerCallback): content = ConfirmPopup(text=msg) content.bind(on_answer=answerCallback) popup = Popup(title=title, content=content, size_hint=(None, None), size=(dp(600),dp(200)), auto_dismiss= False) popup.open() return popup class ConfirmPopup(GridLayout): text = StringProperty() def __init__(self,**kwargs): <|fim_middle|> def on_answer(self, *args): pass def editor_popup(title, content, answerCallback): content = EditorPopup(content=content) content.bind(on_answer=answerCallback) popup = Popup(title=title, content=content, size_hint=(0.7, 0.8), auto_dismiss= False, title_size=sp(18)) popup.open() return popup class EditorPopup(GridLayout): content = ObjectProperty(None) def __init__(self,**kwargs): self.register_event_type('on_answer') super(EditorPopup,self).__init__(**kwargs) def on_content(self, instance, value): Clock.schedule_once(lambda dt: self.ids.content.add_widget(value)) def on_answer(self, *args): pass def okPopup(title, msg, answerCallback): content = OkPopup(text=msg) content.bind(on_ok=answerCallback) popup = Popup(title=title, content=content, size_hint=(None, None), size=(dp(600),dp(200)), auto_dismiss= False) popup.open() return popup class OkPopup(GridLayout): text = StringProperty() def __init__(self,**kwargs): self.register_event_type('on_ok') super(OkPopup,self).__init__(**kwargs) def on_ok(self, *args): pass <|fim▁end|>
self.register_event_type('on_answer') super(ConfirmPopup,self).__init__(**kwargs)