.. versionchanged:: 2.0.0
       Remove parameter *debug*.
498432
def run(icon=None):
    
    app = wx.App()
    frame = myappframe.MyAppFrame(None,
                                  u'Lattice Viewer \u2014 Accelerator Online Modeling Tool')
    frame.SetSize((1024, 768))
    frame.Show()
    if icon is not None:
        frame.SetIcon(icon)
    app.MainLoop()
1253072
def remove(self, iocb):
        """"""
        if _debug: IOQueue._debug("remove %r", iocb)

        # remove the request from the queue
        for i, item in enumerate(self.queue):
            if iocb is item[1]:
                if _debug: IOQueue._debug("    - found at %d", i)
                del self.queue[i]

                # if the queue is empty, clear the event
                qlen = len(self.queue)
                if not qlen:
                    self.notempty.clear()

                # record the new length
                # self.queuesize.Record( qlen, _time() )
                break
        else:
            if _debug: IOQueue._debug("    - not found")
600017
def remove(self, param):
        
        if self.has(param):
            del(self.raw_dict[param])
            self.manifest.remove_option(self.feature_name, param)
407057
def delete(id)
      unless Debugger.started? && Debugger.remove_breakpoint(id)
        raise ArgumentError, "No breakpoint ##{id}"
      end
      Pry.processor.debugging = false if to_a.empty?
    end
156849
public void removeParameter(ParamType type) {

        switch (type) {
            case language:
                m_localeSelection.reset();
                break;
            case text:
                m_searchInput.setFormValueAsString("");
                break;
            case expired:
                m_includeExpiredCheckBox.setChecked(false);
                break;
            case creation:
                m_dateCreatedStartDateBox.setValue(null, true);
                m_dateCreatedEndDateBox.setValue(null, true);
                break;
            case modification:
                m_dateModifiedStartDateBox.setValue(null, true);
                m_dateModifiedEndDateBox.setValue(null, true);
                break;
            case scope:
                m_scopeSelection.setFormValueAsString(m_defaultScope.name());
                break;
            default:
        }
    }
1008317
def remove(packagename, save, save_dev, save_test, filename):
    
    print(sh_pip.uninstall(packagename, "-y"))
    if not filename:
        filename = get_filename(save, save_dev, save_test)
    remove_requirements(packagename, filename)
1135624
protected String stripVersionFromName(String name, String version) {
        int versionBeginIndex = name.lastIndexOf("-" + version);
        if ( versionBeginIndex != -1) {
            return name.substring(0, versionBeginIndex) + name.substring(versionBeginIndex + version.length() + 1);
        } else {
            return name;
        }
    }
1035732
def get_debug_info():
        
        from . import __version__
        from .parser import SPEC_VERSION
        d = OrderedDict()
        d['Version'] = '%s' % __version__
        d['Spec version'] = SPEC_VERSION

        return d
588577
private void remove_poll_object(final DeviceProxy deviceProxy, final String objname,
            final String objtype) throws DevFailed {
        // Send command on administration device.
        if (deviceProxy.getAdm_dev() == null) {
            import_admin_device(deviceProxy, "remove_poll_object");
        }
        if (DeviceProxy.isCheck_idl() && deviceProxy.getAdm_dev().get_idl_version() < 2) {
            Except.throw_non_supported_exception("TangoApi_IDL_NOT_SUPPORTED",
                "Not supported by the IDL version used by device", deviceProxy
                    .getFull_class_name()
                    + ".remove_poll_object()");
        }

        final DeviceData argin = new DeviceData();
        final String[] params = new String[3];
        params[0] = deviceProxy.devname;
        params[1] = objtype;
        params[2] = objname.toLowerCase();
        argin.insert(params);
        deviceProxy.getAdm_dev().command_inout("RemObjPolling", argin);
    }
524626
def debug(version=False):
    """"""
    if version:
        print(__version__)
        return
    print(json.dumps(MANAGE_DICT, indent=2))
873900
def stop
      Debugger.stop if !@always_enabled && Debugger.started?
      if PryDebugger.current_remote_server   # Cleanup DRb remote if running
        PryDebugger.current_remote_server.teardown
      end
    end
368970
function debug(msg, error, extra) {
	if (!Manager.root.hasHandlers()) {
		basicConfig();
	}
	Manager.root.debug(msg, error, extra);
}
1076045
def _delete_version(self, symbol, version_num, do_cleanup=True):
        
        version = self._versions.find_one({'symbol': symbol, 'version': version_num})
        if not version:
            logger.error("Can't delete %s:%s as not found in DB" % (symbol, version_num))
            return
        # If the version is pointed to by a snapshot, then can't delete
        if version.get('parent', None):
            for parent in version['parent']:
                snap_name = self._snapshots.find_one({'_id': parent})
                if snap_name:
                    snap_name = snap_name['name']
                logger.error("Can't delete: %s:%s as pointed to by snapshot: %s" % (symbol, version['version'],
                                                                                    snap_name))
                return
        self._versions.delete_one({'_id': version['_id']})
        # TODO: for FW pointers, if the above statement fails, they we have no way to delete the orphaned segments.
        #       This would be possible only via FSCK, or by moving the above statement at the end of this method,
        #       but with the risk of failing to delelte the version catastrophically, and ending up with a corrupted v.
        if do_cleanup:
            cleanup(self._arctic_lib, symbol, [version['_id']], self._versions,
                    shas_to_delete=tuple(bson.binary.Binary(s) for s in version.get(FW_POINTERS_REFS_KEY, [])),
                    pointers_cfgs=(get_fwptr_config(version), ))
535664
def remove_on_change(pattern=".*")
      pattern = (pattern.kind_of?(Regexp) ? pattern.source : pattern.to_s)
      if @listeners.has_key?(pattern)
        listener, proc = @listeners.delete(pattern)
        Klass.remove_OnKeyChange_Handler(listener.get_pointer(0))
        sleep @handler_sleep
        true
      else
        nil
      end
    end
9842
@Override
    public void deconfigure() throws CoreException {
        if (DEBUG) {
            System.out.println("Removing findbugs from the project build spec.");
        }
        // de-register FindBugs builder
        removeFromBuildSpec(FindbugsPlugin.BUILDER_ID);
    }
1240914
def remove_breakpoint(self, event_type, bp=None, filter_func=None):
        

        if bp is None and filter_func is None:
            raise ValueError('remove_breakpoint(): You must specify either "bp" or "filter".')

        try:
            if bp is not None:
                self._breakpoints[event_type].remove(bp)
            else:
                self._breakpoints[event_type] = [ b for b in self._breakpoints[event_type] if not filter_func(b) ]
        except ValueError:
            # the breakpoint is not found
            l.error('remove_breakpoint(): Breakpoint %s (type %s) is not found.', bp, event_type)
867385
def yank_version(name, version, options = {})
      ensure_ready!(:authorization)
      url = "gems/#{escape(name)}/versions/#{escape(version)}"
      response = connection.delete(url, options)
      checked_response_body(response)
    end