Пример #1
0
        def test_sip_api_already_set():
            """Raise ImportError if sip API v1 was already set"""

            __import__("PyQt4.QtCore")  # Bypass linter warning
            import sip
            sip.setapi("QString", 1)
            assert_raises(ImportError, __import__, "Qt")
Пример #2
0
def prepare_pyqt4():
    # For PySide compatibility, use the new-style string API that automatically
    # converts QStrings to Unicode Python strings. Also, automatically unpack
    # QVariants to their underlying objects.
    import sip
    sip.setapi('QString', 2)
    sip.setapi('QVariant', 2)
Пример #3
0
 def _setup_pyqt4_internal(api):
     global QtCore, QtGui, QtWidgets, \
         __version__, is_pyqt5, _getSaveFileName
     # List of incompatible APIs:
     # http://pyqt.sourceforge.net/Docs/PyQt4/incompatible_apis.html
     _sip_apis = ["QDate", "QDateTime", "QString", "QTextStream", "QTime",
                  "QUrl", "QVariant"]
     try:
         import sip
     except ImportError:
         pass
     else:
         for _sip_api in _sip_apis:
             try:
                 sip.setapi(_sip_api, api)
             except ValueError:
                 pass
     from PyQt4 import QtCore, QtGui
     __version__ = QtCore.PYQT_VERSION_STR
     # PyQt 4.6 introduced getSaveFileNameAndFilter:
     # https://riverbankcomputing.com/news/pyqt-46
     if __version__ < LooseVersion("4.6"):
         raise ImportError("PyQt<4.6 is not supported")
     QtCore.Signal = QtCore.pyqtSignal
     QtCore.Slot = QtCore.pyqtSlot
     QtCore.Property = QtCore.pyqtProperty
     _getSaveFileName = QtGui.QFileDialog.getSaveFileNameAndFilter
Пример #4
0
def importPyQt():
    try:
        import sip
        sip.setapi('QString', 2)
        sip.setapi('QVariant', 2)

        from PyQt4 import QtCore, QtGui, QtNetwork, QtWebKit, uic
        from PyQt4.QtCore import pyqtSignal as Signal, pyqtSlot as Slot, \
                pyqtProperty as Property
        QtUiTools = object()

        def loadUI(uiFilename, parent=None):
            newWidget = uic.loadUi(uiFilename)
            newWidget.setParent(parent)
            return newWidget

        logger.info("Successfully initialized PyQt4.")

        globals().update(
                QtCore=QtCore,
                QtGui=QtGui,
                QtNetwork=QtNetwork,
                QtWebKit=QtWebKit,
                QtUiTools=QtUiTools,
                Signal=Signal,
                Slot=Slot,
                Property=Property,
                loadUI=loadUI,
                binding="PyQt4",
                )

        return True

    except ImportError:
        return False
Пример #5
0
def import_pyqt4(version=2):
    """
    Import PyQt4

    Parameters
    ----------
    version : 1, 2, or None
      Which QString/QVariant API to use. Set to None to use the system
      default

    ImportErrors rasied within this function are non-recoverable
    """
    # The new-style string API (version=2) automatically
    # converts QStrings to Unicode Python strings. Also, automatically unpacks
    # QVariants to their underlying objects.
    import sip

    if version is not None:
        sip.setapi('QString', version)
        sip.setapi('QVariant', version)

    from PyQt4 import QtGui, QtCore, QtSvg

    if not check_version(QtCore.PYQT_VERSION_STR, '4.7'):
        raise ImportError("IPython requires PyQt4 >= 4.7, found %s" %
                          QtCore.PYQT_VERSION_STR)

    # Alias PyQt-specific functions for PySide compatibility.
    QtCore.Signal = QtCore.pyqtSignal
    QtCore.Slot = QtCore.pyqtSlot

    # query for the API version (in case version == None)
    version = sip.getapi('QString')
    api = QT_API_PYQTv1 if version == 1 else QT_API_PYQT
    return QtCore, QtGui, QtSvg, api
Пример #6
0
def setup_apiv2():
    """
    Setup apiv2 when using PyQt4 and Python2.
    """
    # setup PyQt api to version 2
    if sys.version_info[0] == 2:
        import sip
        if _api_version:
            default = _api_version
            apis = [
                ("QDate", default),
                ("QDateTime", default),
                ("QString", default),
                ("QTextStream", default),
                ("QTime", default),
                ("QUrl", default),
                ("QVariant", default),
                ("QFileDialog", default),
            ]
            for name, version in apis:
                try:
                    sip.setapi(name, version)
                except ValueError:
                    logging.getLogger(__name__).critical("failed to set up sip api to version 2 for PyQt4")
                    raise ImportError('PyQt4')
        from PyQt4.QtCore import PYQT_VERSION_STR as __version__
Пример #7
0
def set_sip_api():
    import sip
    api2_classes = [
            'QData', 'QDateTime', 'QString', 'QTextStream',
            'QTime', 'QUrl', 'QVariant',
            ]
    for cl in api2_classes:
        sip.setapi(cl, 2)
Пример #8
0
def setNewPyQtAPI():
    try:
        import sip
        # We now use the new PyQt API - IPython needs it
        sip.setapi('QString', 2)
        sip.setapi('QVariant', 2)
    except Exception:
        print "Could not set PyQt API, is PyQt4 installed?"
Пример #9
0
    def load_module(fullname):
        if fullname in _sys.modules:
            return _sys.modules[fullname]

        _, name = fullname.split('.')

        global qt

        if qt:
            # If a Qt implementation was already selected previously
            # and the selected module is the same as the one being imported,
            # then return it, otherwise False.
            if qt.__name__ == name:
                _sys.modules[fullname] = qt; return qt
            else:
                _sys.modules[fullname] = False; return False

        if name == 'PyQt4' and _sys.version_info[0] == 2:
            # Select API version 2, this is needed only for PyQt4 on Python 2.x
            try:
                import sip
                for api in ['QDate', 'QDateTime', 'QString', 'QTextStream',
                            'QTime', 'QUrl', 'QVariant']:
                    try:
                        sip.setapi(api, 2)
                    except Exception:
                        pass
            except Exception:
                pass

        # The selection of Qt implementation is successful only if its QtCore
        # module can be imported.
        try:
            qt = __import__(name + '.QtCore')
        except ImportError:
            _sys.modules[fullname] = False; return False

        core = qt.QtCore

        # Turn `QtCore.Qt` object into a package,
        # because `import qt` will actually give this object.
        core.Qt.__path__ = []
        core.Qt.__package__ = 'qt'

        # Put some additional attributes into `qt`.
        core.Qt.module = name
        core.Qt.version_str = core.qVersion()
        core.Qt.major = int(core.Qt.version_str.split('.', 1)[0])
        if name.startswith('PyQt'):
            core.Qt.module_version_str = core.PYQT_VERSION_STR
            core.Signal = core.pyqtSignal
            core.Slot = core.pyqtSlot
        else:
            core.Qt.module_version_str = qt.__version__
        core.Qt.Signal = core.Signal
        core.Qt.Slot = core.Slot

        _sys.modules[fullname] = qt; return qt
Пример #10
0
 def update_apis(apis='QDate QDateTime QString QTextStream QTime QUrl QVariant'.split()):
     import sys
     if sys.version_info.major==2:
         import sip
         for api in apis:
             try:
                 sip.setapi(api, 2)
             except:
                 pass
Пример #11
0
 def _initPyQt4():
     """initialize PyQt4 to be compatible with PySide"""
     if 'PyQt4.QtCore' in sys.modules:
         # too late to configure API
         pass
     else:
         import sip
         sip.setapi("QString", 2)
         sip.setapi("QVariant", 2)
Пример #12
0
Файл: main.py Проект: gpa14/enki
def _checkDependencies(profiler):
    """Check if 3rdparty software is installed in the system.
    Notify user, how to install it
    """
    _SEE_SITE_PLAIN = 'See http://enki-editor.org/install-sources.html'
    _SEE_SITE_HTML = \
        'See <a href="http://enki-editor.org/install-sources.html">' \
        'installation instructions</a>'

    try:
        import PyQt5
    except ImportError as ex:
        plain = 'Failed to import Qt4 python bindings:\n{}\n{}'.format(str(ex), _SEE_SITE_PLAIN)

        _showErrorMessage(False, 'PyQt5 not found', plain, plain)
        raise ex

    import sip
    sip.setapi('QString', 2)
    sip.setapi('QVariant', 2)

    profiler.stepDone('Import PyQt5')

    try:
        import qutepart
    except ImportError as ex:
        html = "<html>" + \
            "Failed to import qutepart.<br/>" \
            "See <a href=\"https://github.com/hlamer/qutepart\">qutepart site</a><br/>" \
            "Exception:<br/>" + \
            str(ex) + '<br/>' + \
            _SEE_SITE_HTML + \
            "</html>"
        plain = "Failed to import qutepart.\n" \
                "See https://github.com/hlamer/qutepart\n" + \
            str(ex) + '\n' + \
            _SEE_SITE_PLAIN
        _showErrorMessage(True, "Qutepart not found", html, plain)
        raise ex

    profiler.stepDone('Import Qutepart')

    if qutepart.VERSION[0] != enki.core.defines.QUTEPART_SUPPORTED_MAJOR or \
       qutepart.VERSION[1] < enki.core.defines.QUTEPART_SUPPORTED_MINOR:
        text = "Qutepart version not supported\n" + \
               "This Enki version requires Qutepart {}.>={}.*\n". \
            format(enki.core.defines.QUTEPART_SUPPORTED_MAJOR,
                   enki.core.defines.QUTEPART_SUPPORTED_MINOR) + \
               "But {}.{}.{} is detected\n\n".format(*qutepart.VERSION)

        html = "<html>" + text.replace('\n', '<br/>') + \
            _SEE_SITE_HTML + \
            "</html>"
        plain = text + _SEE_SITE_PLAIN

        _showErrorMessage(True, "Not supported Qutepart version", html, plain)
        raise ImportError('Not supported Qutepart')
Пример #13
0
        def test_sip_api_1_2():
            """sip=1, hint=2 == WARNING"""
            import sip
            sip.setapi("QString", 1)
            os.environ["QT_SIP_API_HINT"] = "2"

            with captured_output() as out:
                __import__("Qt")  # Bypass linter warning
                stdout, stderr = out
                assert stderr.getvalue().startswith("Warning:")
Пример #14
0
	def _initPyQt4():
		"""initialize PyQt4 to be compatible with PySide"""
		import sip
		if 'PyQt4.QtCore' in sys.modules:
			# too late to configure API, let's check that it was properly parameterized...
			for api in ('QVariant', 'QString'):
				if sip.getapi(api) != 2:
					raise RuntimeError('%s API already set to V%d, but should be 2' % (api, sip.getapi(api)))
		else:
			sip.setapi("QString", 2)
			sip.setapi("QVariant", 2)
Пример #15
0
def setup_apiv2():
    """
    Setup apiv2 when using PyQt4 and Python2.
    """
    # setup PyQt api to version 2
    if sys.version_info[0] == 2:
        logging.getLogger(__name__).debug('setting up SIP API to version 2')
        import sip
        try:
            sip.setapi("QString", 2)
            sip.setapi("QVariant", 2)
        except ValueError:
            logging.getLogger(__name__).critical(
                "failed to set up sip api to version 2 for PyQt4")
            raise ImportError('PyQt4')
def load_pyqt4():
    """Sets up PyQt4 nicely to be PySide-compatible as much as possible."""
    # Kill off QString and QVariant to make it act properly like PySide
    import sip
    sip.setapi('QString', 2)
    sip.setapi('QVariant', 2)

    from PyQt4 import QtCore
    QtCore._QT_ENGINE = 'PyQt4'

    # Also rename the pyqt things for compatibility.
    QtCore.Signal = QtCore.pyqtSignal
    QtCore.Slot = QtCore.pyqtSlot
    QtCore.Property = QtCore.pyqtProperty

    global IS_PYQT4
    IS_PYQT4 = True
Пример #17
0
def get_qt():
    qtapi = os.environ.get('QT_API', 'pyqt')

    # Try PyQt4
    if qtapi == 'pyqt' or qtapi == 'pyqt4':
        try:
            PyQt4 = __import__('PyQt4')
            imp.find_module('QtCore', PyQt4.__path__)
            imp.find_module('QtGui', PyQt4.__path__)
            import sip
        except ImportError:
            pass
        else:
            api2_classes = [
                'QData', 'QDateTime', 'QString', 'QTextStream',
                'QTime', 'QUrl', 'QVariant'
            ]
            for cl in api2_classes:
                try:
                    sip.setapi(cl, 2)
                except ValueError:
                    pass
            import PyQt4.QtCore
            import PyQt4.QtGui
            os.environ['QT_API'] = 'pyqt'
            return PyQt4, qtapi
    # Try PyQt5
    if qtapi == 'pyqt5':
        try:
            PyQt5 = __import__('PyQt5')
            imp.find_module('QtCore', PyQt5.__path__)
            imp.find_module('QtGui', PyQt5.__path__)
        except ImportError:
            pass
        else:
            import PyQt5.QtCore
            import PyQt5.QtGui
            import PyQt5.QtWidgets
            os.environ['QT_API'] = 'pyqt5'
            return PyQt5, qtapi
    # Oh no
    sys.stderr.write("'file_archive view' requires either PyQt4 or PyQt5\n")
    if 'QT_API' in os.environ:
        sys.stderr.write("QT_API is currently set to '%s', which is not "
                         "supported\n" % qtapi)
    sys.exit(3)
Пример #18
0
        def ets(self, parameter_s=''):
            """Choose backend for ETS GUI

            %ets wx|qt
            """
            opts, arg = self.parse_options(parameter_s, '')
            if arg == "qt":
                import sip, os
                sip.setapi('QString', 2)
                sip.setapi('QVariant', 2)
                os.environ['ETS_TOOLKIT'] = 'qt4'
            elif arg == "wx":
                import os
                os.environ['ETS_TOOLKIT'] = 'wx'
            else:
                from IPython.utils.warn import error
                error("argument of ets must be wx or qt")
            self.shell.enable_gui(arg)
Пример #19
0
    def run(self):
        import unittest
        import sip

        sip.setapi("QString", 2)
        sip.setapi("QVariant", 2)

        names = []
        for filename in glob.glob("test/test_*.py"):
            name = os.path.splitext(os.path.basename(filename))[0]
            if not self.tests or name in self.tests:
                names.append("test." + name)

        tests = unittest.defaultTestLoader.loadTestsFromNames(names)
        t = unittest.TextTestRunner(verbosity=self.verbosity)
        testresult = t.run(tests)
        if not testresult.wasSuccessful():
            sys.exit("At least one test failed.")
Пример #20
0
def __setPyQt4API(element, api_version=2):
    try:
        ver = sip.getapi(element)
    except ValueError:
        ver = -1

    if ver < 0:
        try:
            sip.setapi(element, api_version)
            log.debug("%s API set to version %d",
                      element, sip.getapi("QString"))
        except ValueError:
            log.warning("Error setting %s API to version %s", element,
                        api_version, exc_info=1)
            return False
    elif ver < api_version:
        log.info("%s API set to version %s (advised: version >= %s)",
                 element, ver, api_version)
    return True
Пример #21
0
def importPyQt():
    try:
        if "PyQt4" in sys.modules:
            return True

        import sip
        sip.setapi('QString', 2)
        sip.setapi('QVariant', 2)

        required_modules = ["QtCore", "QtGui", "QtNetwork", "QtWebKit", "uic"]

        for module_name in required_modules:
            _named_import('PyQt4.%s' % module_name)

        from PyQt4.QtCore import pyqtSignal as Signal
        from PyQt4.QtCore import pyqtSlot as Slot
        from PyQt4.QtCore import pyqtProperty as Property
        QtUiTools = object()

        def loadUi(uifile, parent=None):
            newWidget = uic.loadUi(uifile, parent)
            return newWidget

        si.LogMessage("[PyQtForSoftimage] Successfully initialized PyQt4.", C.siInfo)

        globals().update(
                QtCore=QtCore,
                QtGui=QtGui,
                QtNetwork=QtNetwork,
                QtWebKit=QtWebKit,
                QtUiTools=QtUiTools,
                Signal=Signal,
                Slot=Slot,
                Property=Property,
                loadUi=loadUi,
                binding="PyQt4",
                )

        return True

    except ImportError:
        return False
Пример #22
0
def getPyQt4Context( ):
    "Get a Qt context for using PyQt4 inside of python."
    import sip  as sipModule
    import PyQt4 as PyQt4Module
    try:
        sipModule.setapi('QString', 2)
        sipModule.setapi('QVariant', 2)
    except:
        print( "qt : Cannot force PyQt4 to APIv2 mode, potential data conversion problems with QString and QVariant classes." )
    
    import_module = lambda moduleName : getattr( __import__(PyQt4Module.__name__, globals(), locals(), [moduleName], -1), moduleName)

    import_module("QtCore")
    import_module("QtGui")
    
    Signal = PyQt4Module.QtCore.pyqtSignal
    Slot = PyQt4Module.QtCore.pyqtSlot
    Property = PyQt4Module.QtCore.pyqtProperty

    return QtContext( PyQt4Module, PyQt4Module.QtCore, PyQt4Module.QtGui, Signal, Slot, Property, import_module, "PyQt4" )
Пример #23
0
def get_pronunciation(text):
    """
    A set of hacks that are pulled togeher to run awesometts and produce
    pronunciation for a word.
    """

    import sip
    sip.setapi('QString', 2)
    sip.setapi('QVariant', 2)
    sip.setapi('QUrl', 2)

    from PyQt4.QtGui import QApplication
    from PyQt4.QtCore import QTimer
    sound_path = [None]
    app = QApplication([])

    def fake_awesometts():
        class FakeAddons(object):
            def GetAddons(self):
                return []
            GetAddons.__bases__ = [object]

        import aqt
        aqt.addons = FakeAddons()

        sys.path.insert(0, expanduser('~/Documents/Anki/addons'))
        import awesometts

        #text = 'furfurfur'
        # text = 'smear'
        group = {u'presets': [u'Howjsay (en)', u'Oxford Dictionary (en-US)', u'Collins (en)', u'Google Translate (en-US)', u'Baidu Translate (en)', u'ImTranslator (VW Paul)'], u'mode': u'ordered'}
        presets = {u'ImTranslator (VW Paul)': {u'voice': u'VW Paul', u'speed': 0, u'service': u'imtranslator'}, u'Linguatec (ko, Sora)': {u'voice': u'Sora', u'service': u'linguatec'}, u'Collins (en)': {u'voice': u'en', u'service': u'collins'}, u'NeoSpeech (ko, Jihun)': {u'voice': u'Jihun', u'service': u'neospeech'}, u'Baidu Translate (en)': {u'voice': u'en', u'service': u'baidu'}, u'Google Translate (en-US)': {u'voice': u'en-US', u'service': u'google'}, u'Acapela Group (ko, Minji)': {u'voice': u'Minji', u'service': u'acapela'}, u'ImTranslator (ko, VW Yumi)': {u'voice': u'VW Yumi', u'speed': 0, u'service': u'imtranslator'}, u'Howjsay (en)': {u'voice': u'en', u'service': u'howjsay'}, u'Oxford Dictionary (en-US)': {u'voice': u'en-US', u'service': u'oxford'}, u'NAVER Translate (ko)': {u'voice': u'ko', u'service': u'naver'}}
        def on_okay(path):
            sound_path[0] = path
            app.quit()
        def on_fail(path):
            app.quit()
        callbacks = {
            'okay': on_okay,
            'fail': on_fail,
        } #{'fail': <function fail at 0x7fe53b8aa668>, 'then': <function <lambda> at 0x7fe53b8aa758>, 'done': <function done at 0x7fe55084fed8>, 'okay': <function okay at 0x7fe550afa758>, 'miss': <function miss at 0x7fe53b8aa6e0>}
        want_human = False
        note = None # <anki.notes.Note object at 0x7fe550871990>

        awesometts.router._logger = _logger
        awesometts.router.group(text, group, presets, callbacks, want_human, note)

    # fake_awesometts()
    QTimer.singleShot(1, fake_awesometts)
    app.exec_()
    return sound_path[0]
Пример #24
0
elif 'PyQt5.QtCore' in sys.modules:
    BINDING = 'PyQt5'

elif 'PyQt4.QtCore' in sys.modules:
    BINDING = 'PyQt4'

else:  # Then try Qt bindings
    try:
        import PyQt5.QtCore  # noqa
    except ImportError:
        if 'PyQt5' in sys.modules:
            del sys.modules["PyQt5"]
        try:
            import sip
            sip.setapi("QString", 2)
            sip.setapi("QVariant", 2)
            sip.setapi('QDate', 2)
            sip.setapi('QDateTime', 2)
            sip.setapi('QTextStream', 2)
            sip.setapi('QTime', 2)
            sip.setapi('QUrl', 2)
            import PyQt4.QtCore  # noqa
        except ImportError:
            if 'PyQt4' in sys.modules:
                del sys.modules["sip"]
                del sys.modules["PyQt4"]
            try:
                import PySide2.QtCore  # noqa
            except ImportError:
                if 'PySide2' in sys.modules:
Пример #25
0
# Copyright (c) 2016 Detlev Offenbach <*****@*****.**>
#
# This is the install script for the eric6 debug client. It may be used
# to just install the debug clients for remote debugging.
#

"""
Installation script for the eric6 debug clients.
"""

from __future__ import unicode_literals, print_function
try:
    import cStringIO as io
    import sip
    sip.setapi('QString', 2)
    sip.setapi('QVariant', 2)
    sip.setapi('QTextStream', 2)
except (ImportError):
    import io    # __IGNORE_WARNING__

import sys
import os
import re
import compileall
import shutil
import fnmatch
import distutils.sysconfig

# Define the globals.
progName = None
Пример #26
0
import os
import sys

try:
    from PySide2 import QtCore, QtGui, QtWidgets
    from PySide2.QtCore import Qt
except ImportError:
    try:
        from PySide import QtCore, QtGui, QtGui as QtWidgets
        from PySide.QtCore import Qt
    except ImportError:
        import sip
        for mod in ("QDate", "QDateTime", "QString", "QTextStream", "QTime",
                    "QUrl", "QVariant"):
            sip.setapi(mod, 2)

        from PyQt4 import QtCore, QtGui
        from PyQt4.QtCore import Qt
        QtCore.Signal = QtCore.pyqtSignal


def find_menu_items(menu, _path=None):
    """Extracts items from a given Nuke menu

    Returns a list of strings, with the path to each item

    Ignores divider lines and hidden items (ones like "@;&CopyBranch" for shift+k)

    >>> found = find_menu_items(nuke.menu("Nodes"))
    >>> found.sort()
Пример #27
0
def _pyqt4():
    """Initialise PyQt4"""

    import sip

    # Validation of envivornment variable. Prevents an error if
    # the variable is invalid since it's just a hint.
    try:
        hint = int(QT_SIP_API_HINT)
    except TypeError:
        hint = None  # Variable was None, i.e. not set.
    except ValueError:
        raise ImportError("QT_SIP_API_HINT=%s must be a 1 or 2")

    for api in ("QString", "QVariant", "QDate", "QDateTime", "QTextStream",
                "QTime", "QUrl"):
        try:
            sip.setapi(api, hint or 2)
        except AttributeError:
            raise ImportError("PyQt4 < 4.6 isn't supported by Qt.py")
        except ValueError:
            actual = sip.getapi(api)
            if not hint:
                raise ImportError("API version already set to %d" % actual)
            else:
                # Having provided a hint indicates a soft constraint, one
                # that doesn't throw an exception.
                sys.stderr.write(
                    "Warning: API '%s' has already been set to %d.\n" %
                    (api, actual))

    import PyQt4 as module
    _setup(module, ["uic"])

    if hasattr(Qt, "_uic"):
        Qt.QtCompat.loadUi = _loadUi

    if hasattr(Qt, "_QtGui"):
        setattr(Qt, "QtWidgets", _new_module("QtWidgets"))
        setattr(Qt, "_QtWidgets", Qt._QtGui)

        Qt.QtCompat.setSectionResizeMode = \
            Qt._QtGui.QHeaderView.setResizeMode

        if hasattr(Qt, "_QtCore"):
            Qt.QtCore.QAbstractProxyModel = Qt._QtGui.QAbstractProxyModel
            Qt.QtCore.QSortFilterProxyModel = Qt._QtGui.QSortFilterProxyModel
            Qt.QtCore.QItemSelection = Qt._QtGui.QItemSelection
            Qt.QtCore.QStringListModel = Qt._QtGui.QStringListModel
            Qt.QtCore.QItemSelectionModel = Qt._QtGui.QItemSelectionModel
            Qt.QtCore.QItemSelectionRange = Qt._QtGui.QItemSelectionRange

    if hasattr(Qt, "_QtCore"):
        Qt.__qt_version__ = Qt._QtCore.QT_VERSION_STR
        Qt.__binding_version__ = Qt._QtCore.PYQT_VERSION_STR

        Qt.QtCore.Property = Qt._QtCore.pyqtProperty
        Qt.QtCore.Signal = Qt._QtCore.pyqtSignal
        Qt.QtCore.Slot = Qt._QtCore.pyqtSlot

        QCoreApplication = Qt._QtCore.QCoreApplication
        Qt.QtCompat.translate = (
            lambda context, sourceText, disambiguation, n: QCoreApplication.
            translate(context, sourceText, disambiguation, QCoreApplication.
                      CodecForTr, n))
Пример #28
0
# (at your option) any later version.
#
# This program is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
# GNU General Public License for more details.
#-------------------------------------------------------------------------------
'''
Created on Dec 1, 2011

@author: thygrrr
'''

# CRUCIAL: This must remain on top.
import sip
sip.setapi('QString', 2)
sip.setapi('QVariant', 2)
sip.setapi('QStringList', 2)
sip.setapi('QList', 2)
sip.setapi('QProcess', 2)

import sys
from PyQt4 import QtGui

#Set up a robust logging system

import util

util.startLogging()

excepthook_original = sys.excepthook
Пример #29
0
def prepare_pyqt4():
    # Set PySide compatible APIs.
    import sip
    sip.setapi('QString', 2)
    sip.setapi('QVariant', 2)
Пример #30
0
 def test_sip_api_1_1():
     """sip=1, hint=1 == OK"""
     import sip
     sip.setapi("QString", 1)
     os.environ["QT_SIP_API_HINT"] = "1"
     __import__("Qt")  # Bypass linter warning
Пример #31
0
    def set_qt_api(self, api):
        self.pytest_qt_api = self._get_qt_api_from_env(
        ) or api or self._guess_qt_api()
        if not self.pytest_qt_api:  # pragma: no cover
            msg = 'pytest-qt requires either PySide, PySide2, PyQt4 or PyQt5 to be installed'
            raise RuntimeError(msg)

        _root_modules = {
            'pyside': 'PySide',
            'pyside2': 'PySide2',
            'pyqt4': 'PyQt4',
            'pyqt4v2': 'PyQt4',
            'pyqt5': 'PyQt5',
        }
        _root_module = _root_modules[self.pytest_qt_api]

        def _import_module(module_name):
            m = __import__(_root_module, globals(), locals(), [module_name], 0)
            return getattr(m, module_name)

        if self.pytest_qt_api == 'pyqt4v2':  # pragma: no cover
            # the v2 api in PyQt4
            # http://pyqt.sourceforge.net/Docs/PyQt4/incompatible_apis.html
            import sip
            sip.setapi("QDate", 2)
            sip.setapi("QDateTime", 2)
            sip.setapi("QString", 2)
            sip.setapi("QTextStream", 2)
            sip.setapi("QTime", 2)
            sip.setapi("QUrl", 2)
            sip.setapi("QVariant", 2)

        self.QtCore = QtCore = _import_module('QtCore')
        self.QtGui = QtGui = _import_module('QtGui')
        self.QtTest = _import_module('QtTest')
        self.Qt = QtCore.Qt
        self.QEvent = QtCore.QEvent

        self.qDebug = QtCore.qDebug
        self.qWarning = QtCore.qWarning
        self.qCritical = QtCore.qCritical
        self.qFatal = QtCore.qFatal
        self.QtDebugMsg = QtCore.QtDebugMsg
        self.QtWarningMsg = QtCore.QtWarningMsg
        self.QtCriticalMsg = QtCore.QtCriticalMsg
        self.QtFatalMsg = QtCore.QtFatalMsg

        # Qt4 and Qt5 have different functions to install a message handler;
        # the plugin will try to use the one that is not None
        self.qInstallMsgHandler = None
        self.qInstallMessageHandler = None

        if self.pytest_qt_api.startswith('pyside'):
            self.Signal = QtCore.Signal
            self.Slot = QtCore.Slot
            self.Property = QtCore.Property
            self.QStringListModel = QtGui.QStringListModel

            self.QStandardItem = QtGui.QStandardItem
            self.QStandardItemModel = QtGui.QStandardItemModel
            self.QAbstractListModel = QtCore.QAbstractListModel
            self.QAbstractTableModel = QtCore.QAbstractTableModel
            self.QStringListModel = QtGui.QStringListModel

            if self.pytest_qt_api == 'pyside2':
                _QtWidgets = _import_module('QtWidgets')
                self.QApplication = _QtWidgets.QApplication
                self.QWidget = _QtWidgets.QWidget
                self.QLineEdit = _QtWidgets.QLineEdit
                self.qInstallMessageHandler = QtCore.qInstallMessageHandler

                self.QSortFilterProxyModel = QtCore.QSortFilterProxyModel
            else:
                self.QApplication = QtGui.QApplication
                self.QWidget = QtGui.QWidget
                self.QLineEdit = QtGui.QLineEdit
                self.qInstallMsgHandler = QtCore.qInstallMsgHandler

                self.QSortFilterProxyModel = QtGui.QSortFilterProxyModel

            def extract_from_variant(variant):
                """PySide does not expose QVariant API"""
                return variant

            def make_variant(value=None):
                """PySide does not expose QVariant API"""
                return value

            self.extract_from_variant = extract_from_variant
            self.make_variant = make_variant

        elif self.pytest_qt_api in ('pyqt4', 'pyqt4v2', 'pyqt5'):
            self.Signal = QtCore.pyqtSignal
            self.Slot = QtCore.pyqtSlot
            self.Property = QtCore.pyqtProperty

            if self.pytest_qt_api == 'pyqt5':
                _QtWidgets = _import_module('QtWidgets')
                self.QApplication = _QtWidgets.QApplication
                self.QWidget = _QtWidgets.QWidget
                self.qInstallMessageHandler = QtCore.qInstallMessageHandler

                self.QStringListModel = QtCore.QStringListModel
                self.QSortFilterProxyModel = QtCore.QSortFilterProxyModel

                def extract_from_variant(variant):
                    """not needed in PyQt5: Qt API always returns pure python objects"""
                    return variant

                def make_variant(value=None):
                    """Return a QVariant object from the given Python builtin"""
                    # PyQt4 doesn't allow one to instantiate any QVariant at all:
                    # QVariant represents a mapped type and cannot be instantiated
                    return QtCore.QVariant(value)

            else:
                self.QApplication = QtGui.QApplication
                self.QWidget = QtGui.QWidget
                self.qInstallMsgHandler = QtCore.qInstallMsgHandler

                self.QStringListModel = QtGui.QStringListModel
                self.QSortFilterProxyModel = QtGui.QSortFilterProxyModel

                def extract_from_variant(variant):
                    """returns python object from the given QVariant"""
                    if isinstance(variant, QtCore.QVariant):
                        return variant.toPyObject()
                    return variant

                def make_variant(value=None):
                    """Return a QVariant object from the given Python builtin"""
                    # PyQt4 doesn't allow one to instantiate any QVariant at all:
                    # QVariant represents a mapped type and cannot be instantiated
                    return value

            self.QStandardItem = QtGui.QStandardItem
            self.QStandardItemModel = QtGui.QStandardItemModel
            self.QAbstractListModel = QtCore.QAbstractListModel
            self.QAbstractTableModel = QtCore.QAbstractTableModel

            self.extract_from_variant = extract_from_variant
            self.make_variant = make_variant
Пример #32
0
import sys, os

os.environ['PYTHONIOENCODING'] = 'utf-8'
srcPath = os.path.abspath(os.path.join("source"))
sys.path.append(srcPath)
sys.path.append(".")

import sip
sip.setapi("QString", 2)
sip.setapi("QVariant", 2)

from domanager import app
app.start()
Пример #33
0
#  General Public Licensing requirements will be met:
#  http://www.trolltech.com/products/qt/opensource.html
#
#  If you are unsure which license is appropriate for your use, please
#  review the following information:
#  http://www.trolltech.com/products/qt/licensing.html or contact the
#  sales department at [email protected].
#
#  This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE
#  WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.
#
############################################################################

# This is only needed for Python v2 but is harmless for Python v3.
import sip
sip.setapi('QString', 2)

from PyQt4 import QtCore, QtGui

# import dockwidgets_rc


class MainWindow(QtGui.QMainWindow):
    def __init__(self):
        super(MainWindow, self).__init__()

        self.textEdit = QtGui.QTextEdit()
        self.setCentralWidget(self.textEdit)

        self.createActions()
        self.createMenus()
Пример #34
0
from ninja_ide.core import plugin


# constants
HELPMSG = '''<h3>Ninja Best Practice Checker</h3><i>Go beyond PEP-8!</i><br><br>
''' + ''.join((__doc__, ', v', __version__, __license__, 'by', __author__))
FILE, CLASS, FUNCTION, LINENR, LEVEL = 0, 1, 2, 3, 4
MAXVAL = {'maxAttributesPerClass': 20, 'maxFunctionsPerClass': 20,
    'maxFunctionsPerFile': 20, 'maxClassesPerFile': 5,
    'maxParametersPerFunction': 5, 'maxLinesPerFunction': 100,
    'maxControlStatementsPerFunction': 20, 'maxLinesPerFile': 999,
    'maxIndentationLevel': 5, 'maxTabs': 5}


# API 2
(setapi(a, 2) for a in ("QDate", "QDateTime", "QString", "QTime", "QUrl",
                        "QTextStream", "QVariant"))


###############################################################################


class Main(plugin.Plugin):
    ' main class for plugin '
    def initialize(self, *args, **kwargs):
        ' class init '
        super(Main, self).initialize(*args, **kwargs)
        self.group0 = QGroupBox()
        self.group0.setTitle(' Options ')
        self.group0.setCheckable(True)
        self.group0.toggled.connect(lambda: self.group0.hide())
Пример #35
0
NUM_VERSION = (2, 6, 0, "dev")

import sip
import os
import sys

curpath = os.path.dirname(__file__)
sys.path.append(curpath)

try:
    types = ["QDate", "QDateTime", "QString", "QTextStream", "QTime", "QUrl", "QVariant"]
    for qtype in types:
        sip.setapi(qtype, 2)
except ValueError:
    # API has already been set so we can't set it again.
    pass


def get_git_changeset():
    """Returns the SHA of the current HEAD
    """
    import os
    import subprocess

    full_path = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))
    sha = subprocess.check_output(['git', 'rev-parse', '--short','HEAD'], cwd=full_path)
    return sha.split('\n')[0]


def part_string(part, i):
    """Convert a version number part into a string for concatentation.
Пример #36
0
   and other provisions required by the GPL or the LGPL. If you do not delete
   the provisions above, a recipient may use your version of this file under
   the terms of any one of the MPL, the GPL or the LGPL.
 
  "2019"
 '''
from __future__ import unicode_literals, print_function
#Ensure we use pyqt api 2 and consistency across python 2 and 3
import sip

API_NAMES = [
    "QDate", "QDateTime", "QString", "QTextStream", "QTime", "QUrl", "QVariant"
]
API_VERSION = 2
for name in API_NAMES:
    sip.setapi(name, API_VERSION)
from opencmiss.zinc.context import Context
from opencmiss.zinc.element import Element, Elementbasis
from opencmiss.zinc.node import Node

#If the mesh is a triangular mesh that face constants are not supported
faceValues = False
cubicHermite = False


class ClothingMeshModel(object):
    '''
    Converts obj file based on manuel bastoni to opencmiss zinc
    In order to get the part a face belong to export the mesh from blender in obj format
    In Export select
        polygroups
Пример #37
0
# Set up configuration variables

__all__ = ['custom_viewer', 'qglue', 'test']

import os

try:
    from sip import setapi
except ImportError:
    pass
else:
    setapi('QString', 2)
    setapi('QVariant', 2)

import sys
from ._mpl_backend import MatplotlibBackendSetter
sys.meta_path.append(MatplotlibBackendSetter())

import logging
from logging import NullHandler

logging.getLogger('glue').addHandler(NullHandler())


def custom_viewer(name, **kwargs):
    """
    Create a custom interactive data viewer.

    To use this, first create a new variable by calling custom_viewer.
    Then, register one or more viewer functions using decorators.
Пример #38
0
def _pyqt4():
    """Initialise PyQt4"""

    import sip
    try:
        sip.setapi("QString", 2)
        sip.setapi("QVariant", 2)
        sip.setapi("QDate", 2)
        sip.setapi("QDateTime", 2)
        sip.setapi("QTextStream", 2)
        sip.setapi("QTime", 2)
        sip.setapi("QUrl", 2)
    except AttributeError as e:
        raise ImportError(str(e))
        # PyQt4 < v4.6
    except ValueError as e:
        # API version already set to v1
        raise ImportError(str(e))

    import PyQt4 as module
    _setup(module, ["uic"])

    if hasattr(Qt, "_uic"):
        Qt.QtCompat.loadUi = lambda fname: Qt._uic.loadUi(fname)

    if hasattr(Qt, "_QtGui"):
        setattr(Qt, "QtWidgets", _new_module("QtWidgets"))
        setattr(Qt, "_QtWidgets", Qt._QtGui)

        Qt.QtCompat.setSectionResizeMode = \
            Qt._QtGui.QHeaderView.setResizeMode

        if hasattr(Qt, "_QtCore"):
            Qt.QtCore.QAbstractProxyModel = Qt._QtGui.QAbstractProxyModel
            Qt.QtCore.QSortFilterProxyModel = Qt._QtGui.QSortFilterProxyModel
            Qt.QtCore.QItemSelection = Qt._QtGui.QItemSelection
            Qt.QtCore.QStringListModel = Qt._QtGui.QStringListModel
            Qt.QtCore.QItemSelectionModel = Qt._QtGui.QItemSelectionModel

    if hasattr(Qt, "_QtCore"):
        Qt.__qt_version__ = Qt._QtCore.QT_VERSION_STR
        Qt.__binding_version__ = Qt._QtCore.PYQT_VERSION_STR

        Qt.QtCore.Property = Qt._QtCore.pyqtProperty
        Qt.QtCore.Signal = Qt._QtCore.pyqtSignal
        Qt.QtCore.Slot = Qt._QtCore.pyqtSlot

        QCoreApplication = Qt._QtCore.QCoreApplication
        Qt.QtCompat.translate = (
            lambda context, sourceText, disambiguation, n: QCoreApplication.
            translate(context, sourceText, disambiguation, QCoreApplication.
                      CodecForTr, n))
Пример #39
0
 def test_sip_api_2_2():
     """sip=2, hint=2 == OK"""
     import sip
     sip.setapi("QString", 2)
     os.environ["QT_SIP_API_HINT"] = "2"
     __import__("Qt")  # Bypass linter warning
Пример #40
0
import os
import sys
if "PySide" in sys.modules:
    PYSIDE = True
else:
    PYSIDE = False
if PYSIDE:
    os.environ['QT_API'] = 'pyside'
    from PySide.QtGui import *
else:
    os.environ['QT_API'] = 'pyqt'
    if 1:
        #is this really needed?
        #If I get rid of it IPython complains
        import sip
        sip.setapi("QString", 2)
        sip.setapi("QVariant", 2)
    from PyQt4.QtGui import *
# Import the console machinery from ipython
from IPython.qt.console.rich_ipython_widget import RichIPythonWidget
from IPython.qt.inprocess import QtInProcessKernelManager
from IPython.lib import guisupport


class QIPythonWidget(RichIPythonWidget):
    """ Convenience class for a live IPython console widget. We can replace the standard banner using the customBanner argument"""
    def __init__(self, customBanner=None, *args, **kwargs):
        if customBanner != None: self.banner = customBanner
        super(QIPythonWidget, self).__init__(*args, **kwargs)
        self.kernel_manager = kernel_manager = QtInProcessKernelManager()
        kernel_manager.start_kernel()
Пример #41
0
 def test_sip_api_already_set():
     """Raise ImportError with sip was set to 1 with no hint, default"""
     __import__("PyQt4.QtCore")  # Bypass linter warning
     import sip
     sip.setapi("QString", 1)
     assert_raises(ImportError, __import__, "Qt")
Пример #42
0
# -*- coding: utf-8 -*-
# Copyright 2019 Lovac42
# Copyright 2006-2019 Ankitects Pty Ltd and contributors
# License: GNU AGPL, version 3 or later; http://www.gnu.org/licenses/agpl.html
# Support: https://github.com/lovac42/CCBC

# imports are all in this file to make moving to pyside easier in the future
# fixme: make sure not to optimize imports on this file

import sip
import os

from anki.utils import isWin, isMac

sip.setapi('QString', 2)
sip.setapi('QVariant', 2)
sip.setapi('QUrl', 2)
try:
    sip.setdestroyonexit(False)
except:
    # missing in older versions
    pass
from PyQt4.QtCore import *
from PyQt4.QtGui import *
from PyQt4 import QtGui as QtWidgets
from PyQt4.QtWebKit import QWebPage, QWebView, QWebSettings
from PyQt4.QtNetwork import QLocalServer, QLocalSocket
# from anki.lang import _

qtmajor = (QT_VERSION & 0xff0000) >> 16
qtminor = (QT_VERSION & 0x00ff00) >> 8
Пример #43
0
def setNewPyQtAPI():
    import sip
    # We now use the new PyQt API - IPython needs it
    sip.setapi('QString', 2)
    sip.setapi('QVariant', 2)
Пример #44
0
import sip
sip.setapi("QString", 2)
sip.setapi('QVariant', 2)

from __init__ import *

from PyQt5 import QtCore, QtGui


def addWidgetWithLayout(child, parent=None, **option):
    #add a widget to parent along with a new layout
    direction = option.get('direction', 'vertical')
    layout = None
    if direction == 'vertical':
        layout = QtWidgets.QVBoxLayout()
    elif direction == 'horizontoal':
        layout = QtWidgets.QHBoxLayout()
    if not parent:
        parent = child.parent()
    parent.setLayout(layout)
    layout.addWidget(child)
    layout.setSpacing(0)
    layout.setMargin(0)
    return child


class TestWindow(QtWidgets.QWidget):
    def __init__(self, parent=None):
        super(TestWindow, self).__init__(parent)
        self.setMinimumSize(100, 100)
        self.setWindowTitle('Prop Test')
import sip

sip.setapi(
    'QString',
    2)  # strange things happen without this. Must import before PyQt imports
# if using ipython: do this on bash before
# export QT_API=pyqt
from pyspatialite import dbapi2 as db
from qgis.core import *

from datetime import datetime, timedelta
import os
import unittest
from TimeManager.time_util import datetime_to_str, DEFAULT_FORMAT
from test_functionality import TestWithQGISLauncher, RiggedTimeManagerControl
import TimeManager.time_util as time_util
import TimeManager.timevectorlayer as timevectorlayer
from TimeManager.query_builder import STRINGCAST_FORMAT, INT_FORMAT, STRING_FORMAT
from mock import Mock

STARTTIME = 1420746289  # 8 January 2015
TEST_TABLE = "test_table"
DB_FILE = "testdata/test_db.sqlite"
DB_FILE_WITH_DATETIMES = "testdata/data_with_datetime.sqlite"
INTEGER_TIMESTAMP = "epoch_seconds"
STRING_TIMESTAMP = "datetime"
NUM_PTS = 100
"""Some test cases for Spatialite which do not build on Travis at the moment"""


class TestSpatialite(TestWithQGISLauncher):
Пример #46
0
def prepare_pyqt():
    import sip
    sip.setapi('QDate', 2)
    sip.setapi('QDateTime', 2)
    sip.setapi('QString', 2)
    sip.setapi('QTextStream', 2)
    sip.setapi('QTime', 2)
    sip.setapi('QUrl', 2)
    sip.setapi('QVariant', 2)
Пример #47
0
# Python2 defaults to PyQt4's API level 1, but Python3
# defaults to level 2, which is what we want. For
# compatibility, we have to explicitly ask for level 2.
import sip
for module in ("QString", "QUrl"):
    sip.setapi(module, 2)

import sys
import os
import signal
import os.path
from PyQt4 import QtCore
from PyQt4 import QtGui

try:
    from PyQt4.phonon import Phonon
    has_phonon = True
except:
    # If we don't have phonon, we fall back to QSound. Doesn't work on Linux.
    has_phonon = False


def init():
    global _app
    _app = QtGui.QApplication(sys.argv)
    # Needs to be set for media below
    _app.setApplicationName("fbmessenger")

    # These can't be local variables during play or they'll get GC'd.
    if has_phonon:
        global _pling_media, _pling_audio, _pling_source
Пример #48
0
# -*- coding: utf-8 -*-

# Form implementation generated from reading ui file 'form.ui'
#
# Created by: PyQt4 UI code generator 4.11.4
#
# WARNING! All changes made in this file will be lost!
import sip
sip.setapi('QString', 1)
from PyQt4 import QtCore, QtGui

try:
    _fromUtf8 = QtCore.QString.fromUtf8
except AttributeError:

    def _fromUtf8(s):
        return s


try:
    _encoding = QtGui.QApplication.UnicodeUTF8

    def _translate(context, text, disambig):
        return QtGui.QApplication.translate(context, text, disambig, _encoding)
except AttributeError:

    def _translate(context, text, disambig):
        return QtGui.QApplication.translate(context, text, disambig)


class Ui_Dialog(object):
Пример #49
0
from PyQt5.QtWidgets import QApplication
from expert import ExpertMainWindow

import sip
import sys

sip.setapi("QString", 1)

if __name__ == "__main__":
    a = QApplication(sys.argv)
    a.setStyle("fusion")
    w = ExpertMainWindow()
    w.show()
    a.exec_()
Пример #50
0
def prepare_pyqt4():
    # Set PySide compatible APIs.
    import sip
    try:
        sip.setapi('QDate', 2)
        sip.setapi('QDateTime', 2)
        sip.setapi('QString', 2)
        sip.setapi('QTextStream', 2)
        sip.setapi('QTime', 2)
        sip.setapi('QUrl', 2)
        sip.setapi('QVariant', 2)
    except ValueError as exc:
        if sys.version_info[0] <= 2:
            # most likely caused by something else setting the API version
            # before us: try to give a better error message to direct the user
            # how to fix.
            msg = exc.args[0]
            msg += (". Pyface expects PyQt API 2 under Python 2. "
                    "Either import Pyface before any other Qt-using packages, "
                    "or explicitly set the API before importing any other "
                    "Qt-using packages.")
            raise ValueError(msg)
        else:
            # don't expect the above on Python 3, so just re-raise
            raise
Пример #51
0
*   it under the terms of the GNU General Public License as published by  *
*   the Free Software Foundation; either version 2 of the License, or     *
*   (at your option) any later version.                                   *
*                                                                         *
***************************************************************************
"""

__author__ = 'Nathan Woodrow'
__date__ = 'May 2014'
__copyright__ = '(C) 2014, Nathan Woodrow'
# This will get replaced with a git SHA1 when you do a git archive
__revision__ = '$Format:%H$'

try:
    import sip
    sip.setapi("QVariant", 2)
except:
    pass

import inspect
import string
from qgis._core import *
from PyQt4.QtCore import QCoreApplication


def register_function(function,
                      arg_count,
                      group,
                      usesgeometry=False,
                      **kwargs):
    """
Пример #52
0
#!/usr/bin/env python
# -*- coding: utf-8 -*-
import sys
try:
    from PyQt5.QtGui import *
    from PyQt5.QtCore import *
    from PyQt5.QtWidgets import *
except ImportError:
    # needed for py3+qt4
    # Ref:
    # http://pyqt.sourceforge.net/Docs/PyQt4/incompatible_apis.html
    # http://stackoverflow.com/questions/21217399/pyqt4-qtcore-qvariant-object-instead-of-a-string
    if sys.version_info.major >= 3:
        import sip
        sip.setapi('QVariant', 2)
    from PyQt4.QtGui import *
    from PyQt4.QtCore import *

# PyQt5: TypeError: unhashable type: 'QListWidgetItem'


class HashableQTreeWidgetItem(QTreeWidgetItem):
    def __init__(self, *args):
        super(HashableQTreeWidgetItem, self).__init__(*args)
        self.setCheckState(0, Qt.Checked)
        self.setFlags(self.flags() | Qt.ItemIsTristate
                      | Qt.ItemIsUserCheckable)

    def __hash__(self):
        # return hash(id(self))
        # print(id(self))
Пример #53
0
import os
import matplotlib
import sip
for api in ['QString', 'QVariant', 'QDate', 'QDateTime', 'QTextStream', 'QTime', 
            'QUrl']:
    sip.setapi(api, 2)

matplotlib.use('Qt4Agg', warn=False)
from matplotlib.backends.qt_compat import QtCore, QtGui
if QtCore.__name__.lower().startswith('pyqt4'):
    os.environ['QT_API'] = 'pyqt'
elif QtCore.__name__.lower().startswith('pyside'):
    os.environ['QT_API'] = 'pyside'

def getOpenFileName(*args, **kwargs):
    fname = QtGui.QFileDialog.getOpenFileName(*args, **kwargs)
    if isinstance(fname, tuple):
        fname = fname[0]
    return fname

def getSaveFileName(*args, **kwargs):
    fname = QtGui.QFileDialog.getSaveFileName(*args, **kwargs)
    if isinstance(fname, tuple):
        fname = fname[0]
    return fname
Пример #54
0
def prepare_pyqt4():
    # Set API version 2 (compatible with both PyQt5 and PySide)
    import sip

    sip.setapi('QDate', 2)
    sip.setapi('QDateTime', 2)
    sip.setapi('QString', 2)
    sip.setapi('QTextStream', 2)
    sip.setapi('QTime', 2)
    sip.setapi('QUrl', 2)
    sip.setapi('QVariant', 2)
Пример #55
0
## A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
## OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
## SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
## LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
## DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
## THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
## (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
## OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE."
## $QT_END_LICENSE$
##
#############################################################################


# This is only needed for Python v2 but is harmless for Python v3.
import sip
sip.setapi('QVariant', 2)

from PyQt4 import QtCore, QtGui

try:
    import easing_rc3
except ImportError:
    import easing_rc2

from ui_form import Ui_Form


class Animation(QtCore.QPropertyAnimation):
    LinearPath, CirclePath = range(2)

    def __init__(self, target, prop):
Пример #56
0
# (at your option) any later version.
#
# This program is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
# GNU General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with this program; if not, see <http://www.gnu.org/licenses/>,
# or write to the Free Software Foundation, Inc.,
# 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
#

#ensure we use API 2 from pyqt regardless of python version with python qwt
import sip
sip.setapi('QString', 2)
sip.setapi('QVariant', 2)
sip.setapi('QDate', 2)
sip.setapi('QDateTime', 2)
sip.setapi('QTextStream', 2)
sip.setapi('QTime', 2)
sip.setapi('QUrl', 2)
import os
os.environ[
    'QT_API'] = 'pyqt'  #qt4 not 5 as is installed on most sytems running python 3!

debuglevels = {}
options = {}

import Timba.utils
import os
Пример #57
0
    except ImportError:
        # Try using PySide
        QT_API = QT_API_PYSIDE
        cond = ("Could not import sip; falling back on PySide\n"
                "in place of PyQt4 or PyQt5.\n")
        verbose.report(cond, 'helpful')

if _sip_imported:
    if QT_API == QT_API_PYQTv2:
        if QT_API_ENV == 'pyqt':
            cond = ("Found 'QT_API=pyqt' environment variable. "
                    "Setting PyQt4 API accordingly.\n")
        else:
            cond = "PyQt API v2 specified."
        try:
            sip.setapi('QString', 2)
        except:
            res = 'QString API v2 specification failed. Defaulting to v1.'
            verbose.report(cond + res, 'helpful')
            # condition has now been reported, no need to repeat it:
            cond = ""
        try:
            sip.setapi('QVariant', 2)
        except:
            res = 'QVariant API v2 specification failed. Defaulting to v1.'
            verbose.report(cond + res, 'helpful')
    if QT_API == QT_API_PYQT5:
        try:
            from PyQt5 import QtCore, QtGui, QtWidgets
            _getSaveFileName = QtWidgets.QFileDialog.getSaveFileName
        except ImportError:
Пример #58
0
*                                                                         *
***************************************************************************
"""

__author__ = 'Matthias Kuhn'
__date__ = 'November 2015'
__copyright__ = '(C) 2015, Matthias Kuhn'
# This will get replaced with a git SHA1 when you do a git archive
__revision__ = 'f9842426dccac3b44472f22362191c98bdc34deb'

import sip
for api in [
        "QDate", "QDateTime", "QString", "QTextStream", "QTime", "QUrl",
        "QVariant"
]:
    sip.setapi(api, 2)

from PyQt4.QtCore import *
from PyQt4.QtGui import QItemSelectionModel, QSortFilterProxyModel

# Add a __nonzero__ method onto QPyNullVariant so we can check for null values easier.
#   >>> value = QPyNullVariant("int")
#   >>> if value:
#   >>>       print "Not a null value"
from types import MethodType
from PyQt4.QtCore import QPyNullVariant


def __nonzero__(self):
    return False
Пример #59
0
import sys
import os

import cPickle as pickle
import sip
API_NAMES = ["QDate", "QDateTime", "QString", "QTextStream", "QTime", "QUrl", "QVariant"]
API_VERSION = 2
for api_name in API_NAMES:
    sip.setapi(api_name, API_VERSION)
from PyQt4 import QtGui, QtCore

from molecular_view import MolecularView
from molecular_scene import MolecularScene
from output_dialog import OutputDialog
import settings


class MainWindow(QtGui.QMainWindow):
    """The main window of the UI."""

    def __init__(self):
        """Initialise the main window."""
        super(MainWindow, self).__init__()
        self.setGeometry(100, 100, 800, 500)
        self.setWindowTitle('MolecularUI')

        file_menu = QtGui.QMenu("File", self)

        save_action = QtGui.QAction("Save", self)
        save_action.setShortcut(QtGui.QKeySequence("Ctrl+S"))
        QtCore.QObject.connect(save_action, QtCore.SIGNAL("triggered()"),
Пример #60
0
# -*- coding: utf-8 -*-

import csv, operator, collections, urllib, itertools, os, json
import common, verticals
# for using native Python strings
import sip

sip.setapi('QString', 2)
from PyQt4.QtCore import QUrl
import parser, scrape, selector, transition

# constants for type of parameter
PATH, GET, POST, COOKIE = 0, 1, 2, 3


def build(browser, transitions, input_values, prev_transitions=None):
    """Build a model of these transitions. 
        A recursion via abstract(browser, input_values, examples).
    
    Parameters
    ----------
    browser: AjaxBrowser
    transitions: group of transaction of the same kind (same step in interactive wrapper) to be analyzed
    input_values: dictionary
            input keys and values of the interactive wrapper
        
    Returns the model or None if failed to abstract transitions.
    """
    diffs = find_differences(
        transitions
    )  # differing parameters can potentially be relevant parameters dependent on the input into the original wrapper.