input
stringlengths 11
5.29k
| target
stringlengths 20
8.26k
|
|---|---|
def __init__(self):
self.filediff = None
meldsettings.connect('changed', self.on_setting_changed) | def getTail(self):
return self.Tail |
def __init__(self):
self.filediff = None
meldsettings.connect('changed', self.on_setting_changed) | def getAAA(self):
temp = []
temp.append( self.getAp1() )
temp.append( self.getAp2() )
temp.append( self.getAp3() )
return temp |
def __init__(self):
self.filediff = None
meldsettings.connect('changed', self.on_setting_changed) | def item_widget(self):
return self._item_widget |
def __init__(self):
self.filediff = None
meldsettings.connect('changed', self.on_setting_changed) | def label(self):
return self._label |
def __init__(self):
self.filediff = None
meldsettings.connect('changed', self.on_setting_changed) | def n_inputs(self):
return self._n_inputs |
def __init__(self):
self.filediff = None
meldsettings.connect('changed', self.on_setting_changed) | def n_outputs(self):
return self._n_outputs |
def __init__(self):
self.filediff = None
meldsettings.connect('changed', self.on_setting_changed) | def device_port(self):
if self._values['managed']:
return None
return self._values['device_port'] |
def __init__(self):
self.filediff = None
meldsettings.connect('changed', self.on_setting_changed) | def __init__(self, want, have=None):
self.want = want
self.have = have |
def __init__(self):
self.filediff = None
meldsettings.connect('changed', self.on_setting_changed) | def __default(self, param):
attr1 = getattr(self.want, param)
try:
attr2 = getattr(self.have, param)
if attr1 != attr2:
return attr1
except AttributeError:
return attr1 |
def __init__(self):
self.filediff = None
meldsettings.connect('changed', self.on_setting_changed) | def get_names(self):
# This method used to pull in base class attributes
# at a time dir() didn't do it yet.
return dir(self.__class__) |
def __init__(self):
self.filediff = None
meldsettings.connect('changed', self.on_setting_changed) | def __getattr__(self, name):
if name in self.fields:
return self.fields[name] |
def __init__(self):
self.filediff = None
meldsettings.connect('changed', self.on_setting_changed) | def api_field_from_django_field(cls, f, default=CharField):
"""
Returns the field type that would likely be associated with each
Django type.
"""
result = default |
def __init__(self):
self.filediff = None
meldsettings.connect('changed', self.on_setting_changed) | def get_object_list(self, request):
"""
An ORM-specific implementation of ``get_object_list``. |
def __init__(self):
self.filediff = None
meldsettings.connect('changed', self.on_setting_changed) | def obj_get_list(self, request=None, **kwargs):
"""
A ORM-specific implementation of ``obj_get_list``. |
def __init__(self):
self.filediff = None
meldsettings.connect('changed', self.on_setting_changed) | def obj_get(self, request=None, **kwargs):
"""
A ORM-specific implementation of ``obj_get``. |
def __init__(self):
self.filediff = None
meldsettings.connect('changed', self.on_setting_changed) | def info(self):
return self.updater.info() |
def __init__(self):
self.filediff = None
meldsettings.connect('changed', self.on_setting_changed) | def getInfo(self):
return jsonified(self.info()) |
def __init__(self):
self.filediff = None
meldsettings.connect('changed', self.on_setting_changed) | def read_property_to_any(obj, propertyIdentifier, propertyArrayIndex=None):
"""Read the specified property of the object, with the optional array index,
and cast the result into an Any object."""
if _debug: read_property_to_any._debug("read_property_to_any %s %r %r", obj, propertyIdentifier, propertyArrayIndex)
# get the datatype
datatype = obj.get_datatype(propertyIdentifier)
if _debug: read_property_to_any._debug(" - datatype: %r", datatype)
if datatype is None:
raise ExecutionError(errorClass='property', errorCode='datatypeNotSupported')
# get the value
value = obj.ReadProperty(propertyIdentifier, propertyArrayIndex)
if _debug: read_property_to_any._debug(" - value: %r", value)
if value is None:
raise ExecutionError(errorClass='property', errorCode='unknownProperty')
# change atomic values into something encodeable
if issubclass(datatype, Atomic) or (issubclass(datatype, (Array, List)) and isinstance(value, list)):
value = datatype(value)
elif issubclass(datatype, Array) and (propertyArrayIndex is not None):
if propertyArrayIndex == 0:
value = Unsigned(value)
elif issubclass(datatype.subtype, Atomic):
value = datatype.subtype(value)
elif not isinstance(value, datatype.subtype):
raise TypeError("invalid result datatype, expecting %s and got %s" \
% (datatype.subtype.__name__, type(value).__name__))
elif not isinstance(value, datatype):
raise TypeError("invalid result datatype, expecting %s and got %s" \
% (datatype.__name__, type(value).__name__))
if _debug: read_property_to_any._debug(" - encodeable value: %r", value)
# encode the value
result = Any()
result.cast_in(value)
if _debug: read_property_to_any._debug(" - result: %r", result)
# return the object
return result |
def __init__(self):
self.filediff = None
meldsettings.connect('changed', self.on_setting_changed) | def read_property_to_result_element(obj, propertyIdentifier, propertyArrayIndex=None):
"""Read the specified property of the object, with the optional array index,
and cast the result into an Any object."""
if _debug: read_property_to_result_element._debug("read_property_to_result_element %s %r %r", obj, propertyIdentifier, propertyArrayIndex)
# save the result in the property value
read_result = ReadAccessResultElementChoice()
try:
if not obj:
raise ExecutionError(errorClass='object', errorCode='unknownObject')
read_result.propertyValue = read_property_to_any(obj, propertyIdentifier, propertyArrayIndex)
if _debug: read_property_to_result_element._debug(" - success")
except PropertyError as error:
if _debug: read_property_to_result_element._debug(" - error: %r", error)
read_result.propertyAccessError = ErrorType(errorClass='property', errorCode='unknownProperty')
except ExecutionError as error:
if _debug: read_property_to_result_element._debug(" - error: %r", error)
read_result.propertyAccessError = ErrorType(errorClass=error.errorClass, errorCode=error.errorCode)
# make an element for this value
read_access_result_element = ReadAccessResultElement(
propertyIdentifier=propertyIdentifier,
propertyArrayIndex=propertyArrayIndex,
readResult=read_result,
)
if _debug: read_property_to_result_element._debug(" - read_access_result_element: %r", read_access_result_element)
# fini
return read_access_result_element |
def __init__(self):
self.filediff = None
meldsettings.connect('changed', self.on_setting_changed) | def visit_BasicNode(self, node):
return BasicNodeReplacement() |
def __init__(self):
self.filediff = None
meldsettings.connect('changed', self.on_setting_changed) | def partItem(self) -> PathNucleicAcidPartItemT:
return self._strand_item.partItem() |
def __init__(self):
self.filediff = None
meldsettings.connect('changed', self.on_setting_changed) | def window(self) -> WindowT:
return self._strand_item.window() |
def __init__(self):
self.filediff = None
meldsettings.connect('changed', self.on_setting_changed) | def __unicode__(self):
return "%s (%s)" % (self.name, self.remote_id) |
def __init__(self):
self.filediff = None
meldsettings.connect('changed', self.on_setting_changed) | def __repr__(self):
"""Return string representation."""
return '<Platform.OPP>' |
def __init__(self):
self.filediff = None
meldsettings.connect('changed', self.on_setting_changed) | def __ror__(self, other):
return Infix(lambda x: self.function(other, x)) |
def __init__(self):
self.filediff = None
meldsettings.connect('changed', self.on_setting_changed) | def description(self):
return self._description |
def __init__(self):
self.filediff = None
meldsettings.connect('changed', self.on_setting_changed) | def description(self, desc):
self._description = self.validate_description(desc) |
def __init__(self):
self.filediff = None
meldsettings.connect('changed', self.on_setting_changed) | def capacity(self):
return self._capacity |
def __init__(self):
self.filediff = None
meldsettings.connect('changed', self.on_setting_changed) | def generation(self):
return self._generation |
def __init__(self):
self.filediff = None
meldsettings.connect('changed', self.on_setting_changed) | def sequence(self):
return self._sequence |
def __init__(self):
self.filediff = None
meldsettings.connect('changed', self.on_setting_changed) | def getAnnotations (self): |
def __init__(self):
self.filediff = None
meldsettings.connect('changed', self.on_setting_changed) | def _call_reciprocal(self, method_name, *args, **kwargs):
# Calls method_name on _reciprocal_of
o = self._reciprocal_of(self.args[0])
return getattr(o, method_name)(*args, **kwargs) |
def __init__(self):
self.filediff = None
meldsettings.connect('changed', self.on_setting_changed) | def _calculate_reciprocal(self, method_name, *args, **kwargs):
# If calling method_name on _reciprocal_of returns a value != None
# then return the reciprocal of that value
t = self._call_reciprocal(method_name, *args, **kwargs)
return 1/t if t is not None else t |
def __init__(self):
self.filediff = None
meldsettings.connect('changed', self.on_setting_changed) | def separator(self):
''' getter method for separator '''
return self._separator |
def __init__(self):
self.filediff = None
meldsettings.connect('changed', self.on_setting_changed) | def get_curr_value(invalue, val_type):
'''return the current value'''
if invalue is None:
return None
curr_value = invalue
if val_type == 'yaml':
curr_value = yaml.load(invalue)
elif val_type == 'json':
curr_value = json.loads(invalue)
return curr_value |
def __init__(self):
self.filediff = None
meldsettings.connect('changed', self.on_setting_changed) | def secrets(self):
'''secret property getter'''
if self._secrets is None:
self._secrets = self.get_secrets()
return self._secrets |
def __init__(self):
self.filediff = None
meldsettings.connect('changed', self.on_setting_changed) | def add_secret(self, key, value):
''' add a secret '''
if self.secrets:
self.secrets[key] = value
else:
self.put(Secret.secret_path, {key: value})
return True |
def __init__(self):
self.filediff = None
meldsettings.connect('changed', self.on_setting_changed) | def service(self):
''' service property '''
return self.svc |
def __init__(self):
self.filediff = None
meldsettings.connect('changed', self.on_setting_changed) | def contributed_values(self):
return self._contributed_values(self.contributed_values_obj) |
def __init__(self):
self.filediff = None
meldsettings.connect('changed', self.on_setting_changed) | def __len__(self):
return len(self._requirements) |
def __init__(self):
self.filediff = None
meldsettings.connect('changed', self.on_setting_changed) | def __repr__(self):
return "Additional({!r})".format(self._requirements) |
def __init__(self):
self.filediff = None
meldsettings.connect('changed', self.on_setting_changed) | def current(self):
"""
Returns the current additional context if set otherwise None
"""
try:
return _additional_ctx_stack.top[1]
except TypeError:
return None |
def __init__(self):
self.filediff = None
meldsettings.connect('changed', self.on_setting_changed) | def __str__(self):
return self.name |
def __init__(self):
self.filediff = None
meldsettings.connect('changed', self.on_setting_changed) | def __str__(self):
return self.ip |
def __init__(self):
self.filediff = None
meldsettings.connect('changed', self.on_setting_changed) | def __str__(self):
return 'id: ' + str(self._get_pk_val()) |
def __init__(self):
self.filediff = None
meldsettings.connect('changed', self.on_setting_changed) | def associate(self, melddoc):
self.melddoc = melddoc |
def __init__(self):
self.filediff = None
meldsettings.connect('changed', self.on_setting_changed) | def load_object(self, obj, callback=None):
pg = self.pg # get the property grid reference
self.callback = callback # store the update method |
def __init__(self):
self.filediff = None
meldsettings.connect('changed', self.on_setting_changed) | def create(kernel):
result = Static()
result.template = "object/static/item/shared_armor_composite_helmet.iff"
result.attribute_template_id = -1
result.stfName("obj_n","unknown_object") |
def __init__(self):
self.filediff = None
meldsettings.connect('changed', self.on_setting_changed) | def set_message ( self , decoded):
self.decoded = decoded |
def __init__(self):
self.filediff = None
meldsettings.connect('changed', self.on_setting_changed) | def create(kernel):
result = Creature()
result.template = "object/creature/npc/droid/crafted/shared_cll_8_binary_load_lifter_advanced.iff"
result.attribute_template_id = 3
result.stfName("droid_name","cll_8_binary_load_lifter_crafted_advanced") |
def __init__(self):
self.filediff = None
meldsettings.connect('changed', self.on_setting_changed) | def create(kernel):
result = Tangible()
result.template = "object/tangible/scout/trap/shared_trap_webber.iff"
result.attribute_template_id = -1
result.stfName("item_n","trap_webber") |
def __init__(self):
self.filediff = None
meldsettings.connect('changed', self.on_setting_changed) | def _get_from_stack(stack, source, key):
value = None
if source + 's' not in stack:
raise ValueError('Invalid stack attribute' + str(stack))
for p in stack[source + 's']:
if p[source + 'Key'] == key:
value = p[source + 'Value']
break
return value |
def __init__(self):
self.filediff = None
meldsettings.connect('changed', self.on_setting_changed) | def __str__(self):
return repr(self.value) |
def __init__(self):
self.filediff = None
meldsettings.connect('changed', self.on_setting_changed) | def custom_endpoint():
return CustomEndpoint() |
def __init__(self):
self.filediff = None
meldsettings.connect('changed', self.on_setting_changed) | def __unicode__(self):
return self.username |
def __init__(self):
self.filediff = None
meldsettings.connect('changed', self.on_setting_changed) | def get_sex(self):
return self.sex |
def __init__(self):
self.filediff = None
meldsettings.connect('changed', self.on_setting_changed) | def __get__(self, obj: t.Any, owner: t.Any = None) -> t.Any:
if obj is None:
return self
rv = obj.config[self.__name__]
if self.get_converter is not None:
rv = self.get_converter(rv)
return rv |
def __init__(self):
self.filediff = None
meldsettings.connect('changed', self.on_setting_changed) | def step_impl(context, user_name, count):
context.helpers.load_postcards(user_name, count) |
def __init__(self):
self.filediff = None
meldsettings.connect('changed', self.on_setting_changed) | def teardown(self, **kwargs: Any) -> None:
"""Execute arbitrary post-profiling tear-down steps as defined by subclass.""" |
def __init__(self):
self.filediff = None
meldsettings.connect('changed', self.on_setting_changed) | def profile_iterable(self, iterable: Iterable, action_name: str) -> Generator:
iterator = iter(iterable)
while True:
try:
self.start(action_name)
value = next(iterator)
self.stop(action_name)
yield value
except StopIteration:
self.stop(action_name)
break |
def __init__(self):
self.filediff = None
meldsettings.connect('changed', self.on_setting_changed) | def __init__(self, model, data):
# try and import pytorch
global torch
if torch is None:
import torch
if version.parse(torch.__version__) < version.parse("0.4"):
warnings.warn("Your PyTorch version is older than 0.4 and not supported.")
# check if we have multiple inputs
self.multi_input = False
if type(data) == list:
self.multi_input = True
if type(data) != list:
data = [data]
self.data = data
self.layer = None
self.input_handle = None
self.interim = False
self.interim_inputs_shape = None
self.expected_value = None # to keep the DeepExplainer base happy
if type(model) == tuple:
self.interim = True
model, layer = model
model = model.eval()
self.layer = layer
self.add_target_handle(self.layer)
# if we are taking an interim layer, the 'data' is going to be the input
# of the interim layer; we will capture this using a forward hook
with torch.no_grad():
_ = model(*data)
interim_inputs = self.layer.target_input
if type(interim_inputs) is tuple:
# this should always be true, but just to be safe
self.interim_inputs_shape = [i.shape for i in interim_inputs]
else:
self.interim_inputs_shape = [interim_inputs.shape]
self.target_handle.remove()
del self.layer.target_input
self.model = model.eval()
self.multi_output = False
self.num_outputs = 1
with torch.no_grad():
outputs = model(*data)
# also get the device everything is running on
self.device = outputs.device
if outputs.shape[1] > 1:
self.multi_output = True
self.num_outputs = outputs.shape[1]
self.expected_value = outputs.mean(0).cpu().numpy() |
def __init__(self):
self.filediff = None
meldsettings.connect('changed', self.on_setting_changed) | def _draw_item(self, win, data, inverted):
if data['type'] == 'MoreComments':
return self._draw_more_comments(win, data)
elif data['type'] == 'HiddenComment':
return self._draw_more_comments(win, data)
elif data['type'] == 'Comment':
return self._draw_comment(win, data, inverted)
else:
return self._draw_submission(win, data) |
def __init__(self):
self.filediff = None
meldsettings.connect('changed', self.on_setting_changed) | def every_week(job, loop=None):
return every(job, timedelta=timedelta(days=7), loop=loop) |
def __init__(self):
self.filediff = None
meldsettings.connect('changed', self.on_setting_changed) | def exec_module(self):
changed = False
result = dict()
state = self.want.state
try:
if state == "present":
changed = self.present()
elif state == "absent":
changed = self.absent()
except iControlUnexpectedHTTPError as e:
raise F5ModuleError(str(e))
result.update(**self.changes.to_return())
result.update(dict(changed=changed))
return result |
def __init__(self):
self.filediff = None
meldsettings.connect('changed', self.on_setting_changed) | def data_received(self, data):
self.transport.write(data) |
def __init__(self):
self.filediff = None
meldsettings.connect('changed', self.on_setting_changed) | def buffer_updated(self, nbytes):
self.transport.write(self.buffer[:nbytes]) |
def __init__(self):
self.filediff = None
meldsettings.connect('changed', self.on_setting_changed) | def detail_export(self, request, pk=None):
serializer = ConditionExportSerializer(self.get_object())
xml = ConditionRenderer().render([serializer.data])
return XMLResponse(xml, name=self.get_object().key) |
def __init__(self):
self.filediff = None
meldsettings.connect('changed', self.on_setting_changed) | def theme_generic_recurse(data):
col.label(data.rna_type.name)
row = col.row()
subsplit = row.split(percentage=0.95)
padding1 = subsplit.split(percentage=0.15)
padding1.column()
subsplit = row.split(percentage=0.85)
padding2 = subsplit.split(percentage=0.15)
padding2.column()
colsub_pair = padding1.column(), padding2.column()
props_type = {}
for i, prop in enumerate(data.rna_type.properties):
if prop.identifier == "rna_type":
continue
props_type.setdefault((prop.type, prop.subtype), []).append(prop)
th_delimiters = USERPREF_PT_theme.ui_delimiters.get(theme_area)
for props_type, props_ls in sorted(props_type.items()):
if props_type[0] == 'POINTER':
for i, prop in enumerate(props_ls):
theme_generic_recurse(getattr(data, prop.identifier))
else:
if th_delimiters is None:
# simple, no delimiters
for i, prop in enumerate(props_ls):
colsub_pair[i % 2].row().prop(data, prop.identifier)
else:
# add hard coded delimiters
i = 0
for prop in props_ls:
colsub = colsub_pair[i]
colsub.row().prop(data, prop.identifier)
i = (i + 1) % 2
if prop.identifier in th_delimiters:
if i:
colsub = colsub_pair[1]
colsub.row().label("")
colsub_pair[0].row().label("")
colsub_pair[1].row().label("")
i = 0 |
def __init__(self):
self.filediff = None
meldsettings.connect('changed', self.on_setting_changed) | def __call__(self, fn):
return self.matchfn(fn) |
def __init__(self):
self.filediff = None
meldsettings.connect('changed', self.on_setting_changed) | def __init__(self, root, cwd, kindpats, ctx=None, badfn=None):
super(patternmatcher, self).__init__(root, cwd, badfn)
# kindpats are already normalized to be relative to repo-root.
# Can we use tree matcher?
rules = _kindpatstoglobs(kindpats, recursive=False)
fallback = True
if rules is not None:
try:
matcher = treematcher(root, cwd, badfn=badfn, rules=rules)
# Replace self to 'matcher'.
self.__dict__ = matcher.__dict__
self.__class__ = matcher.__class__
fallback = False
except ValueError:
# for example, Regex("Compiled regex exceeds size limit of 10485760 bytes.")
pass
if fallback:
self._prefix = _prefix(kindpats)
self._pats, self.matchfn = _buildmatch(ctx, kindpats, "$", root)
self._files = _explicitfiles(kindpats) |
def __init__(self):
self.filediff = None
meldsettings.connect('changed', self.on_setting_changed) | def set_submodule(self, submodule: 'Submodule') -> None:
"""Set this instance's submodule. It must be called before
the first write operation begins"""
self._smref = weakref.ref(submodule) |
def __init__(self):
self.filediff = None
meldsettings.connect('changed', self.on_setting_changed) | def test_methods(self): |
def __init__(self):
self.filediff = None
meldsettings.connect('changed', self.on_setting_changed) | def new_tool_type(request):
if request.method == 'POST':
tform = ToolTypeForm(request.POST, instance=Tool_Type())
if tform.is_valid():
tform.save()
messages.add_message(request,
messages.SUCCESS,
'Tool Type Configuration Successfully Created.',
extra_tags='alert-success')
return HttpResponseRedirect(reverse('tool_type', ))
else:
tform = ToolTypeForm()
add_breadcrumb(title="New Tool Type Configuration", top_level=False, request=request)
return render(request, 'dojo/new_tool_type.html',
{'tform': tform}) |
def __init__(self):
self.filediff = None
meldsettings.connect('changed', self.on_setting_changed) | def __init__(self):
"""Constructeur du paramètre"""
Parametre.__init__(self, "voir", "view")
self.schema = "<cle>"
self.aide_courte = "affiche le détail d'un chemin"
self.aide_longue = \
"Cette commande permet d'obtenir plus d'informations sur " \
"un chemin (ses flags actifs, ses salles et sorties...)." |
def __init__(self):
self.filediff = None
meldsettings.connect('changed', self.on_setting_changed) | def edit_tool_type(request, ttid):
tool_type = Tool_Type.objects.get(pk=ttid)
if request.method == 'POST':
tform = ToolTypeForm(request.POST, instance=tool_type)
if tform.is_valid():
tform.save()
messages.add_message(request,
messages.SUCCESS,
'Tool Type Configuration Successfully Updated.',
extra_tags='alert-success')
return HttpResponseRedirect(reverse('tool_type', ))
else:
tform = ToolTypeForm(instance=tool_type)
add_breadcrumb(title="Edit Tool Type Configuration", top_level=False, request=request)
return render(request,
'dojo/edit_tool_type.html',
{
'tform': tform,
}) |
def __init__(self):
self.filediff = None
meldsettings.connect('changed', self.on_setting_changed) | def tearDown(self):
if hasattr(self, "rng_state"):
torch.set_rng_state(self.rng_state) |
def __init__(self):
self.filediff = None
meldsettings.connect('changed', self.on_setting_changed) | def merge(left, right):
if left is None:
return right
if right is None:
return left
if left.prio > right.prio:
left.right = merge(left.right, right)
left.update()
return left
else:
right.left = merge(left, right.left)
right.update()
return right |
def __init__(self):
self.filediff = None
meldsettings.connect('changed', self.on_setting_changed) | def commit(self):
context = self.pop()
if self:
# savepoint
self[-1]['cbs'].extend(context['cbs'])
self[-1]['dirty'] = self[-1]['dirty'] or context['dirty']
else:
# transaction
for func, args, kwargs in context['cbs']:
func(*args, **kwargs) |
def __init__(self):
self.filediff = None
meldsettings.connect('changed', self.on_setting_changed) | def settings(slug=None):
slug = slug if slug else "general"
# get the currently active group
active_group = SettingsGroup.query.filter_by(key=slug).first_or_404()
# get all groups - used to build the navigation
all_groups = SettingsGroup.query.all()
SettingsForm = Setting.get_form(active_group)
old_settings = Setting.get_settings(active_group)
new_settings = {}
form = SettingsForm()
if form.validate_on_submit():
for key, values in iteritems(old_settings):
try:
# check if the value has changed
if values['value'] == form[key].data:
continue
else:
new_settings[key] = form[key].data
except KeyError:
pass
Setting.update(settings=new_settings, app=current_app)
flash(_("Settings saved."), "success")
else:
for key, values in iteritems(old_settings):
try:
form[key].data = values['value']
except (KeyError, ValueError):
pass
return render_template("management/settings.html", form=form,
all_groups=all_groups, active_group=active_group) |
def __init__(self):
self.filediff = None
meldsettings.connect('changed', self.on_setting_changed) | def __enter__(self):
entering = not transaction_states[self.using]
transaction_states[self.using].begin()
self._no_monkey.__enter__(self)
if entering:
on_commit(transaction_states[self.using].commit, self.using) |
def __init__(self):
self.filediff = None
meldsettings.connect('changed', self.on_setting_changed) | def report_markread(report_id=None):
# AJAX request
if request.is_xhr:
ids = request.get_json()["ids"]
data = []
for report in Report.query.filter(Report.id.in_(ids)).all():
report.zapped_by = current_user.id
report.zapped = time_utcnow()
report.save()
data.append({
"id": report.id,
"type": "read",
"reverse": False,
"reverse_name": None,
"reverse_url": None
})
return jsonify(
message="{} reports marked as read.".format(len(data)),
category="success",
data=data,
status=200
)
# mark single report as read
if report_id:
report = Report.query.filter_by(id=report_id).first_or_404()
if report.zapped:
flash(_("Report %(id)s is already marked as read.", id=report.id),
"success")
return redirect(url_for("management.reports"))
report.zapped_by = current_user.id
report.zapped = time_utcnow()
report.save()
flash(_("Report %(id)s marked as read.", id=report.id), "success")
return redirect(url_for("management.reports"))
# mark all as read
reports = Report.query.filter(Report.zapped == None).all()
report_list = []
for report in reports:
report.zapped_by = current_user.id
report.zapped = time_utcnow()
report_list.append(report)
db.session.add_all(report_list)
db.session.commit()
flash(_("All reports were marked as read."), "success")
return redirect(url_for("management.reports")) |
def __init__(self):
self.filediff = None
meldsettings.connect('changed', self.on_setting_changed) | def generateUUID(): # pylint: disable=invalid-name
""" Utility function; generates UUIDs """
return str(uuid.uuid4()) |
def __init__(self):
self.filediff = None
meldsettings.connect('changed', self.on_setting_changed) | def __getitem__(self, idx):
return self._calls[idx] |
def __init__(self):
self.filediff = None
meldsettings.connect('changed', self.on_setting_changed) | def __init__(self, directory=None):
if directory is None:
directory = []
import copy
self.directory = copy.deepcopy(directory)
self.bound = False
self.start_tls_called = False
self.extend = self.Extend(self)
self.operation = {
"!" : self._search_not,
"&" : self._search_and,
"|" : self._search_or,
} |
def __init__(self):
self.filediff = None
meldsettings.connect('changed', self.on_setting_changed) | def modify(self, dn, changes, controls=None):
self.result = { 'dn' : '',
'referrals' : None,
'description' : 'success',
'result' : 0,
'message' : '',
'type' : 'modifyResponse'}
# Check to see if the user exists in the directory
try:
index = self._find_user(dn)
except StopIteration:
# If we get here the user doesn't exist so continue
self.result["description"] = "failure"
self.result["result"] = 32
self.result["message"] = "Error no such object: {0!s}".format(dn)
return False
# extract the hash we are interested in
entry = self.directory[index].get("attributes")
# Loop over the changes hash and apply them
for k, v in changes.items():
if v[0] == "MODIFY_DELETE":
entry.pop(k)
elif v[0] == "MODIFY_REPLACE" or v[0] == "MODIFY_ADD":
entry[k] = v[1][0]
else:
self.result["result"] = 2
self.result["message"] = "Error bad/missing/not implemented" \
"modify operation: %s" % k[1]
# Place the attributes back into the directory hash
self.directory[index]["attributes"] = entry
# Attempt to write changes to disk
with open(DIRECTORY, 'w+') as f:
f.write(str(self.directory))
return True |
def __init__(self):
self.filediff = None
meldsettings.connect('changed', self.on_setting_changed) | def __enter__(self):
self.start() |
def __init__(self):
self.filediff = None
meldsettings.connect('changed', self.on_setting_changed) | def __exit__(self, *args):
self.stop()
self.reset() |
def __init__(self):
self.filediff = None
meldsettings.connect('changed', self.on_setting_changed) | def get_server_mock(self):
return self._server_mock |
def __init__(self):
self.filediff = None
meldsettings.connect('changed', self.on_setting_changed) | def unmount(self, uri):
"""Method called by the mount manager for unmounting the selected URI"""
pass |
def __init__(self):
self.filediff = None
meldsettings.connect('changed', self.on_setting_changed) | def __init__(self, optional=False, choices=None):
self._required = not optional
self._choices = None # Choices doesn't make sense for secrets |
def __init__(self):
self.filediff = None
meldsettings.connect('changed', self.on_setting_changed) | def buffering(self):
return self._bufferedMode |
def __init__(self):
self.filediff = None
meldsettings.connect('changed', self.on_setting_changed) | def __enter__(self):
"""
Syntax sugar which helps in celery tasks, cron jobs, and other scripts
Usage:
with Tenant.objects.get(schema_name='test') as tenant:
# run some code in tenant test
# run some code in previous tenant (public probably)
"""
connection = connections[get_tenant_database_alias()]
self._previous_tenant.append(connection.tenant)
self.activate()
return self |
def __init__(self):
self.filediff = None
meldsettings.connect('changed', self.on_setting_changed) | def orchestrator(self):
"""
:returns: Orchestrator instance.
:rtype: Orchestrator
"""
return self.__orchestrator |
def __init__(self):
self.filediff = None
meldsettings.connect('changed', self.on_setting_changed) | def signal_handler_mapping(self):
"""A dict mapping (signal number) -> (a method handling the signal)."""
# Could use an enum here, but we never end up doing any matching on the specific signal value,
# instead just iterating over the registered signals to set handlers, so a dict is probably
# better.
return {
signal.SIGINT: self._handle_sigint_if_enabled,
signal.SIGQUIT: self.handle_sigquit,
signal.SIGTERM: self.handle_sigterm,
} |
def __init__(self):
self.filediff = None
meldsettings.connect('changed', self.on_setting_changed) | def decrypt(self, enc):
# enc = base64.b64decode(enc)
iv = enc[:AES.block_size]
cipher = AES.new(self.key, AES.MODE_CBC, iv)
return self._unpad(cipher.decrypt(enc[AES.block_size:])).decode('utf-8') |
def __init__(self):
self.filediff = None
meldsettings.connect('changed', self.on_setting_changed) | def _check_layer_operation(example_dict, operation_dict):
"""Error-checks layer operation.
Such operations are used for dimensionality reduction (to convert radar data
from 3-D to 2-D).
:param example_dict: See doc for `reduce_examples_3d_to_2d`.
:param operation_dict: Dictionary with the following keys.
operation_dict["radar_field_name"]: Field to which operation will be
applied.
operation_dict["operation_name"]: Name of operation (must be in list
`VALID_LAYER_OPERATION_NAMES`).
operation_dict["min_height_m_agl"]: Minimum height of layer over which
operation will be applied.
operation_dict["max_height_m_agl"]: Max height of layer over which operation
will be applied.
:raises: ValueError: if something is wrong with the operation params.
"""
if operation_dict[RADAR_FIELD_KEY] in AZIMUTHAL_SHEAR_FIELD_NAMES:
error_string = (
'Layer operations cannot be applied to azimuthal-shear fields '
'(such as "{0:s}").'
).format(operation_dict[RADAR_FIELD_KEY])
raise ValueError(error_string)
if (operation_dict[RADAR_FIELD_KEY] == radar_utils.REFL_NAME
and REFL_IMAGE_MATRIX_KEY in example_dict):
pass
else:
if (operation_dict[RADAR_FIELD_KEY]
not in example_dict[RADAR_FIELDS_KEY]):
error_string = (
'\n{0:s}\nExamples contain only radar fields listed above, '
'which do not include "{1:s}".'
).format(
str(example_dict[RADAR_FIELDS_KEY]),
operation_dict[RADAR_FIELD_KEY]
)
raise ValueError(error_string)
if operation_dict[OPERATION_NAME_KEY] not in VALID_LAYER_OPERATION_NAMES:
error_string = (
'\n{0:s}\nValid operations (listed above) do not include '
'"{1:s}".'
).format(
str(VALID_LAYER_OPERATION_NAMES), operation_dict[OPERATION_NAME_KEY]
)
raise ValueError(error_string)
min_height_m_agl = operation_dict[MIN_HEIGHT_KEY]
max_height_m_agl = operation_dict[MAX_HEIGHT_KEY]
error_checking.assert_is_geq(
min_height_m_agl, numpy.min(example_dict[RADAR_HEIGHTS_KEY])
)
error_checking.assert_is_leq(
max_height_m_agl, numpy.max(example_dict[RADAR_HEIGHTS_KEY])
)
error_checking.assert_is_greater(max_height_m_agl, min_height_m_agl) |
def __init__(self):
self.filediff = None
meldsettings.connect('changed', self.on_setting_changed) | def __init__(self):
self._cache = {}
self._bucket_client = None
self._param_client = None
self._secret_client = None |
def __init__(self):
self.filediff = None
meldsettings.connect('changed', self.on_setting_changed) | def _get_or_create_cached_value(self, key, getter, ttl=None):
# happy path
try:
expiry, value = self._cache[key]
except KeyError:
pass
else:
if expiry is None or time.time() < expiry:
logger.debug("Key %s from cache", key)
return value
logger.debug("Cache for key %s has expired", key)
# get value
value = getter()
if ttl:
expiry = time.time() + ttl
else:
expiry = None
self._cache[key] = (expiry, value)
logger.debug("Set cache for key %s", key)
return value |
def __init__(self):
self.filediff = None
meldsettings.connect('changed', self.on_setting_changed) | def __getitem__(self, key):
value = self._collection[key]
if isinstance(key, slice):
slice_repr = ":".join(str("" if i is None else i) for i in (key.start, key.stop, key.step))
logger.debug("Get /%s[%s] config key", "/".join(self._path), slice_repr)
return [self._to_python(item) for item in value]
else:
logger.debug("Get /%s[%s] config key", "/".join(self._path), key)
return self._to_python(value) |
def __init__(self):
self.filediff = None
meldsettings.connect('changed', self.on_setting_changed) | def add_backend(self, backend):
"""
Adds a new backend to the list
@param backend_id: the id of the backend to add
"""
if backend:
backend_iter = self.liststore.append([
backend.get_id(),
self.dialog.get_pixbuf_from_icon_name(backend.get_icon(),
16),
backend.get_human_name(),
self._get_markup_for_tags(backend.get_attached_tags()),
])
self.backendid_to_iter[backend.get_id()] = backend_iter |