def newmemorylayer():
    uri = "point?crs=epsg:4326&field=id:integer"
    layer = QgsVectorLayer(uri, "testlayer", "memory")
    print QgsProviderRegistry.instance().pluginList()
    print layer.dataProvider()
    print layer.dataProvider().errors()
    return layer

def getFileFilter(param):
    """
    Returns a suitable file filter pattern for the specified parameter definition
    :param param:
    :return:
    """
    if param.type() == 'layer':
        vectors = QgsProviderRegistry.instance().fileVectorFilters().split(';;')
        vectors.pop(0)
        rasters = QgsProviderRegistry.instance().fileRasterFilters().split(';;')
        rasters.pop(0)
        filters = set(vectors + rasters)
        filters = sorted(filters)
        return tr('All files (*.*)') + ';;' + ";;".join(filters)
    elif param.type() == 'multilayer':
        if param.layerType() == QgsProcessing.TypeRaster:
            exts = QgsRasterFileWriter.supportedFormatExtensions()
        elif param.layerType() == QgsProcessing.TypeFile:
            return tr('All files (*.*)', 'QgsProcessingParameterMultipleLayers')
        else:
            exts = QgsVectorFileWriter.supportedFormatExtensions()
        for i in range(len(exts)):
            exts[i] = tr('{0} files (*.{1})', 'QgsProcessingParameterMultipleLayers').format(exts[i].upper(), exts[i].lower())
        return tr('All files (*.*)') + ';;' + ';;'.join(exts)
    elif param.type() == 'raster':
        return QgsProviderRegistry.instance().fileRasterFilters()
    elif param.type() == 'rasterDestination':
        if param.provider() is not None:
            exts = param.provider().supportedOutputRasterLayerExtensions()
        else:
            exts = QgsRasterFileWriter.supportedFormatExtensions()
        for i in range(len(exts)):
            exts[i] = tr('{0} files (*.{1})', 'ParameterRaster').format(exts[i].upper(), exts[i].lower())
        return ';;'.join(exts) + ';;' + tr('All files (*.*)')
    elif param.type() in ('sink', 'vectorDestination'):
        if param.provider() is not None:
            exts = param.provider().supportedOutputVectorLayerExtensions()
        else:
            exts = QgsVectorFileWriter.supportedFormatExtensions()
        for i in range(len(exts)):
            exts[i] = tr('{0} files (*.{1})', 'ParameterVector').format(exts[i].upper(), exts[i].lower())
        return ';;'.join(exts) + ';;' + tr('All files (*.*)')
    elif param.type() == 'source':
        return QgsProviderRegistry.instance().fileVectorFilters()
    elif param.type() == 'vector':
        return QgsProviderRegistry.instance().fileVectorFilters()
    elif param.type() == 'fileDestination':
        return param.fileFilter() + ';;' + tr('All files (*.*)')

    if param.defaultFileExtension():
        return tr('Default extension') + ' (*.' + param.defaultFileExtension() + ')'
    else:
        return ''

 def _open_wmts(self, name, capabilites_url):
     # Add new HTTPConnection like in source
     # https://github.com/qgis/QGIS/blob/master/src/gui/qgsnewhttpconnection.cpp
     
     self.msg_log(u'add WM(T)S: Name = {0}, URL = {1}'.format(name, capabilites_url))
     
     s = QSettings()
     
     s.setValue(u'Qgis/WMS/{0}/password'.format(name), '')
     s.setValue(u'Qgis/WMS/{0}/username'.format(name), '')
     s.setValue(u'Qgis/connections-wms/{0}/dpiMode'.format(name), 7)  # refer to https://github.com/qgis/QGIS/blob/master/src/gui/qgsnewhttpconnection.cpp#L229-L247
     s.setValue(u'Qgis/connections-wms/{0}/ignoreAxisOrientation'.format(name), False)
     s.setValue(u'Qgis/connections-wms/{0}/ignoreGetFeatureInfoURI'.format(name), False)
     s.setValue(u'Qgis/connections-wms/{0}/ignoreGetMapURI'.format(name), False)
     s.setValue(u'Qgis/connections-wms/{0}/invertAxisOrientation'.format(name), False)
     s.setValue(u'Qgis/connections-wms/{0}/referer'.format(name), '')
     s.setValue(u'Qgis/connections-wms/{0}/smoothPixmapTransform'.format(name), False)
     s.setValue(u'Qgis/connections-wms/{0}/url'.format(name), capabilites_url)
     
     s.setValue(u'Qgis/connections-wms/selected', name)
     
     # create new dialog
     wms_dlg = QgsProviderRegistry.instance().selectWidget("wms", self.main_win)
     
     QObject.connect(wms_dlg, SIGNAL( "addRasterLayer( QString const &, QString const &, QString const & )" ),
                self.main_win, SLOT( "addRasterLayer( QString const &, QString const &, QString const & )" ) )
     
     wms_dlg.show()

 def testDecodeUri(self):
     """
     Test decoding an AFS uri
     """
     uri = self.vl.source()
     parts = QgsProviderRegistry.instance().decodeUri(self.vl.dataProvider().name(), uri)
     self.assertEqual(parts, {'url': 'http://' + self.basetestpath + '/fake_qgis_http_endpoint'})

    def loadVectorLayerFromParameter(self, name, parameters, context, feedback, external=False):
        """
        Creates a dedicated command to load a vector into
        the temporary GRASS DB.
        :param name: name of the parameter
        :param parameters: Parameters of the algorithm.
        :param context: Processing context
        :param external: use v.external (v.in.ogr if False).
        """
        layer = self.parameterAsVectorLayer(parameters, name, context)

        is_ogr_disk_based_layer = layer is not None and layer.dataProvider().name() == 'ogr'
        if is_ogr_disk_based_layer:
            # we only support direct reading of disk based ogr layers -- not ogr postgres layers, etc
            source_parts = QgsProviderRegistry.instance().decodeUri('ogr', layer.source())
            if not source_parts.get('path'):
                is_ogr_disk_based_layer = False
            elif source_parts.get('layerId'):
                # no support for directly reading layers by id in grass
                is_ogr_disk_based_layer = False

        if not is_ogr_disk_based_layer:
            # parameter is not a vector layer or not an OGR layer - try to convert to a source compatible with
            # grass OGR inputs and extract selection if required
            path = self.parameterAsCompatibleSourceLayerPath(parameters, name, context,
                                                             QgsVectorFileWriter.supportedFormatExtensions(),
                                                             feedback=feedback)
            ogr_layer = QgsVectorLayer(path, '', 'ogr')
            self.loadVectorLayer(name, ogr_layer, external=external, feedback=feedback)
        else:
            # already an ogr disk based layer source
            self.loadVectorLayer(name, layer, external=external, feedback=feedback)

 def test_043_decodeuri(self):
     # URI decoding
     filename = '/home/to/path/test.csv'
     uri = 'file://{}?geomType=none'.format(filename)
     registry = QgsProviderRegistry.instance()
     components = registry.decodeUri('delimitedtext', uri)
     self.assertEqual(components['path'], filename)

    def test_qgis_environment(self):
        """QGIS environment has the expected providers"""

        r = QgsProviderRegistry.instance()
        self.assertIn('gdal', r.providerList())
        self.assertIn('ogr', r.providerList())
        self.assertIn('postgres', r.providerList())

    def setUpClass(cls):
        """Run before all tests"""
        # Register the provider
        r = QgsProviderRegistry.instance()
        metadata = QgsProviderMetadata(PyProvider.providerKey(), PyProvider.description(), PyProvider.createProvider)
        assert r.registerProvider(metadata)
        assert r.providerMetadata(PyProvider.providerKey()) == metadata

        # Create test layer
        cls.vl = cls.createLayer()
        assert (cls.vl.isValid())
        cls.source = cls.vl.dataProvider()

        # poly layer
        cls.poly_vl = QgsVectorLayer('Polygon?crs=epsg:4326&field=pk:integer&key=pk',
                                     'test', 'pythonprovider')
        assert (cls.poly_vl.isValid())
        cls.poly_provider = cls.poly_vl.dataProvider()

        f1 = QgsFeature()
        f1.setAttributes([1])
        f1.setGeometry(QgsGeometry.fromWkt('Polygon ((-69.03664108 81.35818902, -69.09237722 80.24346619, -73.718477 80.1319939, -73.718477 76.28620011, -74.88893598 76.34193625, -74.83319983 81.35818902, -69.03664108 81.35818902))'))

        f2 = QgsFeature()
        f2.setAttributes([2])
        f2.setGeometry(QgsGeometry.fromWkt('Polygon ((-67.58750139 81.1909806, -66.30557012 81.24671674, -66.30557012 76.89929767, -67.58750139 76.89929767, -67.58750139 81.1909806))'))

        f3 = QgsFeature()
        f3.setAttributes([3])
        f3.setGeometry(QgsGeometry.fromWkt('Polygon ((-68.36780737 75.78457483, -67.53176524 72.60761475, -68.64648808 73.66660144, -70.20710006 72.9420316, -68.36780737 75.78457483))'))

        f4 = QgsFeature()
        f4.setAttributes([4])

        cls.poly_provider.addFeatures([f1, f2, f3, f4])

    def _open_wfs(self, name, capabilites_url):
        # Add new HTTPConnection like in source
        # https://github.com/qgis/QGIS/blob/master/src/gui/qgsnewhttpconnection.cpp
        # https://github.com/qgis/QGIS/blob/79616fd8d8285b4eb93adafdfcb97a3e429b832e/src/app/qgisapp.cpp#L3783

        self.msg_log(u'add WFS: Name={0}, original URL={1}'.format(name, capabilites_url))

        # remove additional url parameters, otherwise adding wfs works the frist time only
        # https://github.com/qgis/QGIS/blob/9eee12111567a84f4d4de7e020392b3c01c28598/src/gui/qgsnewhttpconnection.cpp#L199-L214
        url = QUrl(capabilites_url)
        url.removeQueryItem('SERVICE')
        url.removeQueryItem('REQUEST')
        url.removeQueryItem('FORMAT')
        url.removeQueryItem('service')
        url.removeQueryItem('request')
        url.removeQueryItem('format')
        #also remove VERSION: shouldn't be necessary, but QGIS sometimes seems to append version=1.0.0
        url.removeQueryItem('VERSION')
        url.removeQueryItem('version')

        capabilites_url = url.toString()
        self.msg_log(u'add WFS: Name={0}, base URL={1}'.format(name, capabilites_url))

        s = QSettings()

        self.msg_log(u'existing WFS url: {0}'.format(s.value(u'Qgis/connections-wfs/{0}/url'.format(name), '')))

        key_user = u'Qgis/WFS/{0}/username'.format(name)
        key_pwd = u'Qgis/WFS/{0}/password'.format(name)
        key_referer = u'Qgis/connections-wfs/{0}/referer'.format(name)
        key_url = u'Qgis/connections-wfs/{0}/url'.format(name)
        key_authcfg = u'Qgis/WFS/{0}/authcfg'.format(name)

        s.remove(key_user)
        s.remove(key_pwd)
        s.remove(key_referer)
        s.remove(key_url)
        s.sync()

        s.setValue(key_user, '')
        s.setValue(key_pwd, '')
        s.setValue(key_referer, '')
        s.setValue(key_url, capabilites_url)

        if self.settings.auth_propagate and self.settings.authcfg:
            s.setValue(key_authcfg, self.settings.authcfg)

        s.setValue(u'Qgis/connections-wfs/selected', name)

        # create new dialog
        wfs_dlg = QgsProviderRegistry.instance().selectWidget("WFS", self.main_win)

        QObject.connect(
            wfs_dlg
            , SIGNAL("addWfsLayer( QString, QString )")
            , self.main_win, SLOT("addWfsLayer( QString, QString )")
        )

        wfs_dlg.show()

  def selectFiles( self ):
    filters = QgsProviderRegistry.instance().fileVectorFilters()
    files, self.encoding = ftools_utils.openDialog( self, filtering=filters, dialogMode="MultipleFiles" )
    if files is None:
      return

    self.layers.extend( [ unicode( f ) for f in files ] )
    self.lstLayers.addItems( files )

    def testDecodeUri(self):
        """Check that the provider URI decoding returns expected values"""

        filename = '/home/to/path/test.db'
        uri = 'dbname=\'{}\' table="test" (geometry) sql='.format(filename)
        registry = QgsProviderRegistry.instance()
        components = registry.decodeUri('spatialite', uri)
        self.assertEqual(components['path'], filename)

    def allRastersFilter(self):
        if self.rastersFilter == '':
            self.rastersFilter = QgsProviderRegistry.instance().fileRasterFilters()

            # workaround for Qgis < 1.5 (see #2376)
            # removed as this is a core plugin Qgis >= 1.9

        return self.rastersFilter

 def dump_configinfo(self):
     from qgis.core import QgsApplication, QgsProviderRegistry
     from PyQt4.QtGui import QImageReader, QImageWriter
     yield QgsProviderRegistry.instance().pluginList()
     yield QImageReader.supportedImageFormats()
     yield QImageWriter.supportedImageFormats()
     yield QgsApplication.libraryPaths()
     yield "Translation file: {}".format(self.translationFile)

    def test_qgis_environment(self):
        """QGIS environment has the expected providers"""
        # noinspection PyUnresolvedReferences
        r = QgsProviderRegistry.instance()

        # print 'Provider count: %s' % len(r.providerList())
        assert 'gdal' in r.providerList()
        assert 'ogr' in r.providerList()
        assert 'postgres' in r.providerList()

    def test_QGISEnvironment(self):
        """QGIS environment has the expected providers"""

        r = QgsProviderRegistry.instance()
        #for item in r.providerList():
        #    print str(item)

        #print 'Provider count: %s' % len(r.providerList())
        assert 'gdal' in r.providerList()
        assert 'ogr' in r.providerList()

    def __init__(self, template_path, debug=False):
        """Constructor.

        :param template_path: Absolute path to a QGIS composer template file.
        :type template_path: str
        """
        gui_flag = True
        self.app = QgsApplication(sys.argv, gui_flag)

        # Make sure QGIS_PREFIX_PATH is set in your env if needed!
        self.app.initQgis()

        if debug:
            print QgsProviderRegistry.instance().pluginList()

        self.canvas = QgsMapCanvas()
        self.canvas.enableAntiAliasing(True)

        self.template_path = template_path

    def open_file_browser(self):

        # noinspection PyArgumentList
        raster_filter = QgsProviderRegistry.instance().fileRasterFilters()

        # noinspection PyArgumentList
        raster = QFileDialog.getOpenFileName(
            parent=self.parent,
            caption=tr('Select raster'),
            filter=raster_filter)
        self.le_shapefile.setText(raster)

    def setUpClass(cls):
        """Run before all tests"""

        # qgis instances
        cls._QgisApp, cls._Canvas, cls._Iface, cls._Parent = \
            QGISAPP, CANVAS, IFACE, PARENT

        cls._PalReportDir = PALREPORTDIR

        # verify that spatialite provider is available
        msg = ('\nSpatialite provider not found, '
               'SKIPPING TEST SUITE')
        res = 'spatialite' in QgsProviderRegistry.instance().providerList()
        assert res, msg

        # load the FreeSansQGIS labeling test font
        fontdb = QFontDatabase()
        cls._TestFontID = fontdb.addApplicationFont(
            os.path.join(cls._TestDataDir, 'font', 'FreeSansQGIS.ttf'))
        msg = ('\nCould not store test font in font database, '
               'SKIPPING TEST SUITE')
        assert cls._TestFontID != -1, msg

        cls._TestFont = fontdb.font('FreeSansQGIS', 'Medium', 48)
        appfont = QApplication.font()
        msg = ('\nCould not load test font from font database, '
               'SKIPPING TEST SUITE')
        assert cls._TestFont.toString() != appfont.toString(), msg

        cls._TestFunction = ''
        cls._TestGroup = ''
        cls._TestGroupPrefix = ''
        cls._TestGroupAbbr = ''

        # initialize class MapRegistry, Canvas, MapRenderer, Map and PAL
        cls._MapRegistry = QgsMapLayerRegistry.instance()
        # set color to match render test comparisons background
        cls._Canvas.setCanvasColor(QColor(152, 219, 249))
        cls._Map = cls._Canvas.map()
        cls._Map.resize(QSize(600, 400))
        cls._MapRenderer = cls._Canvas.mapRenderer()
        crs = QgsCoordinateReferenceSystem()
        # default for labeling test data sources: WGS 84 / UTM zone 13N
        crs.createFromSrid(32613)
        cls._MapRenderer.setDestinationCrs(crs)
        # TODO: match and store platform's native logical output dpi
        cls._MapRenderer.setOutputSize(QSize(600, 400), 72)

        cls._Pal = QgsPalLabeling()
        cls._MapRenderer.setLabelingEngine(cls._Pal)
        cls._PalEngine = cls._MapRenderer.labelingEngine()
        msg = ('\nCould not initialize PAL labeling engine, '
               'SKIPPING TEST SUITE')
        assert cls._PalEngine, msg

    def populateControls(self):
        if self.populated:
            return
        
        self.updateCOMPorts()
        # Read version

        self.versionLabel.setText(roam.__version__)
        self.qgisapiLabel.setText(str(QGis.QGIS_VERSION))
        ecwsupport = 'ecw' in QgsProviderRegistry.instance().fileRasterFilters()
        self.ecwlabel.setText("Yes" if ecwsupport else "No")

def getFileFilter(param):
    """
    Returns a suitable file filter pattern for the specified parameter definition
    :param param:
    :return:
    """
    if param.type() == 'multilayer':
        if param.layerType() == QgsProcessing.TypeRaster:
            exts = dataobjects.getSupportedOutputRasterLayerExtensions()
        elif param.layerType() == QgsProcessing.TypeFile:
            return tr('All files (*.*)', 'QgsProcessingParameterMultipleLayers')
        else:
            exts = QgsVectorFileWriter.supportedFormatExtensions()
        for i in range(len(exts)):
            exts[i] = tr('{0} files (*.{1})', 'QgsProcessingParameterMultipleLayers').format(exts[i].upper(), exts[i].lower())
        return tr('All files (*.*)') + ';;' + ';;'.join(exts)
    elif param.type() == 'raster':
        return QgsProviderRegistry.instance().fileRasterFilters()
    elif param.type() == 'rasterDestination':
        exts = dataobjects.getSupportedOutputRasterLayerExtensions()
        for i in range(len(exts)):
            exts[i] = tr('{0} files (*.{1})', 'QgsProcessingParameterRasterDestination').format(exts[i].upper(), exts[i].lower())
        return tr('All files (*.*)') + ';;' + ';;'.join(exts)
    elif param.type() == 'table':
        exts = ['csv', 'dbf']
        for i in range(len(exts)):
            exts[i] = tr('{0} files (*.{1})', 'ParameterTable').format(exts[i].upper(), exts[i].lower())
        return tr('All files (*.*)') + ';;' + ';;'.join(exts)
    elif param.type() == 'sink':
        exts = QgsVectorFileWriter.supportedFormatExtensions()
        for i in range(len(exts)):
            exts[i] = tr('{0} files (*.{1})', 'ParameterVector').format(exts[i].upper(), exts[i].lower())
        return tr('All files (*.*)') + ';;' + ';;'.join(exts)
    elif param.type() == 'source':
        return QgsProviderRegistry.instance().fileVectorFilters()
    elif param.type() == 'vector':
        return QgsProviderRegistry.instance().fileVectorFilters()
    elif param.type() == 'fileOut':
        return tr('All files (*.*)') + ';;' + param.fileFilter()

    return ''