PyQGIS

dlg = QMessageBox()
dlg.setText("Trail")
dlg.open()
dlg.close()

editor = QgsCodeEditorPython()
editor.show()

from qgis.core import QgsProject
pjt = QgsProject.instance()
pjt.read('D:/python/bxl-culturel/bxl-culturel.qgz')

iface.addVectorLayer('D:/python/bxl-culturel/bruxelles_parcours_bd/bruxelles_parcours_bd.shp',
'Parcours bd - iface', 'ogr')

layer = iface.activeLayer()
iface.setActiveLayer(layer)
len(layer) #count features
layer.name()
layer.source()
layer.geometryType()
layer.featureCount()
layer.fields()

for i in layer.fields():
    print(i)

layer.storageType()

uri = QgsDataSourceUri()
# attention vous devez renseigner le chemin absolu
uri.setDatabase('/chemin/absolu/vers/data/db_streetart.sqlite')

schema = ''
table = 'layer_streetart'
geom_column = 'geometry'

uri.setDataSource(schema, table, geom_column)

# affichage de l'uri (vu comme la source)
uri.uri() # returns 'dbname=\'/chemin/absolu/vers/data/db_streetart.sqlite\' table="layer_streetart" (geometry)'

vlayer = QgsVectorLayer(uri.uri(), 'Street art', 'spatialite')
QgsProject.instance().addMapLayer(vlayer)

uri = QgsDataSourceUri()

# set host name, port, database name, username and password :
# uri.setConnection(host, port, db_name, username, password)
uri.setConnection("localhost", "5432", "postgres", "postgres", "1234")

# set database schema, table name, geometry column and optionally
# subset (WHERE clause)
uri.setDataSource("solar", "ground", "geom")

# get the generated URI
uri.uri() # returns 'dbname=\'postgres\' host=localhost port=5432 user=\'postgres\'
password=\'1234\' table="solar"."ground" (geom)'

# adding the layer using iface
iface.addVectorLayer(uri.uri(), "Nom de ma couche", "postgres")

for l in iface.mapCanvas().layers():
    print(l)

# Afficher les couches dont l'ID contient "bruxelles"
dict_layers = pjt.mapLayers()
list_bxl=[]
for id_layer, layer in dict_layers.items():
    if 'bruxelles' in id_layer:
        list_bxl.append(layer)

print(list_bxl)

layer = iface.activeLayer()
elem0 = layer.getFeature(0) # si venant de db utiliser la pk
print(elem0['nom_de_la_'])

for feature in layer.getFeatures():
    print(feature['nom_de_la_'])

processing.run # Lance seulement le traitement

processing.runAndLoadResults # Charge automatiquement le résultat dans QGIS

result = processing.run(
    "native:buffer",
    {
        'INPUT': my_layer,
        'DISTANCE': 1000,
        'SEGMENTS': 5,
        'END_CAP_STYLE': 0,
        'JOIN_STYLE': 0,
        'MITER_LIMIT': 2,
        'DISSOLVE': False,
        'OUTPUT': 'TEMPORARY_OUTPUT'
    }
)

output_path="/tmp/output.gpkg"

# appel de la méthode de sauvegarde
QgsVectorLayerExporter.exportLayer(
    layer = result_layer,
    uri = output_path,
    providerKey = 'ogr',
    destCRS = QgsCoordinateReferenceSystem('EPSG:2154')
)

exec(open('chemin_vers_le_script.py'.encode('utf-8')).read())

from qgis.core import QgsProject, QgsCoordinateReferenceSystem, QgsVectorLayerExporter
import processing

pjt = QgsProject.instance()
target_crs = QgsCoordinateReferenceSystem("EPSG:3812")

bus_layer = next((l for l in pjt.mapLayers().values() if 'bus_stops' in l.name()), None)
street_layer = next((l for l in pjt.mapLayers().values() if 'Street art' in l.name()), None)

if not bus_layer or not street_layer:
    raise ValueError("Couche 'bus_stops' ou 'Street art' introuvable.")

bus_layer_reprojected = processing.run("native:reprojectlayer", {
    'INPUT': bus_layer,
    'TARGET_CRS': target_crs,
    'OUTPUT': 'TEMPORARY_OUTPUT'
})['OUTPUT']

if street_layer.crs() != target_crs:
    street_layer_reprojected = processing.run("native:reprojectlayer", {
        'INPUT': street_layer,
        'TARGET_CRS': target_crs,
        'OUTPUT': 'TEMPORARY_OUTPUT'
    })['OUTPUT']
else:
    street_layer_reprojected = street_layer

buffer_layer = processing.run("native:buffer", {
    'INPUT': bus_layer_reprojected,
    'DISTANCE': 100,
    'OUTPUT': 'TEMPORARY_OUTPUT'
})['OUTPUT']

extracted_layer = processing.run("native:extractbylocation", {
    "INPUT": street_layer_reprojected,
    "PREDICATE": [0],  # 0 = intersecte
    "INTERSECT": buffer_layer,
    "OUTPUT": 'TEMPORARY_OUTPUT'
})['OUTPUT']

output_path = "D:/python/tmp/fresques_proches_bus.gpkg"
QgsVectorLayerExporter.exportLayer(
    layer=extracted_layer,
    uri=output_path,
    providerKey='ogr',
    destCRS=target_crs
)

extracted_layer.setName("Fresques proches bus")
pjt.addMapLayer(extracted_layer)

print(f"🎉 Succès ! {extracted_layer.featureCount()} fresques trouvées à moins de 1000m d'un arrêt de bus.")

"""
***************************************************************************
*                                                                         *
*   This program is free software; you can redistribute it and/or modify  *
*   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.                                   *
*                                                                         *
***************************************************************************
"""

from typing import Any, Optional

from qgis.core import (
    QgsFeatureSink,
    QgsProcessing,
    QgsProcessingAlgorithm,
    QgsProcessingContext,
    QgsProcessingException,
    QgsProcessingFeedback,
    QgsProcessingParameterFeatureSink,
    QgsProcessingParameterFeatureSource,
    QgsProcessingParameterVectorLayer,
    QgsProject,
    QgsVectorLayer
)
from qgis import processing


class ExampleProcessingAlgorithmJune2026(QgsProcessingAlgorithm):

    OUTPUT = 'OUTPUT'

    def name(self) -> str:
        return "example_june2026"

    def displayName(self) -> str:
        return "Exemple June 2026"

    def group(self) -> str:
        return "Example scripts"

    def groupId(self) -> str:
        return "examplescripts"

    def shortHelpString(self) -> str:
        return "Example algorithm short description"

    def initAlgorithm(self, config: Optional[dict[str, Any]] = None):
        """
        Here we define the inputs and output of the algorithm, along
        with some other properties.
        """
        self.addParameter(QgsProcessingParameterVectorLayer('bus_stop', 'BUS_STOP', defaultValue=None))
        self.addParameter(QgsProcessingParameterVectorLayer('street_art', 'STREET_ART', defaultValue=None))

    def processAlgorithm(
        self,
        parameters: dict[str, Any],
        context: QgsProcessingContext,
        feedback: QgsProcessingFeedback,
    ) -> dict[str, Any]:

        CRS_METRIQUE = 'EPSG:3812'      # Lambert 2008 (Belgique), en mètres
        DISTANCE = 100
        # SORTIE = r"D:\a3_python\pyqgis\tmp\fresques_proches_bus.gpkg"

        bus_id = parameters['bus_stop']
        street_art_id=parameters['street_art']

        pjt = QgsProject.instance()
        bus = pjt.mapLayers()[bus_id]
        street_art = pjt.mapLayers()[street_art_id]

        # Reprojeter bus vers 3812
        if bus.crs().authid() != CRS_METRIQUE:
            bus = processing.run(
                "native:reprojectlayer", 
                {
                'INPUT': bus, 
                'TARGET_CRS': CRS_METRIQUE, 
                'OUTPUT': 'TEMPORARY_OUTPUT',
            })['OUTPUT']

        # Reprojeter street vers 3812 si besoin (il est en 2154 → sera reprojeté)
        if street_art.crs().authid() != CRS_METRIQUE:
            street_art = processing.run("native:reprojectlayer", {
                'INPUT': street_art, 
                'TARGET_CRS': CRS_METRIQUE, 
                'OUTPUT': 'TEMPORARY_OUTPUT',
            })['OUTPUT']

        # Buffer 100 m autour des arrêts
        buffer_bus = processing.run("native:buffer", {
            'INPUT': bus,
            'DISTANCE': 100, 
            'JOIN_STYLE': 0,
            'MITER_LIMIT': 2,
            'DISSOLVE': True, 
            'OUTPUT': 'TEMPORARY_OUTPUT',
        })['OUTPUT']

        # Extraire les fresques qui intersectent le buffer + sauvegarde GPKG
        result = processing.run("native:extractbylocation", {
            'INPUT': street_art, 
            'PREDICATE': [0], 
            'INTERSECT': buffer_bus, 
            'OUTPUT': 'TEMPORARY_OUTPUT', 
        })['OUTPUT']

        result.setName("Street art près des arrêts de bus")        
        pjt.addMapLayer(result)

        return dict()

    def createInstance(self):
        return self.__class__()