def __init__(self, dock_tabbar, main):
     QObject.__init__(self)
     self.dock_tabbar = dock_tabbar
     self.main = main
     self.moving = False
     self.from_index = None
     self.to_index = None

    def __init__(self, parent, repo_files, prefix, root_prefix, pip_packages):
        QObject.__init__(self)
        self._parent = parent
        self._repo_files = repo_files
        self._prefix = prefix
        self._root_prefix = root_prefix
        self._pip_packages_names = {}

        for p in pip_packages:
            n, v, b = conda_api_q.CondaProcess.split_canonical_name(p)
            local = ''
            if '(' in n:
                name = n.split('-(')
                n = name[0]
                local = name[-1].replace(')', '')
            self._pip_packages_names[n] = {}
            self._pip_packages_names[n]['version'] = v
            self._pip_packages_names[n]['local'] = local
            self._pip_packages_names[n]['build'] = b

        self.packages_names = None
        self.row_data = None
        self.packages_versions = None
        self._packages = None

        # Define helper function locally
        self._get_package_metadata = parent.get_package_metadata

 def __init__(self, original_out):
     QObject.__init__(self)
     # If the file descriptor of the stream is < 0 then we are running in a no-external-console mode
     if not hasattr(original_out, 'fileno') or original_out.fileno() < 0:
         self._original_out = None
     else:
         self._original_out = original_out

 def disconnect(self):
     """
     Disconnect the tool from everything
     """
     QObject.disconnect(self)
     for cid in self._cids:
         self.canvas.mpl_disconnect(cid)
     self.fit_start_x.remove()
     self.fit_end_x.remove()

 def __init__(self, callee):
     QObject.__init__(self)
     self.moveToThread(qApp.thread())
     self.callee = callee
     # Help should then give the correct doc
     self.__call__.__func__.__doc__ = callee.__doc__
     self._args = None
     self._kwargs = None
     self._result = None
     self._exc_info = None

    def __init__(self, parent, startup, version="", releases=None):
        QObject.__init__(self)
        self._parent = parent
        self.error = None
        self.latest_release = None
        self.startup = startup
        self.releases = releases

        if not version:
            self.version = __version__
        else:
            self.version = version

    def __init__(self, parent, repo_files, env, prefix):
        QObject.__init__(self)
        self._parent = parent
        self._repo_files = repo_files
        self._env = env
        self._prefix = prefix

        self.packages_names = None
        self.row_data = None
        self.packages_versions = None

        # define helper function locally
        self._get_package_metadata = parent.get_package_metadata

 def __init__(self, callee):
     QObject.__init__(self)
     qapp = QApplication.instance()
     if qapp is not None:
         self.moveToThread(qapp.thread())
         self.qApp = qapp
     self.callee = callee
     # Help should then give the correct doc
     self.__call__.__func__.__doc__ = callee.__doc__
     self._args = None
     self._kwargs = None
     self._result = None
     self._exc_info = None

    def __init__(self, cacheSize=DEFAULT_CACHE_SIZE, userAgent='(PyQt) TileMap 1.0', parent=None):
        QObject.__init__(self, parent=parent)
        self._manager = None
        self._cache = None
        self._cacheSize = cacheSize

        try:
            # Convert user agent to bytes
            userAgent = userAgent.encode()
        except:
            # no encode method exists. This hsould be the Python 2 case
            pass

        self._userAgent = userAgent
        self._tileInDownload = dict()

    def __init__(self, parent):
        QObject.__init__(self, parent)
        self._parent = parent
        self._output = None
        self._partial = None
        self._stdout = None
        self._error = None
        self._parse = False
        self._function_called = ""
        self._name = None
        self._process = QProcess()
        self.set_root_prefix()

        # Signals
        self._process.finished.connect(self._call_conda_ready)
        self._process.readyReadStandardOutput.connect(self._call_conda_partial)

    def __init__(self, parent):
        QObject.__init__(self)
        self.main = parent

        self.clients = {}
        self.requests = {}
        self.register_queue = {}

        # Register languages to create clients for
        for language in self.get_languages():
            self.clients[language] = {
                'status': self.STOPPED,
                'config': self.get_language_config(language),
                'instance': None
            }
            self.register_queue[language] = []

    def __init__(self, widget, resultfilename=None):
        """
        Construct test runner.

        Parameters
        ----------
        widget : UnitTestWidget
            Unit test widget which constructs the test runner.
        resultfilename : str or None
            Name of file in which to store test results. If None, use default.
        """
        QObject.__init__(self, widget)
        self.process = None
        if resultfilename is None:
            self.resultfilename = os.path.join(tempfile.gettempdir(),
                                               'unittest.results')
        else:
            self.resultfilename = resultfilename

    def __init__(self, parent, server_args_fmt='',
                 server_settings={}, external_server=False,
                 folder=getcwd(), language='python',
                 plugin_configurations={}):
        QObject.__init__(self)
        # LSPMethodProviderMixIn.__init__(self)
        self.manager = parent
        self.zmq_in_socket = None
        self.zmq_out_socket = None
        self.zmq_in_port = None
        self.zmq_out_port = None
        self.transport_client = None
        self.language = language

        self.initialized = False
        self.ready_to_close = False
        self.request_seq = 1
        self.req_status = {}
        self.plugin_registry = {}
        self.watched_files = {}
        self.req_reply = {}

        self.transport_args = [sys.executable, '-u',
                               osp.join(LOCATION, 'transport', 'main.py')]
        self.external_server = external_server

        self.folder = folder
        self.plugin_configurations = plugin_configurations
        self.client_capabilites = CLIENT_CAPABILITES
        self.server_capabilites = SERVER_CAPABILITES
        self.context = zmq.Context()

        server_args = server_args_fmt % (server_settings)
        # transport_args = self.local_server_fmt % (server_settings)
        # if self.external_server:
        transport_args = self.external_server_fmt % (server_settings)

        self.server_args = [server_settings['cmd']]
        self.server_args += server_args.split(' ')
        self.transport_args += transport_args.split(' ')
        self.transport_args += ['--folder', folder]
        self.transport_args += ['--transport-debug', str(get_debug_level())]

    def __init__(self, parent, on_finished=None, on_partial=None):
        QObject.__init__(self, parent)
        self._parent = parent
        self.output = None
        self.partial = None
        self.stdout = None
        self.error = None
        self._parse = False
        self._function_called = ''
        self._name = None
        self._process = QProcess()
        self._on_finished = on_finished

        self._process.finished.connect(self._call_conda_ready)
        self._process.readyReadStandardOutput.connect(self._call_conda_partial)

        if on_finished is not None:
            self._process.finished.connect(on_finished)
        if on_partial is not None:
            self._process.readyReadStandardOutput.connect(on_partial)

        self.set_root_prefix()

 def __init__(self):
     QObject.__init__(self)
     self.dialogs = {}
     self.namespace = None

 def __init__(self, editor, lsp_manager):
     QObject.__init__(self)
     self.editor = editor
     self.lsp_manager = lsp_manager

 def __init__(self, parent, editor, lsp_manager):
     QObject.__init__(self, parent)
     self.editor = editor
     self.lsp_manager = lsp_manager
     self.editor.sig_perform_lsp_request.connect(self.perform_request)
     self.sig_initialize.connect(self.initialize_callback)

 def __init__(self, input_condition):
     QObject.__init__(self)
     self.input_data = None
     self.input_condition = input_condition

 def __init__(self):
     QObject.__init__(self)
     self.dialogs = {}

 def __init__(self, parent):
     QObject.__init__(self)
     self._parent = parent
     self.error = None
     self.latest_release = None