text_prompt
stringlengths 157
13.1k
| code_prompt
stringlengths 7
19.8k
⌀ |
|---|---|
<SYSTEM_TASK:>
Solve the following problem using Python, implementing the functions described below, one line at a time
<END_TASK>
<USER_TASK:>
Description:
def record_id(self, record, type_=None, selector=None):
"""Retrieve an object identifier from the given record; if it is an alien class, and the type is provided, then use duck typing to get the corresponding fields of the alien class."""
|
pk = record_id(record, type_, selector, self.normalize_object_slot)
return pk
|
<SYSTEM_TASK:>
Solve the following problem using Python, implementing the functions described below, one line at a time
<END_TASK>
<USER_TASK:>
Description:
def fastcc(model, epsilon, solver):
"""Check consistency of model reactions. Yield all reactions in the model that are not part of the consistent subset. Args: model: :class:`MetabolicModel` to solve. epsilon: Flux threshold value. solver: LP solver instance to use. """
|
reaction_set = set(model.reactions)
subset = set(reaction_id for reaction_id in reaction_set
if model.limits[reaction_id].lower >= 0)
logger.info('Checking {} irreversible reactions...'.format(len(subset)))
logger.debug('|J| = {}, J = {}'.format(len(subset), subset))
p = FastcoreProblem(model, solver, epsilon=epsilon)
p.lp7(subset)
consistent_subset = set(
reaction_id for reaction_id in model.reactions
if abs(p.get_flux(reaction_id)) >= 0.999 * epsilon)
logger.debug('|A| = {}, A = {}'.format(
len(consistent_subset), consistent_subset))
for reaction in subset - consistent_subset:
# Inconsistent reaction
yield reaction
# Check remaining reactions
subset = (reaction_set - subset) - consistent_subset
logger.info('Checking reversible reactions...')
logger.debug('|J| = {}, J = {}'.format(len(subset), subset))
flipped = False
singleton = False
while len(subset) > 0:
logger.info('{} reversible reactions left to check...'.format(
len(subset)))
if singleton:
reaction = next(iter(subset))
subset_i = {reaction}
logger.debug('LP3 on {}'.format(subset_i))
p.maximize({reaction: -1 if p.is_flipped(reaction) else 1})
else:
subset_i = subset
logger.debug('LP7 on {}'.format(subset_i))
p.lp7(subset_i)
consistent_subset.update(
reaction_id for reaction_id in subset
if abs(p.get_flux(reaction_id) >= 0.999 * epsilon))
logger.debug('|A| = {}, A = {}'.format(
len(consistent_subset), consistent_subset))
if not subset.isdisjoint(consistent_subset):
subset -= consistent_subset
logger.debug('|J| = {}, J = {}'.format(len(subset), subset))
flipped = False
else:
# TODO: irreversible reactions are taken care of before the
# loop so at this point all reactions in subset_i are reversble(?).
subset_rev_i = subset_i & model.reversible
if flipped or len(subset_rev_i) == 0:
flipped = False
if singleton:
subset -= subset_rev_i
for reaction in subset_rev_i:
logger.info('Inconsistent: {}'.format(reaction))
yield reaction
else:
singleton = True
else:
p.flip(subset_rev_i)
flipped = True
logger.info('Flipped {} reactions'.format(len(subset_rev_i)))
|
<SYSTEM_TASK:>
Solve the following problem using Python, implementing the functions described below, one line at a time
<END_TASK>
<USER_TASK:>
Description:
def fastcc_is_consistent(model, epsilon, solver):
"""Quickly check whether model is consistent Return true if the model is consistent. If it is only necessary to know whether a model is consistent, this function is fast as it will return the result as soon as it finds a single inconsistent reaction. Args: model: :class:`MetabolicModel` to solve. epsilon: Flux threshold value. solver: LP solver instance to use. """
|
for reaction in fastcc(model, epsilon, solver):
return False
return True
|
<SYSTEM_TASK:>
Solve the following problem using Python, implementing the functions described below, one line at a time
<END_TASK>
<USER_TASK:>
Description:
def fastcc_consistent_subset(model, epsilon, solver):
"""Return consistent subset of model. The largest consistent subset is returned as a set of reaction names. Args: model: :class:`MetabolicModel` to solve. epsilon: Flux threshold value. solver: LP solver instance to use. Returns: Set of reaction IDs in the consistent reaction subset. """
|
reaction_set = set(model.reactions)
return reaction_set.difference(fastcc(model, epsilon, solver))
|
<SYSTEM_TASK:>
Solve the following problem using Python, implementing the functions described below, one line at a time
<END_TASK>
<USER_TASK:>
Description:
def fastcore(model, core, epsilon, solver, scaling=1e5, weights={}):
"""Find a flux consistent subnetwork containing the core subset. The result will contain the core subset and as few of the additional reactions as possible. Args: model: :class:`MetabolicModel` to solve. core: Set of core reaction IDs. epsilon: Flux threshold value. solver: LP solver instance to use. scaling: Scaling value to apply (see [Vlassis14]_ for more information on this parameter). weights: Dictionary with reaction IDs as keys and values as weights. Weights specify the cost of adding a reaction to the consistent subnetwork. Default value is 1. Returns: Set of reaction IDs in the consistent reaction subset. """
|
consistent_subset = set()
reaction_set = set(model.reactions)
subset = core - model.reversible
logger.debug('|J| = {}, J = {}'.format(len(subset), subset))
penalty_set = reaction_set - core
logger.debug('|P| = {}, P = {}'.format(len(penalty_set), penalty_set))
p = FastcoreProblem(model, solver, epsilon=epsilon)
mode = set(p.find_sparse_mode(subset, penalty_set, scaling, weights))
if not subset.issubset(mode):
raise FastcoreError('Inconsistent irreversible core reactions:'
' {}'.format(subset - mode))
consistent_subset |= mode
logger.debug('|A| = {}, A = {}'.format(
len(consistent_subset), consistent_subset))
subset = core - mode
logger.debug('|J| = {}, J = {}'.format(len(subset), subset))
flipped = False
singleton = False
while len(subset) > 0:
penalty_set -= consistent_subset
if singleton:
subset_i = set((next(iter(subset)),))
else:
subset_i = subset
mode = set(p.find_sparse_mode(subset_i, penalty_set, scaling, weights))
consistent_subset.update(mode)
logger.debug('|A| = {}, A = {}'.format(
len(consistent_subset), consistent_subset))
if not subset.isdisjoint(consistent_subset):
logger.debug('Subset improved {} -> {}'.format(
len(subset), len(subset - consistent_subset)))
subset -= consistent_subset
logger.debug('|J| = {}, J = {}'.format(len(subset), subset))
flipped = False
else:
logger.debug('Nothing found, changing state...')
subset_rev_i = subset_i & model.reversible
if flipped or len(subset_rev_i) == 0:
if singleton:
raise FastcoreError('Global network inconsistent:'
' {}'.format(subset_rev_i))
logger.debug('Going to non-flipped, singleton state...')
singleton = True
flipped = False
else:
p.flip(subset_rev_i)
flipped = True
logger.debug('Flipped {} reactions'.format(
len(subset_rev_i)))
return consistent_subset
|
<SYSTEM_TASK:>
Solve the following problem using Python, implementing the functions described below, one line at a time
<END_TASK>
<USER_TASK:>
Description:
def lp7(self, reaction_subset):
"""Approximately maximize the number of reaction with flux. This is similar to FBA but approximately maximizing the number of reactions in subset with flux > epsilon, instead of just maximizing the flux of one particular reaction. LP7 prefers "flux splitting" over "flux concentrating". """
|
if self._zl is None:
self._add_maximization_vars()
positive = set(reaction_subset) - self._flipped
negative = set(reaction_subset) & self._flipped
v = self._v.set(positive)
zl = self._zl.set(positive)
cs = self._prob.add_linear_constraints(v >= zl)
self._temp_constr.extend(cs)
v = self._v.set(negative)
zl = self._zl.set(negative)
cs = self._prob.add_linear_constraints(v <= -zl)
self._temp_constr.extend(cs)
self._prob.set_objective(self._zl.sum(reaction_subset))
self._solve()
|
<SYSTEM_TASK:>
Solve the following problem using Python, implementing the functions described below, one line at a time
<END_TASK>
<USER_TASK:>
Description:
def lp10(self, subset_k, subset_p, weights={}):
"""Force reactions in K above epsilon while minimizing support of P. This program forces reactions in subset K to attain flux > epsilon while minimizing the sum of absolute flux values for reactions in subset P (L1-regularization). """
|
if self._z is None:
self._add_minimization_vars()
positive = set(subset_k) - self._flipped
negative = set(subset_k) & self._flipped
v = self._v.set(positive)
cs = self._prob.add_linear_constraints(v >= self._epsilon)
self._temp_constr.extend(cs)
v = self._v.set(negative)
cs = self._prob.add_linear_constraints(v <= -self._epsilon)
self._temp_constr.extend(cs)
self._prob.set_objective(self._z.expr(
(rxnid, -weights.get(rxnid, 1)) for rxnid in subset_p))
self._solve()
|
<SYSTEM_TASK:>
Solve the following problem using Python, implementing the functions described below, one line at a time
<END_TASK>
<USER_TASK:>
Description:
def find_sparse_mode(self, core, additional, scaling, weights={}):
"""Find a sparse mode containing reactions of the core subset. Return an iterator of the support of a sparse mode that contains as many reactions from core as possible, and as few reactions from additional as possible (approximately). A dictionary of weights can be supplied which gives further penalties for including specific additional reactions. """
|
if len(core) == 0:
return
self.lp7(core)
k = set()
for reaction_id in core:
flux = self.get_flux(reaction_id)
if self.is_flipped(reaction_id):
flux *= -1
if flux >= self._epsilon:
k.add(reaction_id)
if len(k) == 0:
return
self.lp10(k, additional, weights)
for reaction_id in self._model.reactions:
flux = self.get_flux(reaction_id)
if abs(flux) >= self._epsilon / scaling:
yield reaction_id
|
<SYSTEM_TASK:>
Solve the following problem using Python, implementing the functions described below, one line at a time
<END_TASK>
<USER_TASK:>
Description:
def flip(self, reactions):
"""Flip the specified reactions."""
|
for reaction in reactions:
if reaction in self._flipped:
self._flipped.remove(reaction)
else:
self._flipped.add(reaction)
|
<SYSTEM_TASK:>
Solve the following problem using Python, implementing the functions described below, one line at a time
<END_TASK>
<USER_TASK:>
Description:
def _jaccard_similarity(f1, f2, weight_func):
"""Calculate generalized Jaccard similarity of formulas. Returns the weighted similarity value or None if there is no overlap at all. If the union of the formulas has a weight of zero (i.e. the denominator in the Jaccard similarity is zero), a value of zero is returned. """
|
elements = set(f1)
elements.update(f2)
count, w_count, w_total = 0, 0, 0
for element in elements:
mi = min(f1.get(element, 0), f2.get(element, 0))
mx = max(f1.get(element, 0), f2.get(element, 0))
count += mi
w = weight_func(element)
w_count += w * mi
w_total += w * mx
if count == 0:
return None
return 0.0 if w_total == 0.0 else w_count / w_total
|
<SYSTEM_TASK:>
Solve the following problem using Python, implementing the functions described below, one line at a time
<END_TASK>
<USER_TASK:>
Description:
def predict_compound_pairs_iterated( reactions, formulas, prior=(1, 43), max_iterations=None, element_weight=element_weight):
"""Predict reaction pairs using iterated method. Returns a tuple containing a dictionary of predictions keyed by the reaction IDs, and the final number of iterations. Each reaction prediction entry contains a tuple with a dictionary of transfers and a dictionary of unbalanced compounds. The dictionary of unbalanced compounds is empty only if the reaction is balanced. Args: reactions: Dictionary or pair-iterable of (id, equation) pairs. IDs must be any hashable reaction identifier (e.g. string) and equation must be :class:`psamm.reaction.Reaction` objects. formulas: Dictionary mapping compound IDs to :class:`psamm.formula.Formula`. Formulas must be flattened. prior: Tuple of (alpha, beta) parameters for the MAP inference. If not provided, the default parameters will be used: (1, 43). max_iterations: Maximum iterations to run before stopping. If the stopping condition is reached before this number of iterations, the procedure also stops. If None, the procedure only stops when the stopping condition is reached. element_weight: A function providing returning weight value for the given :class:`psamm.formula.Atom` or :class:`psamm.formula.Radical`. If not provided, the default weight will be used (H=0, C=1, *=0.82) """
|
prior_alpha, prior_beta = prior
reactions = dict(reactions)
pair_reactions = {}
possible_pairs = Counter()
for reaction_id, equation in iteritems(reactions):
for (c1, _), (c2, _) in product(equation.left, equation.right):
spair = tuple(sorted([c1.name, c2.name]))
possible_pairs[spair] += 1
pair_reactions.setdefault(spair, set()).add(reaction_id)
next_reactions = set(reactions)
pairs_predicted = None
prediction = {}
weights = {}
iteration = 0
while len(next_reactions) > 0:
iteration += 1
if max_iterations is not None and iteration > max_iterations:
break
logger.info('Iteration {}: {} reactions...'.format(
iteration, len(next_reactions)))
for reaction_id in next_reactions:
result = predict_compound_pairs(
reactions[reaction_id], formulas, weights, element_weight)
if result is None:
continue
transfer, balance = result
rpairs = {}
for ((c1, _), (c2, _)), form in iteritems(transfer):
rpairs.setdefault((c1, c2), []).append(form)
prediction[reaction_id] = rpairs, balance
pairs_predicted = Counter()
for reaction_id, (rpairs, _) in iteritems(prediction):
for c1, c2 in rpairs:
spair = tuple(sorted([c1.name, c2.name]))
pairs_predicted[spair] += 1
next_reactions = set()
for spair, total in sorted(iteritems(possible_pairs)):
pred = pairs_predicted[spair]
# The weight is set to the maximum a posteriori (MAP) estimate
# of the primary pair probability distribution.
posterior_alpha = prior_alpha + pred
posterior_beta = prior_beta + total - pred
pair_weight = ((posterior_alpha - 1) /
(posterior_alpha + posterior_beta - 2))
if (spair not in weights or
abs(pair_weight - weights[spair]) > 1e-5):
next_reactions.update(pair_reactions[spair])
c1, c2 = spair
weights[c1, c2] = pair_weight
weights[c2, c1] = pair_weight
return prediction, iteration
|
<SYSTEM_TASK:>
Solve the following problem using Python, implementing the functions described below, one line at a time
<END_TASK>
<USER_TASK:>
Description:
def predict_compound_pairs(reaction, compound_formula, pair_weights={}, weight_func=element_weight):
"""Predict compound pairs for a single reaction. Performs greedy matching on reaction compounds using a scoring function that uses generalized Jaccard similarity corrected by the weights in the given dictionary. Returns a tuple of a transfer dictionary and a dictionary of unbalanced compounds. The dictionary of unbalanced compounds is empty only if the reaction is balanced. Args: reaction: :class:`psamm.reaction.Reaction`. compound_formula: Dictionary mapping compound IDs to :class:`psamm.formula.Formula`. Formulas must be flattened. pair_weights: Dictionary mapping pairs of compound IDs to correction values. This value is multiplied by the calculated Jaccard similarity. If a pair is not in the dictionary, the value 1 is used. Pairs are looked up in the weights dictionary as a tuple of compound names (``c1``, ``c2``) where ``c1`` is the left-hand side and ``c2`` is the right-hand side. weight_func: Weight function for caclulating the generalized Jaccard similarity. This function will be given an :class:`psamm.formula.Atom` or :class:`psamm.formula.Radical` and should return a corresponding weight. """
|
def score_func(inst1, inst2):
score = _jaccard_similarity(
inst1.formula, inst2.formula, weight_func)
if score is None:
return None
pair = inst1.compound.name, inst2.compound.name
pair_weight = pair_weights.get(pair, 1.0)
return pair_weight * score
return _match_greedily(reaction, compound_formula, score_func)
|
<SYSTEM_TASK:>
Solve the following problem using Python, implementing the functions described below, one line at a time
<END_TASK>
<USER_TASK:>
Description:
def config_get(option_name):
""" Helper to access a Juju config option when charmhelpers is not available. :param str option_name: Name of the config option to get the value of """
|
try:
raw = subprocess.check_output(['config-get', option_name, '--format=yaml'])
return yaml.load(raw.decode('UTF-8'))
except ValueError:
return None
|
<SYSTEM_TASK:>
Solve the following problem using Python, implementing the functions described below, one line at a time
<END_TASK>
<USER_TASK:>
Description:
def fetch(which=None, mirror_url=None, resources_yaml='resources.yaml', force=False, reporthook=None):
""" Attempt to fetch all resources for a charm. :param list which: A name, or a list of one or more resource names, to fetch. If ommitted, all non-optional resources are fetched. You can also pass ``jujuresources.ALL`` to fetch all optional *and* required resources. :param str mirror_url: Fetch resources from the given mirror. :param str resources_yaml: Location of the yaml file containing the resource descriptions (default: ``./resources.yaml``). Can be a local file name or a remote URL. :param force bool: Force re-downloading of valid resources. :param func reporthook: Callback for reporting download progress. Will be called once for each resource, just prior to fetching, and will be passed the resource name. :return: True or False indicating whether the resources were successfully downloaded. """
|
resources = _load(resources_yaml, None)
if reporthook is None:
reporthook = lambda r: juju_log('Fetching %s' % r, level='INFO')
_fetch(resources, which, mirror_url, force, reporthook)
failed = _invalid(resources, which)
if failed:
juju_log('Failed to fetch resource%s: %s' % (
's' if len(failed) > 1 else '',
', '.join(failed)
), level='WARNING')
else:
juju_log('All resources successfully fetched', level='INFO')
return not failed
|
<SYSTEM_TASK:>
Solve the following problem using Python, implementing the functions described below, one line at a time
<END_TASK>
<USER_TASK:>
Description:
def rate(wait=MIN_WAIT, reps=REPS):
""" Rate limit a command function. :param wait: How long to wait between commands. :param reps: How many times to send a command. :returns: Decorator. """
|
def decorator(function):
""" Decorator function.
:returns: Wrapper.
"""
def wrapper(self, *args, **kwargs):
""" Wrapper.
:param args: Passthrough positional arguments.
:param kwargs: Passthrough keyword arguments.
"""
saved_wait = self.wait
saved_reps = self.reps
self.wait = wait
self.reps = reps
function(self, *args, **kwargs)
self.wait = saved_wait
self.reps = saved_reps
return wrapper
return decorator
|
<SYSTEM_TASK:>
Solve the following problem using Python, implementing the functions described below, one line at a time
<END_TASK>
<USER_TASK:>
Description:
def on(self, state):
""" Turn on or off. :param state: True (on) or False (off). """
|
self._on = state
cmd = self.command_set.off()
if state:
cmd = self.command_set.on()
self.send(cmd)
|
<SYSTEM_TASK:>
Solve the following problem using Python, implementing the functions described below, one line at a time
<END_TASK>
<USER_TASK:>
Description:
def flash(self, duration=0.0):
""" Flash a group. :param duration: How quickly to flash (in seconds). """
|
for _ in range(2):
self.on = not self.on
time.sleep(duration)
|
<SYSTEM_TASK:>
Solve the following problem using Python, implementing the functions described below, one line at a time
<END_TASK>
<USER_TASK:>
Description:
def send(self, cmd):
""" Send a command to the bridge. :param cmd: List of command bytes. """
|
self._bridge.send(cmd, wait=self.wait, reps=self.reps)
|
<SYSTEM_TASK:>
Solve the following problem using Python, implementing the functions described below, one line at a time
<END_TASK>
<USER_TASK:>
Description:
def enqueue(self, pipeline):
""" Start a pipeline. :param pipeline: Start this pipeline. """
|
copied = Pipeline().append(pipeline)
copied.group = self
self._queue.put(copied)
|
<SYSTEM_TASK:>
Solve the following problem using Python, implementing the functions described below, one line at a time
<END_TASK>
<USER_TASK:>
Description:
def _wait(self, duration, steps, commands):
""" Compute wait time. :param duration: Total time (in seconds). :param steps: Number of steps. :param commands: Number of commands. :returns: Wait in seconds. """
|
wait = ((duration - self.wait * self.reps * commands) / steps) - \
(self.wait * self.reps * self._bridge.active)
return max(0, wait)
|
<SYSTEM_TASK:>
Solve the following problem using Python, implementing the functions described below, one line at a time
<END_TASK>
<USER_TASK:>
Description:
def get(cls, name, definition, output_dir):
""" Dispatch to the right subclass based on the definition. """
|
if 'url' in definition:
return URLResource(name, definition, output_dir)
elif 'pypi' in definition:
return PyPIResource(name, definition, output_dir)
else:
return Resource(name, definition, output_dir)
|
<SYSTEM_TASK:>
Solve the following problem using Python, implementing the functions described below, one line at a time
<END_TASK>
<USER_TASK:>
Description:
def run(self):
""" Run the pipeline queue. The pipeline queue will run forever. """
|
while True:
self._event.clear()
self._queue.get().run(self._event)
|
<SYSTEM_TASK:>
Solve the following problem using Python, implementing the functions described below, one line at a time
<END_TASK>
<USER_TASK:>
Description:
def run(self, stop):
""" Run the pipeline. :param stop: Stop event """
|
_LOGGER.info("Starting a new pipeline on group %s", self._group)
self._group.bridge.incr_active()
for i, stage in enumerate(self._pipe):
self._execute_stage(i, stage, stop)
_LOGGER.info("Finished pipeline on group %s", self._group)
self._group.bridge.decr_active()
|
<SYSTEM_TASK:>
Solve the following problem using Python, implementing the functions described below, one line at a time
<END_TASK>
<USER_TASK:>
Description:
def append(self, pipeline):
""" Append a pipeline to this pipeline. :param pipeline: Pipeline to append. :returns: This pipeline. """
|
for stage in pipeline.pipe:
self._pipe.append(stage)
return self
|
<SYSTEM_TASK:>
Solve the following problem using Python, implementing the functions described below, one line at a time
<END_TASK>
<USER_TASK:>
Description:
def _add_stage(self, name):
""" Add stage methods at runtime. Stage methods all follow the same pattern. :param name: Stage name. """
|
def stage_func(self, *args, **kwargs):
""" Stage function.
:param args: Positional arguments.
:param kwargs: Keyword arguments.
:return: Pipeline (for method chaining).
"""
self._pipe.append(Stage(name, args, kwargs))
return self
setattr(Pipeline, name, stage_func)
|
<SYSTEM_TASK:>
Solve the following problem using Python, implementing the functions described below, one line at a time
<END_TASK>
<USER_TASK:>
Description:
def _execute_stage(self, index, stage, stop):
""" Execute a pipeline stage. :param index: Stage index. :param stage: Stage object. """
|
if stop.is_set():
_LOGGER.info("Stopped pipeline on group %s", self._group)
return
_LOGGER.info(" -> Running stage '%s' on group %s", stage, self._group)
if stage.name == 'on':
self._group.on = True
elif stage.name == 'off':
self._group.on = False
elif stage.name == 'hue':
self._group.hue = stage.args[0]
elif stage.name == 'saturation':
self._group.saturation = stage.args[0]
elif stage.name == 'color':
self._group.color = Color(*stage.args)
elif stage.name == 'brightness':
self._group.brightness = stage.args[0]
elif stage.name == 'temperature':
self._group.temperature = stage.args[0]
elif stage.name == 'transition':
self._group.transition(*stage.args, **stage.kwargs)
elif stage.name == 'white':
self._group.white()
elif stage.name == 'white_up':
self._group.white_up()
elif stage.name == 'white_down':
self._group.white_down()
elif stage.name == 'red_up':
self._group.red_up()
elif stage.name == 'red_down':
self._group.red_down()
elif stage.name == 'green_up':
self._group.green_up()
elif stage.name == 'green_down':
self._group.green_down()
elif stage.name == 'blue_up':
self._group.blue_up()
elif stage.name == 'blue_down':
self._group.blue_down()
elif stage.name == 'night_light':
self._group.night_light()
elif stage.name == 'flash':
self._group.flash(**stage.kwargs)
elif stage.name == 'repeat':
self._repeat(index, stage, stop)
elif stage.name == 'wait':
time.sleep(*stage.args)
elif stage.name == 'callback':
stage.args[0](*stage.args[1:], **stage.kwargs)
|
<SYSTEM_TASK:>
Solve the following problem using Python, implementing the functions described below, one line at a time
<END_TASK>
<USER_TASK:>
Description:
def _repeat(self, index, stage, stop):
""" Repeat a stage. :param index: Stage index. :param stage: Stage object to repeat. :param iterations: Number of iterations (default infinite). :param stages: Stages back to repeat (default 1). """
|
times = None
if 'iterations' in stage.kwargs:
times = stage.kwargs['iterations'] - 1
stages_back = 1
if 'stages' in stage.kwargs:
stages_back = stage.kwargs['stages']
i = 0
while i != times:
if stop.is_set():
break
for forward in range(stages_back):
if stop.is_set():
break
stage_index = index - stages_back + forward
self._execute_stage(stage_index, self._pipe[stage_index], stop)
i += 1
|
<SYSTEM_TASK:>
Solve the following problem using Python, implementing the functions described below, one line at a time
<END_TASK>
<USER_TASK:>
Description:
def brightness(self, brightness):
""" Set the brightness. :param brightness: Value to set (0.0-1.0). """
|
try:
cmd = self.command_set.brightness(brightness)
self.send(cmd)
self._brightness = brightness
except AttributeError:
self._setter('_brightness', brightness,
self._dimmest, self._brightest,
self._to_brightness)
|
<SYSTEM_TASK:>
Solve the following problem using Python, implementing the functions described below, one line at a time
<END_TASK>
<USER_TASK:>
Description:
def _to_brightness(self, brightness):
""" Step to a given brightness. :param brightness: Get to this brightness. """
|
self._to_value(self._brightness, brightness,
self.command_set.brightness_steps,
self._dimmer, self._brighter)
|
<SYSTEM_TASK:>
Solve the following problem using Python, implementing the functions described below, one line at a time
<END_TASK>
<USER_TASK:>
Description:
def _to_value(self, current, target, max_steps, step_down, step_up):
""" Step to a value :param current: Current value. :param target: Target value. :param max_steps: Maximum number of steps. :param step_down: Down function. :param step_up: Up function. """
|
for _ in range(steps(current, target, max_steps)):
if (current - target) > 0:
step_down()
else:
step_up()
|
<SYSTEM_TASK:>
Solve the following problem using Python, implementing the functions described below, one line at a time
<END_TASK>
<USER_TASK:>
Description:
def _dimmest(self):
""" Group brightness as dim as possible. """
|
for _ in range(steps(self.brightness, 0.0,
self.command_set.brightness_steps)):
self._dimmer()
|
<SYSTEM_TASK:>
Solve the following problem using Python, implementing the functions described below, one line at a time
<END_TASK>
<USER_TASK:>
Description:
def add_repo(self, repo_name, items):
""" Build up repos `name` - Name of this repo. `items` - List of paths to rpm. """
|
juicer.utils.Log.log_debug("[CART:%s] Adding %s items to repo '%s'" % \
(self.cart_name, len(items), repo_name))
# We can't just straight-away add all of `items` to the
# repo. `items` may be composed of a mix of local files, local
# directories, remote files, and remote directories. We need
# to filter and validate each item.
items = juicer.utils.filter_package_list(items)
cart_items = []
for item in items:
juicer.utils.Log.log_debug("Creating CartObject for %s" % item)
i = juicer.common.CartItem.CartItem(item)
cart_items.append(i)
self.repo_items_hash[repo_name] = cart_items
|
<SYSTEM_TASK:>
Solve the following problem using Python, implementing the functions described below, one line at a time
<END_TASK>
<USER_TASK:>
Description:
def load(self, json_file):
""" Build a cart from a json file """
|
cart_file = os.path.join(CART_LOCATION, json_file)
try:
cart_body = juicer.utils.read_json_document(cart_file)
except IOError as e:
juicer.utils.Log.log_error('an error occured while accessing %s:' %
cart_file)
raise JuicerError(e.message)
self.cart_name = cart_body['_id']
if cart_body['current_env'] == '':
self.current_env = juicer.utils.get_login_info()[1]['start_in']
else:
self.current_env = cart_body['current_env']
for repo, items in cart_body['repos_items'].iteritems():
self.add_repo(repo, items)
|
<SYSTEM_TASK:>
Solve the following problem using Python, implementing the functions described below, one line at a time
<END_TASK>
<USER_TASK:>
Description:
def sign_items(self, sign_with):
""" Sign the items in the cart with a GPG key. After everything is collected and signed all the cart items are issued a refresh() to sync their is_signed attributes. `sign_with` is a reference to the method that implements juicer.common.RpmSignPlugin. """
|
cart_items = self.items()
item_paths = [item.path for item in cart_items]
sign_with(item_paths)
for item in cart_items:
item.refresh()
|
<SYSTEM_TASK:>
Solve the following problem using Python, implementing the functions described below, one line at a time
<END_TASK>
<USER_TASK:>
Description:
def sync_remotes(self, force=False):
""" Pull down all non-local items and save them into remotes_storage. """
|
connectors = juicer.utils.get_login_info()[0]
for repo, items in self.iterrepos():
repoid = "%s-%s" % (repo, self.current_env)
for rpm in items:
# don't bother syncing down if it's already in the pulp repo it needs to go to
if not rpm.path.startswith(juicer.utils.pulp_repo_path(connectors[self.current_env], repoid)) or force:
rpm.sync_to(self.remotes_storage)
else:
juicer.utils.Log.log_debug("Not syncing %s because it's already in pulp" % rpm.path)
|
<SYSTEM_TASK:>
Solve the following problem using Python, implementing the functions described below, one line at a time
<END_TASK>
<USER_TASK:>
Description:
def items(self):
""" Build and return a list of all items in this cart """
|
cart_items = []
for repo, items in self.iterrepos():
cart_items.extend(items)
return cart_items
|
<SYSTEM_TASK:>
Solve the following problem using Python, implementing the functions described below, one line at a time
<END_TASK>
<USER_TASK:>
Description:
def arg(*args, **kwargs):
""" Decorator to add args to subcommands. """
|
def _arg(f):
if not hasattr(f, '_subcommand_args'):
f._subcommand_args = []
f._subcommand_args.append((args, kwargs))
return f
return _arg
|
<SYSTEM_TASK:>
Solve the following problem using Python, implementing the functions described below, one line at a time
<END_TASK>
<USER_TASK:>
Description:
def argset(name, *args, **kwargs):
""" Decorator to add sets of required mutually exclusive args to subcommands. """
|
def _arg(f):
if not hasattr(f, '_subcommand_argsets'):
f._subcommand_argsets = {}
f._subcommand_argsets.setdefault(name, []).append((args, kwargs))
return f
return _arg
|
<SYSTEM_TASK:>
Solve the following problem using Python, implementing the functions described below, one line at a time
<END_TASK>
<USER_TASK:>
Description:
def resources(argv=sys.argv[1:]):
""" Juju CLI subcommand for dispatching resources subcommands. """
|
eps = iter_entry_points('jujuresources.subcommands')
ep_map = {ep.name: ep.load() for ep in eps}
parser = argparse.ArgumentParser()
if '--description' in argv:
print('Manage and mirror charm resources')
return 0
subparsers = {}
subparser_factory = parser.add_subparsers()
subparsers['help'] = subparser_factory.add_parser('help', help='Display help for a subcommand')
subparsers['help'].add_argument('command', nargs='?')
subparsers['help'].set_defaults(subcommand='help')
for name, subcommand in ep_map.items():
subparsers[name] = subparser_factory.add_parser(name, help=subcommand.__doc__)
subparsers[name].set_defaults(subcommand=subcommand)
for args, kwargs in getattr(subcommand, '_subcommand_args', []):
subparsers[name].add_argument(*args, **kwargs)
for argset in getattr(subcommand, '_subcommand_argsets', {}).values():
group = subparsers[name].add_mutually_exclusive_group(required=True)
for args, kwargs in argset:
group.add_argument(*args, **kwargs)
opts = parser.parse_args(argv)
if opts.subcommand == 'help':
if opts.command:
subparsers[opts.command].print_help()
else:
parser.print_help()
else:
return _exit(opts.subcommand(opts) or 0)
|
<SYSTEM_TASK:>
Solve the following problem using Python, implementing the functions described below, one line at a time
<END_TASK>
<USER_TASK:>
Description:
def fetch(opts):
""" Create a local mirror of one or more resources. """
|
resources = _load(opts.resources, opts.output_dir)
if opts.all:
opts.resource_names = ALL
reporthook = None if opts.quiet else lambda name: print('Fetching {}...'.format(name))
if opts.verbose:
backend.VERBOSE = True
_fetch(resources, opts.resource_names, opts.mirror_url, opts.force, reporthook)
return verify(opts)
|
<SYSTEM_TASK:>
Solve the following problem using Python, implementing the functions described below, one line at a time
<END_TASK>
<USER_TASK:>
Description:
def verify(opts):
""" Verify that one or more resources were downloaded successfully. """
|
resources = _load(opts.resources, opts.output_dir)
if opts.all:
opts.resource_names = ALL
invalid = _invalid(resources, opts.resource_names)
if not invalid:
if not opts.quiet:
print("All resources successfully downloaded")
return 0
else:
if not opts.quiet:
print("Invalid or missing resources: {}".format(', '.join(invalid)))
return 1
|
<SYSTEM_TASK:>
Solve the following problem using Python, implementing the functions described below, one line at a time
<END_TASK>
<USER_TASK:>
Description:
def resource_path(opts):
""" Return the full path to a named resource. """
|
resources = _load(opts.resources, opts.output_dir)
if opts.resource_name not in resources:
sys.stderr.write('Invalid resource name: {}\n'.format(opts.resource_name))
return 1
print(resources[opts.resource_name].destination)
|
<SYSTEM_TASK:>
Solve the following problem using Python, implementing the functions described below, one line at a time
<END_TASK>
<USER_TASK:>
Description:
def serve(opts):
""" Run a light-weight HTTP server hosting previously mirrored resources """
|
resources = _load(opts.resources, opts.output_dir)
opts.output_dir = resources.output_dir # allow resources.yaml to set default output_dir
if not os.path.exists(opts.output_dir):
sys.stderr.write("Resources dir '{}' not found. Did you fetch?\n".format(opts.output_dir))
return 1
backend.PyPIResource.build_pypi_indexes(opts.output_dir)
os.chdir(opts.output_dir)
HTTPServer.allow_reuse_address = True
httpd = HTTPServer((opts.host, opts.port), SimpleHTTPRequestHandler)
if opts.ssl_cert:
httpd.socket = ssl.wrap_socket(httpd.socket, certfile=opts.ssl_cert, server_side=True)
print("Serving at: http{}://{}:{}/".format(
's' if opts.ssl_cert else '', socket.gethostname(), opts.port))
httpd.serve_forever()
|
<SYSTEM_TASK:>
Solve the following problem using Python, implementing the functions described below, one line at a time
<END_TASK>
<USER_TASK:>
Description:
def _to_temperature(self, temperature):
""" Step to a given temperature. :param temperature: Get to this temperature. """
|
self._to_value(self._temperature, temperature,
self.command_set.temperature_steps,
self._warmer, self._cooler)
|
<SYSTEM_TASK:>
Solve the following problem using Python, implementing the functions described below, one line at a time
<END_TASK>
<USER_TASK:>
Description:
def _warmest(self):
""" Group temperature as warm as possible. """
|
for _ in range(steps(self.temperature, 0.0,
self.command_set.temperature_steps)):
self._warmer()
|
<SYSTEM_TASK:>
Solve the following problem using Python, implementing the functions described below, one line at a time
<END_TASK>
<USER_TASK:>
Description:
def _coolest(self):
""" Group temperature as cool as possible. """
|
for _ in range(steps(self.temperature, 1.0,
self.command_set.temperature_steps)):
self._cooler()
|
<SYSTEM_TASK:>
Solve the following problem using Python, implementing the functions described below, one line at a time
<END_TASK>
<USER_TASK:>
Description:
def ip_to_array(ipaddress):
"""Convert a string representing an IPv4 address to 4 bytes."""
|
res = []
for i in ipaddress.split("."):
res.append(int(i))
assert len(res) == 4
return res
|
<SYSTEM_TASK:>
Solve the following problem using Python, implementing the functions described below, one line at a time
<END_TASK>
<USER_TASK:>
Description:
def int_to_array(i, length=2):
"""Convert an length byte integer to an array of bytes."""
|
res = []
for dummy in range(0, length):
res.append(i & 0xff)
i = i >> 8
return reversed(res)
|
<SYSTEM_TASK:>
Solve the following problem using Python, implementing the functions described below, one line at a time
<END_TASK>
<USER_TASK:>
Description:
def stop(self):
"""Stop internal color pattern playing """
|
if ( self.dev == None ): return ''
buf = [REPORT_ID, ord('p'), 0, 0, 0, 0, 0, 0, 0]
return self.write(buf);
|
<SYSTEM_TASK:>
Solve the following problem using Python, implementing the functions described below, one line at a time
<END_TASK>
<USER_TASK:>
Description:
def savePattern(self):
"""Save internal RAM pattern to flash """
|
if ( self.dev == None ): return ''
buf = [REPORT_ID, ord('W'), 0xBE, 0xEF, 0xCA, 0xFE, 0, 0, 0]
return self.write(buf);
|
<SYSTEM_TASK:>
Solve the following problem using Python, implementing the functions described below, one line at a time
<END_TASK>
<USER_TASK:>
Description:
def create_repo(self, repo_name=None, feed=None, envs=[], checksum_type="sha256", query='/repositories/'):
""" `repo_name` - Name of repository to create `feed` - Repo URL to feed from `checksum_type` - Used for generating meta-data Create repository in specified environments, associate the yum_distributor with it and publish the repo """
|
data = {'display_name': repo_name,
'notes': {
'_repo-type': 'rpm-repo',
}
}
juicer.utils.Log.log_debug("Create Repo: %s", repo_name)
for env in envs:
if juicer.utils.repo_exists_p(repo_name, self.connectors[env], env):
juicer.utils.Log.log_info("repo `%s` already exists in %s... skipping!",
(repo_name, env))
continue
else:
data['relative_path'] = '/%s/%s/' % (env, repo_name)
data['id'] = '-'.join([repo_name, env])
_r = self.connectors[env].post(query, data)
if _r.status_code == Constants.PULP_POST_CREATED:
imp_query = '/repositories/%s/importers/' % data['id']
imp_data = {
'importer_id': 'yum_importer',
'importer_type_id': 'yum_importer',
'importer_config': {},
}
if feed:
imp_data['importer_config']['feed_url'] = feed
_r = self.connectors[env].post(imp_query, imp_data)
dist_query = '/repositories/%s/distributors/' % data['id']
dist_data = {'distributor_id': 'yum_distributor',
'distributor_type_id': 'yum_distributor',
'distributor_config': {
'relative_url': '/%s/%s/' % (env, repo_name),
'http': True,
'https': True,
'checksum_type': checksum_type
},
'auto_publish': True,
'relative_path': '/%s/%s/' % (env, repo_name)
}
_r = self.connectors[env].post(dist_query, dist_data)
if _r.status_code == Constants.PULP_POST_CREATED:
pub_query = '/repositories/%s/actions/publish/' % data['id']
pub_data = {'id': 'yum_distributor'}
_r = self.connectors[env].post(pub_query, pub_data)
if _r.status_code == Constants.PULP_POST_ACCEPTED:
juicer.utils.Log.log_info("created repo `%s` in %s", repo_name, env)
else:
_r.raise_for_status()
else:
_r.raise_for_status()
return True
|
<SYSTEM_TASK:>
Solve the following problem using Python, implementing the functions described below, one line at a time
<END_TASK>
<USER_TASK:>
Description:
def create_user(self, login=None, password=None, user_name=None, envs=[], query='/users/'):
""" `login` - Login or username for user `password` - Plain text password for user `user_name` - Full name of user Create user in specified environments """
|
login = login.lower()
data = {'login': login,
'password': password[0],
'name': user_name}
juicer.utils.Log.log_debug("Create User: %s ('%s')", login, user_name)
for env in envs:
if envs.index(env) != 0 and juicer.utils.env_same_host(env, envs[envs.index(env) - 1]):
juicer.utils.Log.log_info("environment `%s` shares a host with environment `%s`... skipping!",
(env, envs[envs.index(env) - 1]))
continue
elif juicer.utils.user_exists_p(login, self.connectors[env]):
juicer.utils.Log.log_info("user `%s` already exists in %s... skipping!",
(login, env))
continue
else:
_r = self.connectors[env].post(query, data)
if _r.status_code == Constants.PULP_POST_CREATED:
juicer.utils.Log.log_info("created user `%s` with login `%s` in %s",
(user_name, login, env))
else:
_r.raise_for_status()
return True
|
<SYSTEM_TASK:>
Solve the following problem using Python, implementing the functions described below, one line at a time
<END_TASK>
<USER_TASK:>
Description:
def delete_repo(self, repo_name=None, envs=[], query='/repositories/'):
""" `repo_name` - Name of repository to delete Delete repo in specified environments """
|
orphan_query = '/content/orphans/rpm/'
juicer.utils.Log.log_debug("Delete Repo: %s", repo_name)
for env in self.args.envs:
if not juicer.utils.repo_exists_p(repo_name, self.connectors[env], env):
juicer.utils.Log.log_info("repo `%s` doesn't exist in %s... skipping!",
(repo_name, env))
continue
else:
url = "%s%s-%s/" % (query, repo_name, env)
_r = self.connectors[env].delete(url)
if _r.status_code == Constants.PULP_DELETE_ACCEPTED:
juicer.utils.Log.log_info("deleted repo `%s` in %s",
(repo_name, env))
# if delete was successful, delete orphaned rpms
_r = self.connectors[env].get(orphan_query)
if _r.status_code is Constants.PULP_GET_OK:
if len(juicer.utils.load_json_str(_r.content)) > 0:
__r = self.connectors[env].delete(orphan_query)
if __r.status_code is Constants.PULP_DELETE_ACCEPTED:
juicer.utils.Log.log_debug("deleted orphaned rpms in %s." % env)
else:
juicer.utils.Log.log_error("unable to delete orphaned rpms in %s. a %s error was returned", (env, __r.status_code))
else:
juicer.utils.Log.log_error("unable to get a list of orphaned rpms. encountered a %s error." % _r.status_code)
else:
_r.raise_for_status()
return True
|
<SYSTEM_TASK:>
Solve the following problem using Python, implementing the functions described below, one line at a time
<END_TASK>
<USER_TASK:>
Description:
def delete_user(self, login=None, envs=[], query='/users/'):
""" `login` - Login or username of user to delete Delete user in specified environments """
|
juicer.utils.Log.log_debug("Delete User: %s", login)
for env in envs:
if envs.index(env) != 0 and juicer.utils.env_same_host(env, envs[envs.index(env) - 1]):
juicer.utils.Log.log_info("environment `%s` shares a host with environment `%s`... skipping!",
(env, envs[envs.index(env) - 1]))
continue
elif not juicer.utils.user_exists_p(login, self.connectors[env]):
juicer.utils.Log.log_info("user `%s` doesn't exist in %s... skipping!",
(login, env))
continue
else:
url = "%s%s/" % (query, login)
_r = self.connectors[env].delete(url)
if _r.status_code == Constants.PULP_DELETE_OK:
juicer.utils.Log.log_info("deleted user `%s` in %s",
(login, env))
else:
_r.raise_for_status()
return True
|
<SYSTEM_TASK:>
Solve the following problem using Python, implementing the functions described below, one line at a time
<END_TASK>
<USER_TASK:>
Description:
def sync_repo(self, repo_name=None, envs=[], query='/repositories/'):
""" Sync repository in specified environments """
|
juicer.utils.Log.log_debug(
"Sync Repo %s In: %s" % (repo_name, ",".join(envs)))
data = {
'override_config': {
'verify_checksum': 'true',
'verify_size': 'true'
},
}
for env in envs:
url = "%s%s-%s/actions/sync/" % (query, repo_name, env)
juicer.utils.Log.log_info("%s:", env)
_r = self.connectors[env].post(url, data)
if _r.status_code == Constants.PULP_POST_ACCEPTED:
juicer.utils.Log.log_info("`%s` sync scheduled" % repo_name)
else:
_r.raise_for_status()
return True
|
<SYSTEM_TASK:>
Solve the following problem using Python, implementing the functions described below, one line at a time
<END_TASK>
<USER_TASK:>
Description:
def list_repos(self, envs=[], query='/repositories/'):
""" List repositories in specified environments """
|
juicer.utils.Log.log_debug(
"List Repos In: %s", ", ".join(envs))
repo_lists = {}
for env in envs:
repo_lists[env] = []
for env in envs:
_r = self.connectors[env].get(query)
if _r.status_code == Constants.PULP_GET_OK:
for repo in juicer.utils.load_json_str(_r.content):
if re.match(".*-{0}$".format(env), repo['id']):
repo_lists[env].append(repo['display_name'])
else:
_r.raise_for_status()
return repo_lists
|
<SYSTEM_TASK:>
Solve the following problem using Python, implementing the functions described below, one line at a time
<END_TASK>
<USER_TASK:>
Description:
def list_users(self, envs=[], query="/users/"):
""" List users in specified environments """
|
juicer.utils.Log.log_debug(
"List Users In: %s", ", ".join(envs))
for env in envs:
juicer.utils.Log.log_info("%s:" % (env))
_r = self.connectors[env].get(query)
if _r.status_code == Constants.PULP_GET_OK:
for user in juicer.utils.load_json_str(_r.content):
roles = user['roles']
if roles:
user_roles = ', '.join(roles)
else:
user_roles = "None"
juicer.utils.Log.log_info("\t%s - %s" % (user['login'], user_roles))
else:
_r.raise_for_status()
return True
|
<SYSTEM_TASK:>
Solve the following problem using Python, implementing the functions described below, one line at a time
<END_TASK>
<USER_TASK:>
Description:
def role_add(self, role=None, login=None, envs=[], query='/roles/'):
""" `login` - Login or username of user to add to `role` `role` - Role to add user to Add user to role """
|
data = {'login': self.args.login}
juicer.utils.Log.log_debug(
"Add Role '%s' to '%s'", role, login)
for env in self.args.envs:
if not juicer.utils.role_exists_p(role, self.connectors[env]):
juicer.utils.Log.log_info("role `%s` doesn't exist in %s... skipping!",
(role, env))
continue
elif not juicer.utils.user_exists_p(login, self.connectors[env]):
juicer.utils.Log.log_info("user `%s` doesn't exist in %s... skipping!",
(login, env))
else:
url = "%s%s/users/" % (query, role)
_r = self.connectors[env].post(url, data)
if _r.status_code == Constants.PULP_POST_OK:
juicer.utils.Log.log_info("added user `%s` to role `%s` in %s",
(login, role, env))
else:
_r.raise_for_status()
return True
|
<SYSTEM_TASK:>
Solve the following problem using Python, implementing the functions described below, one line at a time
<END_TASK>
<USER_TASK:>
Description:
def show_user(self, login=None, envs=[], query='/users/'):
""" `login` - Login or username of user Show user in specified environments """
|
juicer.utils.Log.log_debug("Show User: %s", login)
# keep track of which iteration of environment we're in
count = 0
for env in self.args.envs:
count += 1
juicer.utils.Log.log_info("%s:", env)
if not juicer.utils.user_exists_p(login, self.connectors[env]):
juicer.utils.Log.log_info("user `%s` doesn't exist in %s... skipping!",
(login, env))
continue
else:
url = "%s%s/" % (query, login)
_r = self.connectors[env].get(url)
if _r.status_code == Constants.PULP_GET_OK:
user = juicer.utils.load_json_str(_r.content)
juicer.utils.Log.log_info("Login: %s" % user['login'])
juicer.utils.Log.log_info("Name: %s" % user['name'])
juicer.utils.Log.log_info("Roles: %s" % ', '.join(user['roles']))
if count < len(envs):
# just want a new line
juicer.utils.Log.log_info("")
else:
_r.raise_for_status()
return True
|
<SYSTEM_TASK:>
Solve the following problem using Python, implementing the functions described below, one line at a time
<END_TASK>
<USER_TASK:>
Description:
def list_roles(self, envs=[], query='/roles/'):
""" List roles in specified environments """
|
juicer.utils.Log.log_debug("List Roles %s", ", ".join(envs))
count = 0
for env in envs:
count += 1
rcount = 0
juicer.utils.Log.log_info("%s:", env)
_r = self.connectors[env].get(query)
if _r.status_code == Constants.PULP_GET_OK:
roles = juicer.utils.load_json_str(_r.content)
for role in roles:
rcount += 1
juicer.utils.Log.log_info("Name: %s" % role['display_name'])
juicer.utils.Log.log_info("Description: %s" % role['description'])
juicer.utils.Log.log_info("ID: %s" % role['id'])
juicer.utils.Log.log_info("Users: %s" % ', '.join(role['users']))
if rcount < len(roles):
# just want a new line
juicer.utils.Log.log_info("\n")
if count < len(envs):
# just want a new line
juicer.utils.Log.log_info("\n")
else:
_r.raise_for_status()
return True
|
<SYSTEM_TASK:>
Solve the following problem using Python, implementing the functions described below, one line at a time
<END_TASK>
<USER_TASK:>
Description:
def update_user(self, login=None, user_name=None, password=None, envs=[], query='/users/'):
""" `login` - Login or username of user to update `user_name` - Updated full name of user `password` - Updated plain text password for user Update user information """
|
juicer.utils.Log.log_debug("Update user information %s" % login)
login = login.lower()
data = {'delta': {}}
if not user_name and not password:
raise JuicerError("Error: --name or --password must be present")
if user_name:
data['delta']['name'] = user_name
if password:
data['delta']['password'] = password[0]
query = "%s%s/" % (query, login)
for env in envs:
juicer.utils.Log.log_info("%s:", env)
if not juicer.utils.user_exists_p(login, self.connectors[env]):
juicer.utils.Log.log_info("user `%s` does not exist in %s... skipping!",
(login, env))
continue
else:
_r = self.connectors[env].put(query, data)
if _r.status_code == Constants.PULP_PUT_OK:
juicer.utils.Log.log_info("user %s updated" %
juicer.utils.load_json_str(_r.content)['login'])
else:
_r.raise_for_status()
return True
|
<SYSTEM_TASK:>
Solve the following problem using Python, implementing the functions described below, one line at a time
<END_TASK>
<USER_TASK:>
Description:
def _diff(self):
"""Calculates what you need to do to make a pulp repo match a juicer repo def"""
|
j_cs = self.j['checksum_type']
j_feed = self.j['feed']
p_cs = self.p['checksum_type']
p_feed = self.p['feed']
# checksum is a distributor property
# Is the pulp checksum wrong?
if not p_cs == j_cs:
juicer.utils.Log.log_debug("Pulp checksum_type does not match juicer")
self.distributor_diff['distributor_config']['checksum_type'] = j_cs
juicer.utils.Log.log_debug("distributor_config::checksum_type SHOULD BE %s" % j_cs)
# feed is an importer property
if not p_feed == j_feed:
juicer.utils.Log.log_debug("Pulp feed does not match juicer")
self.importer_diff['importer_config']['feed'] = j_feed
juicer.utils.Log.log_debug("importer_config::feed SHOULD BE %s" % j_feed)
|
<SYSTEM_TASK:>
Solve the following problem using Python, implementing the functions described below, one line at a time
<END_TASK>
<USER_TASK:>
Description:
def _set_prefixes(self, conf):
"""Set the graphite key prefixes :param dict conf: The configuration data """
|
if conf.get('legacy_namespace', 'y') in self.TRUE_VALUES:
self.count_prefix = 'stats_counts'
self.count_suffix = ''
self.gauge_prefix = 'stats.gauges'
self.timer_prefix = 'stats.timers'
self.rate_prefix = 'stats'
self.rate_suffix = ''
else:
global_prefix = conf.get('global_prefix', 'stats')
self.count_prefix = '%s.%s' % (global_prefix,
conf.get('prefix_counter',
'counters'))
self.count_suffix = '.count'
self.gauge_prefix = '%s.%s' % (global_prefix,
conf.get('prefix_gauge', 'gauges'))
self.timer_prefix = '%s.%s' % (global_prefix,
conf.get('prefix_timer', 'timers'))
self.rate_prefix = self.count_prefix
self.rate_suffix = '.rate'
|
<SYSTEM_TASK:>
Solve the following problem using Python, implementing the functions described below, one line at a time
<END_TASK>
<USER_TASK:>
Description:
def _get_batches(self, items):
"""given a list yield list at most self.max_batch_size in size"""
|
for i in xrange(0, len(items), self.max_batch_size):
yield items[i:i + self.max_batch_size]
|
<SYSTEM_TASK:>
Solve the following problem using Python, implementing the functions described below, one line at a time
<END_TASK>
<USER_TASK:>
Description:
def report_stats(self, payload, is_retry=False):
""" Send data to graphite host :param payload: Data to send to graphite """
|
if self.debug:
if self.pickle_proto:
print "reporting pickled stats"
else:
print "reporting stats -> {\n%s}" % payload
try:
graphite = socket.socket()
with eventlet.Timeout(self.graphite_timeout, True):
graphite.connect(self.graphite_addr)
graphite.sendall(payload)
graphite.close()
except eventlet.timeout.Timeout:
self.logger.critical("Timeout sending to graphite")
if self.debug:
print "Timeout talking to graphite"
if not is_retry:
self.logger.critical('Attempting 1 retry!')
self.report_stats(payload, is_retry=True)
else:
self.logger.critical('Already retried once, giving up')
except Exception as err:
self.logger.critical("error connecting to graphite: %s" % err)
if self.debug:
print "error connecting to graphite: %s" % err
finally:
try:
graphite.close()
except Exception:
pass
|
<SYSTEM_TASK:>
Solve the following problem using Python, implementing the functions described below, one line at a time
<END_TASK>
<USER_TASK:>
Description:
def stats_flush(self):
""" Periodically flush stats to graphite """
|
while True:
try:
eventlet.sleep(self.flush_interval)
if self.debug:
print "seen %d stats so far." % self.stats_seen
print "current counters: %s" % self.counters
if self.pickle_proto:
payload = self.pickle_payload()
if payload:
for batch in payload:
self.report_stats(batch)
else:
payload = self.plain_payload()
if payload:
self.report_stats(payload)
except: # safety net
self.logger.critical('Encountered error in stats_flush loop')
|
<SYSTEM_TASK:>
Solve the following problem using Python, implementing the functions described below, one line at a time
<END_TASK>
<USER_TASK:>
Description:
def pickle_payload(self):
"""obtain stats payload in batches of pickle format"""
|
tstamp = int(time.time())
payload = []
for item in self.counters:
payload.append(("%s.%s%s" % (self.rate_prefix, item,
self.rate_suffix),
(tstamp,
self.counters[item] / self.flush_interval)))
payload.append(("%s.%s%s" % (self.count_prefix, item,
self.count_suffix),
(tstamp, self.counters[item])))
self.counters[item] = 0
for key in self.timers:
if len(self.timers[key]) > 0:
self.process_timer_key(key, tstamp, payload, pickled=True)
self.timers[key] = []
for key in self.gauges:
payload.append(("%s.%s" % (self.gauge_prefix, key),
(tstamp, self.gauges[key])))
self.gauges[key] = 0
if payload:
batched_payload = []
for batch in self._get_batches(payload):
if self.debug:
print "pickling batch: %r" % batch
serialized_data = pickle.dumps(batch, protocol=-1)
length_prefix = struct.pack("!L", len(serialized_data))
batched_payload.append(length_prefix + serialized_data)
return batched_payload
return None
|
<SYSTEM_TASK:>
Solve the following problem using Python, implementing the functions described below, one line at a time
<END_TASK>
<USER_TASK:>
Description:
def plain_payload(self):
"""obtain stats payload in plaintext format"""
|
tstamp = int(time.time())
payload = []
for item in self.counters:
payload.append('%s.%s%s %s %s\n' % (self.rate_prefix,
item,
self.rate_suffix,
self.counters[item] /
self.flush_interval,
tstamp))
payload.append('%s.%s%s %s %s\n' % (self.count_prefix,
item,
self.count_suffix,
self.counters[item],
tstamp))
self.counters[item] = 0
for key in self.timers:
if len(self.timers[key]) > 0:
self.process_timer_key(key, tstamp, payload)
self.timers[key] = []
for key in self.gauges:
payload.append("%s.%s %d %d\n" % (self.gauge_prefix, key,
self.gauges[key], tstamp))
self.gauges[key] = 0
if self.debug:
print payload
if payload:
return "".join(payload)
else:
return None
|
<SYSTEM_TASK:>
Solve the following problem using Python, implementing the functions described below, one line at a time
<END_TASK>
<USER_TASK:>
Description:
def process_gauge(self, key, fields):
""" Process a received gauge event :param key: Key of timer :param fields: Received fields """
|
try:
self.gauges[key] = float(fields[0])
if self.stats_seen >= maxint:
self.logger.info("hit maxint, reset seen counter")
self.stats_seen = 0
self.stats_seen += 1
except Exception as err:
self.logger.info("error decoding gauge event: %s" % err)
if self.debug:
print "error decoding gauge event: %s" % err
|
<SYSTEM_TASK:>
Solve the following problem using Python, implementing the functions described below, one line at a time
<END_TASK>
<USER_TASK:>
Description:
def process_timer(self, key, fields):
""" Process a received timer event :param key: Key of timer :param fields: Received fields """
|
try:
if key not in self.timers:
self.timers[key] = []
self.timers[key].append(float(fields[0]))
if self.stats_seen >= maxint:
self.logger.info("hit maxint, reset seen counter")
self.stats_seen = 0
self.stats_seen += 1
except Exception as err:
self.logger.info("error decoding timer event: %s" % err)
if self.debug:
print "error decoding timer event: %s" % err
|
<SYSTEM_TASK:>
Solve the following problem using Python, implementing the functions described below, one line at a time
<END_TASK>
<USER_TASK:>
Description:
def process_counter(self, key, fields):
""" Process a received counter event :param key: Key of counter :param fields: Received fields """
|
sample_rate = 1.0
try:
if len(fields) is 3:
if self.ratecheck.match(fields[2]):
sample_rate = float(fields[2].lstrip("@"))
else:
raise Exception("bad sample rate.")
counter_value = float(fields[0] or 1) * (1 / float(sample_rate))
if key not in self.counters:
self.counters[key] = 0
self.counters[key] += counter_value
if self.stats_seen >= maxint:
self.logger.info("hit maxint, reset seen counter")
self.stats_seen = 0
self.stats_seen += 1
except Exception as err:
self.logger.info("error decoding counter event: %s" % err)
if self.debug:
print "error decoding counter event: %s" % err
|
<SYSTEM_TASK:>
Solve the following problem using Python, implementing the functions described below, one line at a time
<END_TASK>
<USER_TASK:>
Description:
def process_timer_key(self, key, tstamp, stack, pickled=False):
"""Append the plain text graphite :param str key: The timer key to process :param int tstamp: The timestamp for the data point :param list stack: The stack of metrics to append the output to """
|
self.timers[key].sort()
values = {'count': len(self.timers[key]),
'low': min(self.timers[key]),
'high': max(self.timers[key]),
'total': sum(self.timers[key])}
values['mean'] = values['low']
nth_percentile = 'upper_%i' % self.pct_threshold
values[nth_percentile] = values['high']
if values['count']:
threshold_idx = int(self.threshold_numerator * values['count']) - 1
values[nth_percentile] = self.timers[key][threshold_idx]
values['mean'] = float(values['total']) / float(values['count'])
for metric in values:
if pickled:
stack.append(("%s.%s.%s" % (self.timer_prefix, key, metric),
(tstamp, values[metric])))
else:
stack.append("%s.%s.%s %s %s\n" % (self.timer_prefix,
key,
metric,
values[metric],
tstamp))
|
<SYSTEM_TASK:>
Solve the following problem using Python, implementing the functions described below, one line at a time
<END_TASK>
<USER_TASK:>
Description:
def decode_recvd(self, data):
""" Decode and process the data from a received event. :param data: Data to decode and process. """
|
bits = data.split(':')
if len(bits) == 2:
key = self.keycheck.sub('_', bits[0])
fields = bits[1].split("|")
field_count = len(fields)
if field_count >= 2:
processor = self.processors.get(fields[1])
if processor:
if self.debug:
print "got key: %s %r" % (key, fields)
processor(key, fields)
else:
print "error: unsupported stats type"
print "key -> %s\nfields ->%s" % (key, fields)
else:
print "error (%s): not enough fields received" % key
else:
print "error: invalid request [%s]" % data[:40]
|
<SYSTEM_TASK:>
Solve the following problem using Python, implementing the functions described below, one line at a time
<END_TASK>
<USER_TASK:>
Description:
def _get_usage(self):
""" Build usage string from argparser args. """
|
parser = argparse.ArgumentParser()
parser.prog = 'juju-resources {}'.format(self.object_name)
for set_name, set_args in getattr(self.object, '_subcommand_argsets', {}).items():
for ap_args, ap_kwargs in set_args:
parser.add_argument(*ap_args, **ap_kwargs)
for ap_args, ap_kwargs in getattr(self.object, '_subcommand_args', []):
parser.add_argument(*ap_args, **ap_kwargs)
usage = parser.format_usage()
usage = re.sub(r'\n *', ' ', usage)
return usage.strip()
|
<SYSTEM_TASK:>
Solve the following problem using Python, implementing the functions described below, one line at a time
<END_TASK>
<USER_TASK:>
Description:
def parse_group_address(addr):
"""Parse KNX group addresses and return the address as an integer. This allows to convert x/x/x and x/x address syntax to a numeric KNX group address """
|
if addr is None:
raise KNXException("No address given")
res = None
if re.match('[0-9]+$', addr):
res = int(addr)
match = re.match("([0-9]+)/([0-9]+)$", addr)
if match:
main = match.group(1)
sub = match.group(2)
res = int(main) * 2048 + int(sub)
match = re.match("([0-9]+)/([0-9]+)/([0-9]+)$", addr)
if match:
main = match.group(1)
middle = match.group(2)
sub = match.group(3)
res = int(main) * 256 * 8 + int(middle) * 256 + int(sub)
if res is None:
raise KNXException("Address {} does not match any address scheme".
format(addr))
return res
|
<SYSTEM_TASK:>
Solve the following problem using Python, implementing the functions described below, one line at a time
<END_TASK>
<USER_TASK:>
Description:
def set(self, name, value):
"""Set the cached value for the given name"""
|
old_val = self.values.get(name)
if old_val != value:
self.values[name] = value
return True
else:
return False
|
<SYSTEM_TASK:>
Solve the following problem using Python, implementing the functions described below, one line at a time
<END_TASK>
<USER_TASK:>
Description:
def sanitize(self):
"""Sanitize all fields of the KNX message."""
|
self.repeat = self.repeat % 2
self.priority = self.priority % 4
self.src_addr = self.src_addr % 0x10000
self.dst_addr = self.dst_addr % 0x10000
self.multicast = self.multicast % 2
self.routing = self.routing % 8
self.length = self.length % 16
for i in range(0, self.length - 1):
self.data[i] = self.data[i] % 0x100
|
<SYSTEM_TASK:>
Solve the following problem using Python, implementing the functions described below, one line at a time
<END_TASK>
<USER_TASK:>
Description:
def to_frame(self):
"""Convert the object to its frame format."""
|
self.sanitize()
res = []
res.append((1 << 7) + (1 << 4) + (self.repeat << 5) +
(self.priority << 2))
res.append(self.src_addr >> 8)
res.append(self.src_addr % 0x100)
res.append(self.dst_addr >> 8)
res.append(self.dst_addr % 0x100)
res.append((self.multicast << 7) + (self.routing << 4) + self.length)
for i in range(0, self.length - 1):
res.append(self.data[i])
checksum = 0
for i in range(0, 5 + self.length):
checksum += res[i]
res.append(checksum % 0x100)
return bytearray(res)
|
<SYSTEM_TASK:>
Solve the following problem using Python, implementing the functions described below, one line at a time
<END_TASK>
<USER_TASK:>
Description:
def from_frame(cls, frame):
"""Create a KNXMessage object from the frame format."""
|
message = cls()
# Check checksum first
checksum = 0
for i in range(0, len(frame) - 1):
checksum += frame[i]
if (checksum % 0x100) != frame[len(frame) - 1]:
raise KNXException('Checksum error in frame {}, '
'expected {} but got {}'
.format(tohex(frame), frame[len(frame) - 1],
checksum % 0x100))
message.repeat = (frame[0] >> 5) & 0x01
message.priority = (frame[0] >> 2) & 0x03
message.src_addr = (frame[1] << 8) + frame[2]
message.dst_addr = (frame[3] << 8) + frame[4]
message.multicast = (frame[5] >> 7)
message.routing = (frame[5] >> 4) & 0x03
message.length = frame[5] & 0x0f
message.data = frame[6:-1]
if len(message.data) + 1 != message.length:
raise KNXException(
'Frame {} has not the correct length'.format(tohex(frame)))
return message
|
<SYSTEM_TASK:>
Solve the following problem using Python, implementing the functions described below, one line at a time
<END_TASK>
<USER_TASK:>
Description:
def assemble_remotes(resource):
""" Using the specified input resource, assemble a list of rpm URLS. This function will, when given a remote package url, directory index, or a combination of the two in a local input file, do all the work required to turn that input into a list of only remote package URLs. """
|
resource_type = classify_resource_type(resource)
if resource_type is None:
juicer.utils.Log.log_debug("Could not classify or find the input resource.")
return []
elif resource_type == REMOTE_PKG_TYPE:
return [resource]
elif resource_type == REMOTE_INDEX_TYPE:
return parse_directory_index(resource)
elif resource_type == REMOTE_INPUT_FILE_TYPE:
# Later on this could examine the excluded data for directory
# indexes and iterate over those too.
remote_packages, excluded_data = parse_input_file(resource)
return remote_packages
|
<SYSTEM_TASK:>
Solve the following problem using Python, implementing the functions described below, one line at a time
<END_TASK>
<USER_TASK:>
Description:
def classify_resource_type(resource):
""" Determine if the specified resource is remote or local. We can handle three remote resource types from the command line, remote RPMs, directory indexes, and input files. They're classified by matching the following patterns: - Remote RPMS start with http[s] and end with .RPM - Directory indexes start with http[s] and don't end in .RPM - Input files don't match above, exist() on local filesystem """
|
if is_remote_package(resource):
juicer.utils.Log.log_debug("Classified %s as a remote package" % resource)
return REMOTE_PKG_TYPE
elif is_directory_index(resource):
juicer.utils.Log.log_debug("Classified %s as a directory index" % resource)
return REMOTE_INDEX_TYPE
elif exists(expanduser(resource)):
juicer.utils.Log.log_debug("Classified %s as an input file" % resource)
return REMOTE_INPUT_FILE_TYPE
else:
juicer.utils.Log.log_debug("Classified %s as unclassifiable" % resource)
return None
|
<SYSTEM_TASK:>
Solve the following problem using Python, implementing the functions described below, one line at a time
<END_TASK>
<USER_TASK:>
Description:
def is_remote_package(resource):
""" Classify the input resource as a remote RPM or not. """
|
remote_regexp = re.compile(r"^https?://(.+).rpm$", re.I)
result = remote_regexp.match(resource)
if result is not None:
juicer.utils.Log.log_debug("%s matches remote package regexp" % resource)
return True
else:
juicer.utils.Log.log_debug("%s doesn't match remote package regexp" % resource)
return False
|
<SYSTEM_TASK:>
Solve the following problem using Python, implementing the functions described below, one line at a time
<END_TASK>
<USER_TASK:>
Description:
def is_directory_index(resource):
""" Classify the input resource as a directory index or not. """
|
remote_regexp = re.compile(r"^https?://(.+)/?$", re.I)
result = remote_regexp.match(resource)
if result is not None:
juicer.utils.Log.log_debug("%s matches directory index regexp" % resource)
return True
else:
juicer.utils.Log.log_debug("%s doesn't match directory index regexp" % resource)
return False
|
<SYSTEM_TASK:>
Solve the following problem using Python, implementing the functions described below, one line at a time
<END_TASK>
<USER_TASK:>
Description:
def parse_input_file(resource):
""" Parse input file into remote packages and excluded data. In addition to garbage, excluded data includes directory indexes for the time being. This will be revisited after basic functionality has been fully implemented. """
|
input_resource = open(resource, 'r').read()
remotes_list = [url for url in input_resource.split()]
juicer.utils.Log.log_debug("Input file parsed into: %s\n" % str(remotes_list))
remote_packages = [pkg for pkg in remotes_list if is_remote_package(pkg) is True]
juicer.utils.Log.log_debug("remote_packages filtered into %s\n" % str(remote_packages))
excluded_data = [datum for datum in remotes_list if datum not in remote_packages]
juicer.utils.Log.log_debug("excluded_data filtered into %s\n" % str(excluded_data))
http_indexes = [index for index in excluded_data if is_directory_index(index)]
remotes_from_indexes = reduce(lambda x, y: x + parse_directory_index(y), http_indexes, [])
return (remote_packages + remotes_from_indexes, excluded_data)
|
<SYSTEM_TASK:>
Solve the following problem using Python, implementing the functions described below, one line at a time
<END_TASK>
<USER_TASK:>
Description:
def parse_directory_index(directory_index):
""" Retrieve a directory index and make a list of the RPMs listed. """
|
# Normalize our URL style
if not directory_index.endswith('/'):
directory_index = directory_index + '/'
site_index = urllib2.urlopen(directory_index)
parsed_site_index = bs(site_index)
rpm_link_tags = parsed_site_index.findAll('a', href=re.compile(r'.*rpm$'))
# Only save the HREF attribute values from the links found
rpm_names = [link['href'] for link in rpm_link_tags]
# Join the index path with the discovered names so we only return complete paths
remote_list = map(lambda end: "".join([directory_index, end]), rpm_names)
return remote_list
|
<SYSTEM_TASK:>
Solve the following problem using Python, implementing the functions described below, one line at a time
<END_TASK>
<USER_TASK:>
Description:
def kelvin_to_rgb(kelvin):
""" Convert a color temperature given in kelvin to an approximate RGB value. :param kelvin: Color temp in K :return: Tuple of (r, g, b), equivalent color for the temperature """
|
temp = kelvin / 100.0
# Calculate Red:
if temp <= 66:
red = 255
else:
red = 329.698727446 * ((temp - 60) ** -0.1332047592)
# Calculate Green:
if temp <= 66:
green = 99.4708025861 * math.log(temp) - 161.1195681661
else:
green = 288.1221695283 * ((temp - 60) ** -0.0755148492)
#Calculate Blue:
if temp > 66:
blue = 255
elif temp <= 19:
blue = 0
else:
blue = 138.5177312231 * math.log(temp - 10) - 305.0447927307
return tuple(correct_output(c) for c in (red, green, blue))
|
<SYSTEM_TASK:>
Solve the following problem using Python, implementing the functions described below, one line at a time
<END_TASK>
<USER_TASK:>
Description:
def white(self):
""" Set color to white. """
|
self._color = RGB_WHITE
cmd = self.command_set.white()
self.send(cmd)
|
<SYSTEM_TASK:>
Solve the following problem using Python, implementing the functions described below, one line at a time
<END_TASK>
<USER_TASK:>
Description:
def brightness(self, brightness):
""" Set the group brightness. :param brightness: Brightness in decimal percent (0.0-1.0). """
|
if brightness < 0 or brightness > 1:
raise ValueError("Brightness must be a percentage "
"represented as decimal 0-1.0")
self._brightness = brightness
cmd = self.command_set.brightness(brightness)
self.send(cmd)
|
<SYSTEM_TASK:>
Solve the following problem using Python, implementing the functions described below, one line at a time
<END_TASK>
<USER_TASK:>
Description:
def hue(self, hue):
""" Set the group hue. :param hue: Hue in decimal percent (0.0-1.0). """
|
if hue < 0 or hue > 1:
raise ValueError("Hue must be a percentage "
"represented as decimal 0-1.0")
self._hue = hue
cmd = self.command_set.hue(hue)
self.send(cmd)
|
<SYSTEM_TASK:>
Solve the following problem using Python, implementing the functions described below, one line at a time
<END_TASK>
<USER_TASK:>
Description:
def send_updates(self):
""" Send updated to the KNX bus. """
|
d = datetime.now()
if self.timeaddr:
self.tunnel.group_write(self.timeaddr,
time_to_knx(d))
if self.dateaddr:
self.tunnel.group_write(self.dateaddr,
date_to_knx(d))
if self.datetimeaddr:
self.tunnel.group_write(self.datetimeaddr,
datetime_to_knx(d))
if self.daynightaddr:
from pysolar.solar import get_altitude
alt = get_altitude(self.lat, self.long, d)
if alt > 0:
self.tunnel.group_write(self.daynightaddr, 1)
else:
self.tunnel.group_write(self.daynightaddr, 0)
|
<SYSTEM_TASK:>
Solve the following problem using Python, implementing the functions described below, one line at a time
<END_TASK>
<USER_TASK:>
Description:
def updater_loop(self):
""" Main loop that should run in the background. """
|
self.updater_running = True
while (self.updater_running):
self.send_updates()
sleep(self.updateinterval)
|
<SYSTEM_TASK:>
Solve the following problem using Python, implementing the functions described below, one line at a time
<END_TASK>
<USER_TASK:>
Description:
def run_updater_in_background(self):
""" Starts a thread that runs the updater in the background. """
|
thread = threading.Thread(target=self.updater_loop())
thread.daemon = True
thread.start()
|
<SYSTEM_TASK:>
Solve the following problem using Python, implementing the functions described below, one line at a time
<END_TASK>
<USER_TASK:>
Description:
|
def parent_dir(path):
'''Return the parent of a directory.'''
return os.path.abspath(os.path.join(path, os.pardir, os.pardir, '_build'))
|
<SYSTEM_TASK:>
Solve the following problem using Python, implementing the functions described below, one line at a time
<END_TASK>
<USER_TASK:>
Description:
def update(self, path):
""" Update the attributes of this CartItem. """
|
self._reset()
self.path = path
self._refresh_synced()
if self.is_synced:
self._refresh_path()
self._refresh_signed()
self._refresh_nvr()
|
<SYSTEM_TASK:>
Solve the following problem using Python, implementing the functions described below, one line at a time
<END_TASK>
<USER_TASK:>
Description:
def sync_to(self, destination):
""" Sync an RPM from a REMOTE to a LOCAL path. Returns True if the item required a sync, False if it already existed locally. TODO: Remove dupe code in Cart.py:sync_remotes() """
|
rpm = RPM(self.path)
rpm.sync(destination)
if rpm.modified:
juicer.utils.Log.log_debug("Source RPM modified. New 'path': %s" % rpm)
self.update(rpm.path)
return True
return False
|
<SYSTEM_TASK:>
Solve the following problem using Python, implementing the functions described below, one line at a time
<END_TASK>
<USER_TASK:>
Description:
def _refresh_synced(self):
""" Update our is_synced attribute accordingly. """
|
if self.path.startswith('http'):
juicer.utils.Log.log_debug("%s is not synced" % self.path)
self.is_synced = False
else:
juicer.utils.Log.log_debug("%s is synced" % self.path)
self.is_synced = True
|
<SYSTEM_TASK:>
Solve the following problem using Python, implementing the functions described below, one line at a time
<END_TASK>
<USER_TASK:>
Description:
def _refresh_path(self):
""" Does it exist? Can we read it? Is it an RPM? """
|
# Unsynced items are remote so we can't check some of their
# properties yet
if os.path.exists(self.path):
try:
i = open(self.path, 'r')
i.close()
juicer.utils.Log.log_debug("Successfully read item at: %s" % self.path)
except:
raise IOError("Error while attempting to access item at path: %s" % self.path)
else:
raise IOError("Could not locate item at path: %s" % self.path)
|
<SYSTEM_TASK:>
Solve the following problem using Python, implementing the functions described below, one line at a time
<END_TASK>
<USER_TASK:>
Description:
def _refresh_nvr(self):
""" Refresh our name-version-release attributes. """
|
rpm_info = juicer.utils.rpm_info(self.path)
self.name = rpm_info['name']
self.version = rpm_info['version']
self.release = rpm_info['release']
|
<SYSTEM_TASK:>
Solve the following problem using Python, implementing the functions described below, one line at a time
<END_TASK>
<USER_TASK:>
Description:
def _reset(self):
""" Used during update operations and when initialized. """
|
self.path = ''
self.version = ''
self.release = ''
self.is_signed = False
self.is_synced = False
self.rpm = False
|
<SYSTEM_TASK:>
Solve the following problem using Python, implementing the functions described below, one line at a time
<END_TASK>
<USER_TASK:>
Description:
def add_bridge(self, bridge):
""" Add bridge groups. :param bridge: Add groups from this bridge. """
|
for group in bridge.groups:
self._groups[group.name] = group
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.