input
stringlengths 11
5.29k
| target
stringlengths 20
8.26k
|
|---|---|
def __init__(self):
self.filediff = None
meldsettings.connect('changed', self.on_setting_changed) | def delete_group(group_id=None):
if request.is_xhr:
ids = request.get_json()["ids"]
if not (set(ids) & set(["1", "2", "3", "4", "5"])):
data = []
for group in Group.query.filter(Group.id.in_(ids)).all():
group.delete()
data.append({
"id": group.id,
"type": "delete",
"reverse": False,
"reverse_name": None,
"reverse_url": None
})
return jsonify(
message="{} groups deleted.".format(len(data)),
category="success",
data=data,
status=200
)
return jsonify(
message=_("You cannot delete one of the standard groups."),
category="danger",
data=None,
status=404
)
if group_id is not None:
if group_id <= 5: # there are 5 standard groups
flash(_("You cannot delete the standard groups. "
"Try renaming it instead.", "danger"))
return redirect(url_for("management.groups"))
group = Group.query.filter_by(id=group_id).first_or_404()
group.delete()
flash(_("Group deleted."), "success")
return redirect(url_for("management.groups"))
flash(_("No group chosen."), "danger")
return redirect(url_for("management.groups")) |
def __init__(self):
self.filediff = None
meldsettings.connect('changed', self.on_setting_changed) | def delete_forum(forum_id):
forum = Forum.query.filter_by(id=forum_id).first_or_404()
involved_users = User.query.filter(Topic.forum_id == forum.id,
Post.user_id == User.id).all()
forum.delete(involved_users)
flash(_("Forum deleted."), "success")
return redirect(url_for("management.forums")) |
def __init__(self):
self.filediff = None
meldsettings.connect('changed', self.on_setting_changed) | def delete_category(category_id):
category = Category.query.filter_by(id=category_id).first_or_404()
involved_users = User.query.filter(Forum.category_id == category.id,
Topic.forum_id == Forum.id,
Post.user_id == User.id).all()
category.delete(involved_users)
flash(_("Category with all associated forums deleted."), "success")
return redirect(url_for("management.forums")) |
def __init__(self):
self.filediff = None
meldsettings.connect('changed', self.on_setting_changed) | def uninstall_plugin(plugin):
plugin = get_plugin_from_all(plugin)
if plugin.uninstallable:
plugin.uninstall()
Setting.invalidate_cache()
flash(_("Plugin has been uninstalled."), "success")
else:
flash(_("Cannot uninstall plugin."), "danger")
return redirect(url_for("management.plugins")) |
def __init__(self):
self.filediff = None
meldsettings.connect('changed', self.on_setting_changed) | def delete(self, dn, controls=None):
self.result = { 'dn' : '',
'referrals' : None,
'description' : 'success',
'result' : 0,
'message' : '',
'type' : 'addResponse'}
# 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}".format(dn)
return False
# Delete the entry object for the user
self.directory.pop(index)
# 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 exitMode(self, mode):
if mode in self.modeList:
self.modeList.remove(mode) |
def __init__(self):
self.filediff = None
meldsettings.connect('changed', self.on_setting_changed) | def _drop_schema(self, force_drop=False):
""" Drops the schema"""
connection = connections[get_tenant_database_alias()]
has_schema = hasattr(connection, 'schema_name')
if has_schema and connection.schema_name not in (self.schema_name, get_public_schema_name()):
raise Exception("Can't delete tenant outside it's own schema or "
"the public schema. Current schema is %s."
% connection.schema_name)
if has_schema and schema_exists(self.schema_name) and (self.auto_drop_schema or force_drop):
self.pre_drop()
cursor = connection.cursor()
cursor.execute('DROP SCHEMA "%s" CASCADE' % self.schema_name) |
def __init__(self):
self.filediff = None
meldsettings.connect('changed', self.on_setting_changed) | def pre_drop(self):
"""
This is a routine which you could override to backup the tenant schema before dropping.
:return:
""" |
def __init__(self):
self.filediff = None
meldsettings.connect('changed', self.on_setting_changed) | def delete(self, force_drop=False, *args, **kwargs):
"""
Deletes this row. Drops the tenant's schema if the attribute
auto_drop_schema set to True.
"""
self._drop_schema(force_drop)
super().delete(*args, **kwargs) |
def __init__(self):
self.filediff = None
meldsettings.connect('changed', self.on_setting_changed) | def remove_vpp_config(self):
self._test.vapi.ip_punt_redirect(punt=self.encode(), is_add=False) |
def __init__(self):
self.filediff = None
meldsettings.connect('changed', self.on_setting_changed) | def __delitem__(self, key):
del self._collection[key] |
def __init__(self):
self.filediff = None
meldsettings.connect('changed', self.on_setting_changed) | def clear(self):
return self._collection.clear() |
def __init__(self):
self.filediff = None
meldsettings.connect('changed', self.on_setting_changed) | def remove_backend(self, backend_id):
""" Removes a backend from the treeview, and selects the first (to show
something in the configuration panel
@param backend_id: the id of the backend to remove
"""
if backend_id in self.backendid_to_iter:
self.liststore.remove(self.backendid_to_iter[backend_id])
del self.backendid_to_iter[backend_id]
self.select_backend() |
def __init__(self):
self.filediff = None
meldsettings.connect('changed', self.on_setting_changed) | def clear(self):
for unused_ in range(len(self._items)):
self.remove_item(self._items[0]) |
def __init__(self):
self.filediff = None
meldsettings.connect('changed', self.on_setting_changed) | def _on_item_button_remove_clicked(self, button, item):
self.remove_item(item) |
def __init__(self):
self.filediff = None
meldsettings.connect('changed', self.on_setting_changed) | def button_remove(self):
return self._button_remove |
def __init__(self):
self.filediff = None
meldsettings.connect('changed', self.on_setting_changed) | def remove_item(self, item):
if (self._locker.is_unlocked("prevent_removal_below_min_size")
and len(self._items) == self._min_size):
return |
def __init__(self):
self.filediff = None
meldsettings.connect('changed', self.on_setting_changed) | def remove(self):
self._set_changed_options()
if self.module.check_mode:
return True
self.remove_from_device()
if self.exists():
raise F5ModuleError("Failed to delete the resource.")
# Artificial sleeping to wait for remote licensing (on BIG-IP) to complete
#
# This should be something that BIG-IQ can do natively in 6.1-ish time.
time.sleep(60)
return True |
def __init__(self):
self.filediff = None
meldsettings.connect('changed', self.on_setting_changed) | def remove_from_device(self):
uri = 'https://{0}:{1}/mgmt/cm/device/licensing/pool/regkey/licenses/{2}/offerings/{3}/members/{4}'.format(
self.client.provider['server'],
self.client.provider['server_port'],
self.want.pool_id,
self.want.key,
self.want.member_id
)
params = {}
if not self.want.managed:
params.update(self.changes.api_params())
params['id'] = self.want.member_id
params['username'] = self.want.device_username
params['password'] = self.want.device_password
self.client.api.delete(uri, json=params) |
def __init__(self):
self.filediff = None
meldsettings.connect('changed', self.on_setting_changed) | def sample_delete_study():
# Create a client
client = aiplatform_v1.VizierServiceClient()
# Initialize request argument(s)
request = aiplatform_v1.DeleteStudyRequest(
name="name_value",
)
# Make the request
client.delete_study(request=request) |
def __init__(self):
self.filediff = None
meldsettings.connect('changed', self.on_setting_changed) | def remove_api_resource_names(self, url_dict):
"""
Given a dictionary of regex matches from a URLconf, removes
``api_name`` and/or ``resource_name`` if found. |
def __init__(self):
self.filediff = None
meldsettings.connect('changed', self.on_setting_changed) | def obj_delete_list(self, request=None, **kwargs):
"""
Deletes an entire list of objects. |
def __init__(self):
self.filediff = None
meldsettings.connect('changed', self.on_setting_changed) | def obj_delete(self, request=None, **kwargs):
"""
Deletes a single object. |
def __init__(self):
self.filediff = None
meldsettings.connect('changed', self.on_setting_changed) | def rollback(self, bundles):
"""
Given the list of bundles, delete all objects pertaining to those
bundles. |
def __init__(self):
self.filediff = None
meldsettings.connect('changed', self.on_setting_changed) | def delete_list(self, request, **kwargs):
"""
Destroys a collection of resources/objects. |
def __init__(self):
self.filediff = None
meldsettings.connect('changed', self.on_setting_changed) | def delete_detail(self, request, **kwargs):
"""
Destroys a single resource/object. |
def __init__(self):
self.filediff = None
meldsettings.connect('changed', self.on_setting_changed) | def obj_delete_list(self, request=None, **kwargs):
"""
A ORM-specific implementation of ``obj_delete_list``. |
def __init__(self):
self.filediff = None
meldsettings.connect('changed', self.on_setting_changed) | def obj_delete(self, request=None, **kwargs):
"""
A ORM-specific implementation of ``obj_delete``. |
def __init__(self):
self.filediff = None
meldsettings.connect('changed', self.on_setting_changed) | def convert_post_to_put(request):
"""
Force Django to process the PUT.
"""
if request.method == "PUT":
if hasattr(request, '_post'):
del request._post
del request._files |
def __init__(self):
self.filediff = None
meldsettings.connect('changed', self.on_setting_changed) | def delete_previous_logs():
cmd = 'rm -rf logs/*'
cr.run_command(cmd) |
def __init__(self):
self.filediff = None
meldsettings.connect('changed', self.on_setting_changed) | def delete_autoscaling_group(connection, module):
group_name = module.params.get('name')
notification_topic = module.params.get('notification_topic')
if notification_topic:
ag.delete_notification_configuration(notification_topic)
groups = connection.get_all_groups(names=[group_name])
if groups:
group = groups[0]
group.max_size = 0
group.min_size = 0
group.desired_capacity = 0
group.update()
instances = True
while instances:
tmp_groups = connection.get_all_groups(names=[group_name])
if tmp_groups:
tmp_group = tmp_groups[0]
if not tmp_group.instances:
instances = False
time.sleep(10)
group.delete()
while len(connection.get_all_groups(names=[group_name])):
time.sleep(5)
changed=True
return changed
else:
changed=False
return changed |
def __init__(self):
self.filediff = None
meldsettings.connect('changed', self.on_setting_changed) | def destroyMod(self):
self.scene().removeItem(self._mod_item)
self._mod_item = None
self._mod_id = None |
def __init__(self):
self.filediff = None
meldsettings.connect('changed', self.on_setting_changed) | def destroyItem(self):
'''Remove this object and references to it from the view
'''
scene = self.scene()
if self._mod_item is not None:
self.destroyMod()
scene.removeItem(self._click_area)
self._click_area = None
scene.removeItem(self) |
def __init__(self):
self.filediff = None
meldsettings.connect('changed', self.on_setting_changed) | def delete(self):
if self.geom:
self.geom.removeNode()
self.geom = None
if self.ceo:
self.ceo.delete()
self.ceo = None
ThreeDScene.delete(self)
return |
def __init__(self):
self.filediff = None
meldsettings.connect('changed', self.on_setting_changed) | def delete(self):
if self.geom:
self.geom.removeNode()
self.geom = None
if self.cog:
self.cog.delete()
self.cog = None
ThreeDScene.delete(self)
return |
def __init__(self):
self.filediff = None
meldsettings.connect('changed', self.on_setting_changed) | def delete(self):
if self.geom:
self.geom.removeNode()
self.geom = None
for npc in self.npcs:
taskMgr.remove(npc.uniqueName('randomEmote'))
npc.delete() |
def __init__(self):
self.filediff = None
meldsettings.connect('changed', self.on_setting_changed) | def test_remove(self, local_rm_mock, exists_mock, sudo_mock):
script = ('if [ -f /etc/presto/catalog/tpch.properties ] ; '
'then rm /etc/presto/catalog/tpch.properties ; '
'else echo "Could not remove catalog \'tpch\'. '
'No such file \'/etc/presto/catalog/tpch.properties\'"; fi')
exists_mock.return_value = True
fabric.api.env.host = 'localhost'
catalog.remove('tpch')
sudo_mock.assert_called_with(script)
local_rm_mock.assert_called_with(get_catalog_directory() +
'/tpch.properties') |
def __init__(self):
self.filediff = None
meldsettings.connect('changed', self.on_setting_changed) | def test_remove_no_such_file(self, exists_mock, sudo_mock):
exists_mock.return_value = False
fabric.api.env.host = 'localhost'
error_msg = ('Could not remove catalog tpch: No such file ' +
os.path.join(get_catalog_directory(), 'tpch.properties'))
out = _AttributeString(error_msg)
out.succeeded = True
sudo_mock.return_value = out
self.assertRaisesRegexp(SystemExit,
'\\[localhost\\] %s' % error_msg,
catalog.remove,
'tpch') |
def __init__(self):
self.filediff = None
meldsettings.connect('changed', self.on_setting_changed) | def test_remove_os_error(self, remove_file_mock, remove_mock):
fabric.api.env.host = 'localhost'
error = OSError(13, 'Permission denied')
remove_mock.side_effect = error
self.assertRaisesRegexp(OSError, 'Permission denied',
catalog.remove, 'tpch') |
def __init__(self):
self.filediff = None
meldsettings.connect('changed', self.on_setting_changed) | def clear_all_markers(self):
pv = self.pile_viewer
QTest.keyPress(pv, 'A', Qt.ShiftModifier, 10)
QTest.keyPress(pv, Qt.Key_Backspace)
self.assertEqual(len(pv.viewer.get_markers()), 0) |
def __init__(self):
self.filediff = None
meldsettings.connect('changed', self.on_setting_changed) | def remove_entry(data, key, sep='.'):
''' remove data at location key '''
if key == '' and isinstance(data, dict):
data.clear()
return True
elif key == '' and isinstance(data, list):
del data[:]
return True
if not (key and Yedit.valid_key(key, sep)) and \
isinstance(data, (list, dict)):
return None
key_indexes = Yedit.parse_key(key, sep)
for arr_ind, dict_key in key_indexes[:-1]:
if dict_key and isinstance(data, dict):
data = data.get(dict_key)
elif (arr_ind and isinstance(data, list) and
int(arr_ind) <= len(data) - 1):
data = data[int(arr_ind)]
else:
return None
# process last index for remove
# expected list entry
if key_indexes[-1][0]:
if isinstance(data, list) and int(key_indexes[-1][0]) <= len(data) - 1: # noqa: E501
del data[int(key_indexes[-1][0])]
return True
# expected dict entry
elif key_indexes[-1][1]:
if isinstance(data, dict):
del data[key_indexes[-1][1]]
return True |
def __init__(self):
self.filediff = None
meldsettings.connect('changed', self.on_setting_changed) | def delete(self, path):
''' remove path from a dict'''
try:
entry = Yedit.get_entry(self.yaml_dict, path, self.separator)
except KeyError:
entry = None
if entry is None:
return (False, self.yaml_dict)
result = Yedit.remove_entry(self.yaml_dict, path, self.separator)
if not result:
return (False, self.yaml_dict)
return (True, self.yaml_dict) |
def __init__(self):
self.filediff = None
meldsettings.connect('changed', self.on_setting_changed) | def _delete(self, resource, name=None, selector=None):
'''call oc delete on a resource'''
cmd = ['delete', resource]
if selector is not None:
cmd.append('--selector={}'.format(selector))
elif name is not None:
cmd.append(name)
else:
raise OpenShiftCLIError('Either name or selector is required when calling delete.')
return self.openshift_cmd(cmd) |
def __init__(self):
self.filediff = None
meldsettings.connect('changed', self.on_setting_changed) | def delete_env_var(self, keys):
'''delete a list of keys '''
if not isinstance(keys, list):
keys = [keys]
env_vars_array = self.get_env_vars()
modified = False
idx = None
for key in keys:
for env_idx, env_var in enumerate(env_vars_array):
if env_var['name'] == key:
idx = env_idx
break
if idx:
modified = True
del env_vars_array[idx]
if modified:
return True
return False |
def __init__(self):
self.filediff = None
meldsettings.connect('changed', self.on_setting_changed) | def delete_volume_by_name(self, volume):
'''delete a volume '''
modified = False
exist_volume_mounts = self.get_volume_mounts()
exist_volumes = self.get_volumes()
del_idx = None
for idx, exist_volume in enumerate(exist_volumes):
if 'name' in exist_volume and exist_volume['name'] == volume['name']:
del_idx = idx
break
if del_idx != None:
del exist_volumes[del_idx]
modified = True
del_idx = None
for idx, exist_volume_mount in enumerate(exist_volume_mounts):
if 'name' in exist_volume_mount and exist_volume_mount['name'] == volume['name']:
del_idx = idx
break
if del_idx != None:
del exist_volume_mounts[idx]
modified = True
return modified |
def __init__(self):
self.filediff = None
meldsettings.connect('changed', self.on_setting_changed) | def delete_secret(self, key):
''' delete secret'''
try:
del self.secrets[key]
except KeyError as _:
return False
return True |
def __init__(self):
self.filediff = None
meldsettings.connect('changed', self.on_setting_changed) | def delete_ports(self, inc_ports):
''' remove a port from a service '''
if not isinstance(inc_ports, list):
inc_ports = [inc_ports]
ports = self.get(Service.port_path) or []
if not ports:
return True
removed = False
for inc_port in inc_ports:
port = self.find_ports(inc_port)
if port:
ports.remove(port)
removed = True
return removed |
def __init__(self):
self.filediff = None
meldsettings.connect('changed', self.on_setting_changed) | def delete_external_ips(self, inc_external_ips):
''' remove an external IP from a service '''
if not isinstance(inc_external_ips, list):
inc_external_ips = [inc_external_ips]
external_ips = self.get(Service.external_ips) or []
if not external_ips:
return True
removed = False
for inc_external_ip in inc_external_ips:
external_ip = self.find_external_ips(inc_external_ip)
if external_ip:
external_ips.remove(external_ip)
removed = True
return removed |
def __init__(self):
self.filediff = None
meldsettings.connect('changed', self.on_setting_changed) | def delete(self, complete=True):
'''return all pods '''
parts = []
for part in self.registry_parts:
if not complete and part['kind'] == 'svc':
continue
parts.append(self._delete(part['kind'], part['name']))
# Clean up returned results
rval = 0
for part in parts:
# pylint: disable=invalid-sequence-index
if 'returncode' in part and part['returncode'] != 0:
rval = part['returncode']
return {'returncode': rval, 'results': parts} |
def __init__(self):
self.filediff = None
meldsettings.connect('changed', self.on_setting_changed) | def assert_no_mappers():
clear_mappers()
gc_collect()
assert len(_mapper_registry) == 0 |
def __init__(self):
self.filediff = None
meldsettings.connect('changed', self.on_setting_changed) | def setup(self):
_sessions.clear()
_mapper_registry.clear() |
def __init__(self):
self.filediff = None
meldsettings.connect('changed', self.on_setting_changed) | def go():
engine = engines.testing_engine(
options={'logging_name':'FOO',
'pool_logging_name':'BAR',
'use_reaper':False}
)
sess = create_session(bind=engine)
a1 = A(col2="a1")
a2 = A(col2="a2")
a3 = A(col2="a3")
a1.bs.append(B(col2="b1"))
a1.bs.append(B(col2="b2"))
a3.bs.append(B(col2="b3"))
for x in [a1,a2,a3]:
sess.add(x)
sess.flush()
sess.expunge_all()
alist = sess.query(A).all()
eq_(
[
A(col2="a1", bs=[B(col2="b1"), B(col2="b2")]),
A(col2="a2", bs=[]),
A(col2="a3", bs=[B(col2="b3")])
],
alist)
for a in alist:
sess.delete(a)
sess.flush()
sess.close()
engine.dispose() |
def __init__(self):
self.filediff = None
meldsettings.connect('changed', self.on_setting_changed) | def ansible_repository(appliance, wait_for_ansible):
repositories = appliance.collections.ansible_repositories
try:
repository = repositories.create(
name=fauxfactory.gen_alpha(),
url=cfme_data.ansible_links.playbook_repositories.embedded_ansible,
description=fauxfactory.gen_alpha())
except KeyError:
pytest.skip("Skipping since no such key found in yaml")
view = navigate_to(repository, "Details")
wait_for(
lambda: view.entities.summary("Properties").get_text_of("Status") == "successful",
timeout=60,
fail_func=view.toolbar.refresh.click
)
yield repository
repository.delete_if_exists() |
def __init__(self):
self.filediff = None
meldsettings.connect('changed', self.on_setting_changed) | def ansible_action(appliance, ansible_catalog_item):
action_collection = appliance.collections.actions
action = action_collection.create(
fauxfactory.gen_alphanumeric(),
action_type="Run Ansible Playbook",
action_values={
"run_ansible_playbook": {
"playbook_catalog_item": ansible_catalog_item.name
}
}
)
yield action
action.delete_if_exists() |
def __init__(self):
self.filediff = None
meldsettings.connect('changed', self.on_setting_changed) | def service_request(appliance, ansible_catalog_item):
request_desc = "Provisioning Service [{0}] from [{0}]".format(ansible_catalog_item.name)
_service_request = appliance.collections.requests.instantiate(request_desc)
yield _service_request
_service_request.delete_if_exists() |
def __init__(self):
self.filediff = None
meldsettings.connect('changed', self.on_setting_changed) | def service(appliance, ansible_catalog_item):
service_ = MyService(appliance, ansible_catalog_item.name)
yield service_
if service_.exists:
service_.delete() |
def __init__(self):
self.filediff = None
meldsettings.connect('changed', self.on_setting_changed) | def delete(
self,
scope: str,
policy_assignment_name: str,
**kwargs: Any
) -> Optional["_models.PolicyAssignment"]:
"""Deletes a policy assignment.
:param scope: The scope of the policy assignment.
:type scope: str
:param policy_assignment_name: The name of the policy assignment to delete.
:type policy_assignment_name: str
:keyword callable cls: A custom type or function that will be passed the direct response
:return: PolicyAssignment, or the result of cls(response)
:rtype: ~azure.mgmt.resource.policy.v2016_12_01.models.PolicyAssignment or None
:raises: ~azure.core.exceptions.HttpResponseError
"""
cls = kwargs.pop('cls', None) # type: ClsType[Optional["_models.PolicyAssignment"]]
error_map = {
401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError
}
error_map.update(kwargs.pop('error_map', {})) |
def __init__(self):
self.filediff = None
meldsettings.connect('changed', self.on_setting_changed) | def delete_by_id(
self,
policy_assignment_id: str,
**kwargs: Any
) -> "_models.PolicyAssignment":
"""Deletes a policy assignment by ID.
When providing a scope for the assignment, use '/subscriptions/{subscription-id}/' for
subscriptions, '/subscriptions/{subscription-id}/resourceGroups/{resource-group-name}' for
resource groups, and
'/subscriptions/{subscription-id}/resourceGroups/{resource-group-name}/providers/{resource-provider-namespace}/{resource-type}/{resource-name}'
for resources.
:param policy_assignment_id: The ID of the policy assignment to delete. Use the format
'/{scope}/providers/Microsoft.Authorization/policyAssignments/{policy-assignment-name}'.
:type policy_assignment_id: str
:keyword callable cls: A custom type or function that will be passed the direct response
:return: PolicyAssignment, or the result of cls(response)
:rtype: ~azure.mgmt.resource.policy.v2016_12_01.models.PolicyAssignment
:raises: ~azure.core.exceptions.HttpResponseError
"""
cls = kwargs.pop('cls', None) # type: ClsType["_models.PolicyAssignment"]
error_map = {
401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError
}
error_map.update(kwargs.pop('error_map', {})) |
def __init__(self):
self.filediff = None
meldsettings.connect('changed', self.on_setting_changed) | def pop(self):
"""
Pops the latest additional context.
If the additional context was pushed by a different additional manager,
a ``RuntimeError`` is raised.
"""
rv = _additional_ctx_stack.pop()
if rv is None or rv[0] is not self:
raise RuntimeError(
"popped wrong additional context ({} instead of {})".format(rv, self)
) |
def __init__(self):
self.filediff = None
meldsettings.connect('changed', self.on_setting_changed) | def backwards(self, orm):
# Removing unique constraint on 'Vendeur', fields ['code_permanent']
db.delete_unique(u'encefal_vendeur', ['code_permanent']) |
def __init__(self):
self.filediff = None
meldsettings.connect('changed', self.on_setting_changed) | def OnDeleteProperty(self, event):
p = self.pg.GetSelectedProperty()
if p:
self.pg.DeleteProperty(p)
else:
wx.MessageBox("First select a property to delete") |
def __init__(self):
self.filediff = None
meldsettings.connect('changed', self.on_setting_changed) | def delete(no_logs, config_file):
"""Delete the project."""
config = _load_config(config_file)
s3 = boto3.client('s3')
cfn = boto3.client('cloudformation')
logs = boto3.client('logs')
try:
stack = cfn.describe_stacks(StackName=config['name'])['Stacks'][0]
except botocore.exceptions.ClientError:
raise RuntimeError('This project has not been deployed yet.')
bucket = _get_from_stack(stack, 'Parameter', 'LambdaS3Bucket')
lambda_package = _get_from_stack(stack, 'Parameter', 'LambdaS3Key')
function = _get_from_stack(stack, 'Output', 'FunctionArn').split(':')[-1]
api_id = _get_from_stack(stack, 'Output', 'ApiId')
if api_id:
log_groups = ['API-Gateway-Execution-Logs_' + api_id + '/' + stage
for stage in config['stage_environments'].keys()]
else:
log_groups = []
log_groups.append('/aws/lambda/' + function)
print('Deleting {}...'.format(config['name']))
cfn.delete_stack(StackName=config['name'])
waiter = cfn.get_waiter('stack_delete_complete')
waiter.wait(StackName=config['name'])
if not no_logs:
print('Deleting logs...')
for log_group in log_groups:
try:
logs.delete_log_group(logGroupName=log_group)
except botocore.exceptions.ClientError:
print(' Log group {} could not be deleted.'.format(log_group))
print('Deleting files...')
try:
s3.delete_object(Bucket=bucket, Key=lambda_package)
s3.delete_bucket(Bucket=bucket)
except botocore.exceptions.ClientError:
print(' S3 bucket {} could not be deleted.'.format(bucket)) |
def __init__(self):
self.filediff = None
meldsettings.connect('changed', self.on_setting_changed) | def done(response):
# A count response; [(cnt,)]
if response[0][0] == 0:
try:
os.remove(self.db_path)
except:
# Failed for some reason
_log.warning("Could not remove db file {}".format(self._dbpath)) |
def __init__(self):
self.filediff = None
meldsettings.connect('changed', self.on_setting_changed) | def test_multiarray_flags_writable_attribute_deletion(self):
a = np.ones(2).flags
attr = ['updateifcopy', 'aligned', 'writeable']
for s in attr:
assert_raises(AttributeError, delattr, a, s) |
def __init__(self):
self.filediff = None
meldsettings.connect('changed', self.on_setting_changed) | def i_deselect_all_objects():
bpy.context.view_layer.objects.active = None
bpy.ops.object.select_all(action="DESELECT") |
def __init__(self):
self.filediff = None
meldsettings.connect('changed', self.on_setting_changed) | def i_delete_the_selected_objects():
bpy.ops.object.delete()
blenderbim.bim.handler.active_object_callback() |
def __init__(self):
self.filediff = None
meldsettings.connect('changed', self.on_setting_changed) | def _maybe_name(obj):
"""Returns object name if it has one, or a message otherwise.
This is useful for names that apper in error messages.
Args:
obj: Object to get the name of.
Returns:
name, "None", or a "no name" message.
"""
if obj is None:
return "None"
elif hasattr(obj, "name"):
return obj.name
else:
return "<no name for %s>" % type(obj) |
def __init__(self):
self.filediff = None
meldsettings.connect('changed', self.on_setting_changed) | def __str__(self):
return str(self.board) |
def __init__(self):
self.filediff = None
meldsettings.connect('changed', self.on_setting_changed) | def get_attn(attn_type):
if isinstance(attn_type, torch.nn.Module):
return attn_type
module_cls = None
if attn_type is not None:
if isinstance(attn_type, str):
attn_type = attn_type.lower()
# Lightweight attention modules (channel and/or coarse spatial).
# Typically added to existing network architecture blocks in addition to existing convolutions.
if attn_type == 'se':
module_cls = SEModule
elif attn_type == 'ese':
module_cls = EffectiveSEModule
elif attn_type == 'eca':
module_cls = EcaModule
elif attn_type == 'ecam':
module_cls = partial(EcaModule, use_mlp=True)
elif attn_type == 'ceca':
module_cls = CecaModule
elif attn_type == 'ge':
module_cls = GatherExcite
elif attn_type == 'gc':
module_cls = GlobalContext
elif attn_type == 'gca':
module_cls = partial(GlobalContext, fuse_add=True, fuse_scale=False)
elif attn_type == 'cbam':
module_cls = CbamModule
elif attn_type == 'lcbam':
module_cls = LightCbamModule
# Attention / attention-like modules w/ significant params
# Typically replace some of the existing workhorse convs in a network architecture.
# All of these accept a stride argument and can spatially downsample the input.
elif attn_type == 'sk':
module_cls = SelectiveKernel
elif attn_type == 'splat':
module_cls = SplitAttn
# Self-attention / attention-like modules w/ significant compute and/or params
# Typically replace some of the existing workhorse convs in a network architecture.
# All of these accept a stride argument and can spatially downsample the input.
elif attn_type == 'lambda':
return LambdaLayer
elif attn_type == 'bottleneck':
return BottleneckAttn
elif attn_type == 'halo':
return HaloAttn
elif attn_type == 'nl':
module_cls = NonLocalAttn
elif attn_type == 'bat':
module_cls = BatNonLocalAttn
# Woops!
else:
assert False, "Invalid attn module (%s)" % attn_type
elif isinstance(attn_type, bool):
if attn_type:
module_cls = SEModule
else:
module_cls = attn_type
return module_cls |
def __init__(self):
self.filediff = None
meldsettings.connect('changed', self.on_setting_changed) | def summary(self) -> str:
raise NotImplementedError |
def __init__(self):
self.filediff = None
meldsettings.connect('changed', self.on_setting_changed) | def start(self, action_name: str) -> None:
pass |
def __init__(self):
self.filediff = None
meldsettings.connect('changed', self.on_setting_changed) | def get_buffer(self, sizehint):
return self.buffer |
def __init__(self):
self.filediff = None
meldsettings.connect('changed', self.on_setting_changed) | def available_translations(self):
return list(self.translations) |
def __init__(self):
self.filediff = None
meldsettings.connect('changed', self.on_setting_changed) | def __repr__(self):
return "<%s>" % self.__class__.__name__ |
def __init__(self):
self.filediff = None
meldsettings.connect('changed', self.on_setting_changed) | def prefix(self):
return self._prefix |
def __init__(self):
self.filediff = None
meldsettings.connect('changed', self.on_setting_changed) | def always(self):
return self._always |
def __init__(self):
self.filediff = None
meldsettings.connect('changed', self.on_setting_changed) | def sm_name(section: str) -> str:
""":return: name of the submodule as parsed from the section name"""
section = section.strip()
return section[11:-1] |
def __init__(self):
self.filediff = None
meldsettings.connect('changed', self.on_setting_changed) | def plugin(self):
return plugins.get(self.plugin_name) |
def __init__(self):
self.filediff = None
meldsettings.connect('changed', self.on_setting_changed) | def getText(self, callingWindow, itmContext, mainItem):
return "Set {} as Damage Pattern".format(itmContext if itmContext is not None else "Item") |
def __init__(self):
self.filediff = None
meldsettings.connect('changed', self.on_setting_changed) | def emitted(self):
return self._queue |
def __init__(self):
self.filediff = None
meldsettings.connect('changed', self.on_setting_changed) | def __init__(self):
self._calls = [] |
def __init__(self):
self.filediff = None
meldsettings.connect('changed', self.on_setting_changed) | def __iter__(self):
return iter(self._calls) |
def __init__(self):
self.filediff = None
meldsettings.connect('changed', self.on_setting_changed) | def __len__(self):
return len(self._calls) |
def __init__(self):
self.filediff = None
meldsettings.connect('changed', self.on_setting_changed) | def __unicode__(self):
return 'SSOIDVerification for {name}, status: {status}'.format(
name=self.name,
status=self.status,
) |
def __init__(self):
self.filediff = None
meldsettings.connect('changed', self.on_setting_changed) | def calls(self):
return self._calls |
def __init__(self):
self.filediff = None
meldsettings.connect('changed', self.on_setting_changed) | def get_container(self):
"""Return container widget"""
return self._container |
def __init__(self):
self.filediff = None
meldsettings.connect('changed', self.on_setting_changed) | def get_information(self):
"""Returns information about extension"""
icon = None
name = None
return icon, name |
def __init__(self):
self.filediff = None
meldsettings.connect('changed', self.on_setting_changed) | def deserialize(self, value):
return DeprecatedValue() |
def __init__(self):
self.filediff = None
meldsettings.connect('changed', self.on_setting_changed) | def serialize(self, value, display=False):
return DeprecatedValue() |
def __init__(self):
self.filediff = None
meldsettings.connect('changed', self.on_setting_changed) | def __init__(self, original, expanded):
self.original = original |
def __init__(self):
self.filediff = None
meldsettings.connect('changed', self.on_setting_changed) | def get_inputs(self):
return self.distribution.headers or [] |
def __init__(self):
self.filediff = None
meldsettings.connect('changed', self.on_setting_changed) | def address(self):
return self.addr |
def __init__(self):
self.filediff = None
meldsettings.connect('changed', self.on_setting_changed) | def length(self):
return self.glen |
def __init__(self):
self.filediff = None
meldsettings.connect('changed', self.on_setting_changed) | def get_global_exiter(cls) -> Optional[Exiter]:
return cls._exiter |
def __init__(self):
self.filediff = None
meldsettings.connect('changed', self.on_setting_changed) | def __getitem__(self, key):
return self._raw[key] |
def __init__(self):
self.filediff = None
meldsettings.connect('changed', self.on_setting_changed) | def get(self):
return os.environ[self._name] |
def __init__(self):
self.filediff = None
meldsettings.connect('changed', self.on_setting_changed) | def __getattr__(self, name: str) -> Any:
"""Custom __getattr__ to allow access to metrics schema fields."""
if name not in self._metric_fields:
raise AttributeError('No field: {} in metrics.'.format(name))
return self._values[name] |
def __init__(self):
self.filediff = None
meldsettings.connect('changed', self.on_setting_changed) | def _to_python(self, value):
if isinstance(value, Proxy):
return value.get()
else:
return value |
def __init__(self):
self.filediff = None
meldsettings.connect('changed', self.on_setting_changed) | def __len__(self):
return len(self._collection) |
def __init__(self):
self.filediff = None
meldsettings.connect('changed', self.on_setting_changed) | def getHead(self):
return self.Head |