Skip to content

extract

extract

This module contains all interface definition to translate from QGIS project to QGIS-Server-Light logic and to write the JSON export of the QGIS project

AbstractDataset dataclass

Bases: LayerLike

Source code in src/qgis_server_light/interface/exporter/extract.py 
92
93
94
@dataclass(repr=False)
class AbstractDataset(LayerLike):
    title: str = field(metadata={"type": "Element"})

title: str = field(metadata={'type': 'Element'}) class-attribute instance-attribute

__init__(id: str, name: str, title: str) -> None

Config dataclass

Bases: BaseInterface

Source code in src/qgis_server_light/interface/exporter/extract.py 
635
636
637
638
639
640
@dataclass(repr=False)
class Config(BaseInterface):
    project: Project = field(metadata={"type": "Element"})
    meta_data: MetaData = field(metadata={"type": "Element"})
    tree: Tree = field(metadata={"type": "Element"})
    datasets: Datasets = field(metadata={"type": "Element"})

datasets: Datasets = field(metadata={'type': 'Element'}) class-attribute instance-attribute

meta_data: MetaData = field(metadata={'type': 'Element'}) class-attribute instance-attribute

project: Project = field(metadata={'type': 'Element'}) class-attribute instance-attribute

tree: Tree = field(metadata={'type': 'Element'}) class-attribute instance-attribute

__init__(project: Project, meta_data: MetaData, tree: Tree, datasets: Datasets) -> None

Crs dataclass

Bases: BaseInterface

Source code in src/qgis_server_light/interface/exporter/extract.py 
 97
 98
 99
100
101
102
103
104
105
@dataclass(repr=False)
class Crs(BaseInterface):
    auth_id: str = field(default=None, metadata={"type": "Element"})
    postgis_srid: int = field(
        default=None,
        metadata={"type": "Element"},
    )
    ogc_uri: str = field(default=None, metadata={"type": "Element"})
    ogc_urn: str = field(default=None, metadata={"type": "Element"})

auth_id: str = field(default=None, metadata={'type': 'Element'}) class-attribute instance-attribute

ogc_uri: str = field(default=None, metadata={'type': 'Element'}) class-attribute instance-attribute

ogc_urn: str = field(default=None, metadata={'type': 'Element'}) class-attribute instance-attribute

postgis_srid: int = field(default=None, metadata={'type': 'Element'}) class-attribute instance-attribute

__init__(auth_id: str = None, postgis_srid: int = None, ogc_uri: str = None, ogc_urn: str = None) -> None

Custom dataclass

Bases: DataSet

Source code in src/qgis_server_light/interface/exporter/extract.py 
523
524
525
@dataclass(repr=False)
class Custom(DataSet):
    pass

__init__(id: str, name: str, title: str, source: DataSource, driver: str, bbox: BBox | None = None, bbox_wgs84: BBox | None = None, crs: Crs | None = None, styles: List[Style] = list(), minimum_scale: float | None = None, maximum_scale: float | None = None, style_name: str = 'default', is_spatial: bool = True) -> None

DataSet dataclass

Bases: AbstractDataset

Source code in src/qgis_server_light/interface/exporter/extract.py 
465
466
467
468
469
470
471
472
473
474
475
476
477
478
479
480
481
482
483
484
485
@dataclass(repr=False)
class DataSet(AbstractDataset):
    source: DataSource = field(metadata={"type": "Element"})
    driver: str = field(metadata={"type": "Element"})
    bbox: BBox | None = field(default=None, metadata={"type": "Element"})
    bbox_wgs84: BBox | None = field(default=None, metadata={"type": "Element"})
    crs: Crs | None = field(default=None, metadata={"type": "Element"})
    styles: List[Style] = field(default_factory=list, metadata={"type": "Element"})
    minimum_scale: float | None = field(default=None, metadata={"type": "Element"})
    maximum_scale: float | None = field(default=None, metadata={"type": "Element"})
    style_name: str = field(default="default", metadata={"type": "Element"})
    is_spatial: bool = field(default=True, metadata={"type": "Element"})

    def get_style_by_name(self, name: str) -> Style | None:
        for style in self.styles:
            if name == style.name:
                return style
        return None

    def style(self) -> Style | None:
        return self.get_style_by_name(self.style_name)

bbox: BBox | None = field(default=None, metadata={'type': 'Element'}) class-attribute instance-attribute

bbox_wgs84: BBox | None = field(default=None, metadata={'type': 'Element'}) class-attribute instance-attribute

crs: Crs | None = field(default=None, metadata={'type': 'Element'}) class-attribute instance-attribute

driver: str = field(metadata={'type': 'Element'}) class-attribute instance-attribute

is_spatial: bool = field(default=True, metadata={'type': 'Element'}) class-attribute instance-attribute

maximum_scale: float | None = field(default=None, metadata={'type': 'Element'}) class-attribute instance-attribute

minimum_scale: float | None = field(default=None, metadata={'type': 'Element'}) class-attribute instance-attribute

source: DataSource = field(metadata={'type': 'Element'}) class-attribute instance-attribute

style_name: str = field(default='default', metadata={'type': 'Element'}) class-attribute instance-attribute

styles: List[Style] = field(default_factory=list, metadata={'type': 'Element'}) class-attribute instance-attribute

__init__(id: str, name: str, title: str, source: DataSource, driver: str, bbox: BBox | None = None, bbox_wgs84: BBox | None = None, crs: Crs | None = None, styles: List[Style] = list(), minimum_scale: float | None = None, maximum_scale: float | None = None, style_name: str = 'default', is_spatial: bool = True) -> None

get_style_by_name(name: str) -> Style | None

Source code in src/qgis_server_light/interface/exporter/extract.py 
478
479
480
481
482
def get_style_by_name(self, name: str) -> Style | None:
    for style in self.styles:
        if name == style.name:
            return style
    return None

style() -> Style | None

Source code in src/qgis_server_light/interface/exporter/extract.py 
484
485
def style(self) -> Style | None:
    return self.get_style_by_name(self.style_name)

DataSource dataclass

Bases: BaseInterface

Source code in src/qgis_server_light/interface/exporter/extract.py 
427
428
429
430
431
432
433
434
435
436
437
438
439
440
441
442
443
444
445
446
447
448
449
450
451
452
453
454
455
456
457
458
459
460
461
462
@dataclass(repr=False)
class DataSource(BaseInterface):
    postgres: PostgresSource | None = field(default=None, metadata={"type": "Element"})
    wmts: WmtsSource | None = field(default=None, metadata={"type": "Element"})
    wms: WmsSource | None = field(default=None, metadata={"type": "Element"})
    ogr: OgrSource | None = field(default=None, metadata={"type": "Element"})
    gdal: GdalSource | None = field(default=None, metadata={"type": "Element"})
    wfs: WfsSource | None = field(default=None, metadata={"type": "Element"})
    vector_tile: VectorTileSource | None = field(
        default=None, metadata={"type": "Element"}
    )
    xyz: XYZSource | None = field(default=None, metadata={"type": "Element"})

    @property
    def definition(
        self,
    ) -> (
        PostgresSource
        | WmtsSource
        | WmsSource
        | OgrSource
        | GdalSource
        | WfsSource
        | VectorTileSource
        | XYZSource
        | None
    ):
        for dataclass_field in fields(self):
            name = dataclass_field.name
            value = getattr(self, name)
            if value:
                return value
        logging.error(
            f"No source was definied at {self.__class__.__name__}, this is not expected"
        )
        return None

definition: PostgresSource | WmtsSource | WmsSource | OgrSource | GdalSource | WfsSource | VectorTileSource | XYZSource | None property

gdal: GdalSource | None = field(default=None, metadata={'type': 'Element'}) class-attribute instance-attribute

ogr: OgrSource | None = field(default=None, metadata={'type': 'Element'}) class-attribute instance-attribute

postgres: PostgresSource | None = field(default=None, metadata={'type': 'Element'}) class-attribute instance-attribute

vector_tile: VectorTileSource | None = field(default=None, metadata={'type': 'Element'}) class-attribute instance-attribute

wfs: WfsSource | None = field(default=None, metadata={'type': 'Element'}) class-attribute instance-attribute

wms: WmsSource | None = field(default=None, metadata={'type': 'Element'}) class-attribute instance-attribute

wmts: WmtsSource | None = field(default=None, metadata={'type': 'Element'}) class-attribute instance-attribute

xyz: XYZSource | None = field(default=None, metadata={'type': 'Element'}) class-attribute instance-attribute

__init__(postgres: PostgresSource | None = None, wmts: WmtsSource | None = None, wms: WmsSource | None = None, ogr: OgrSource | None = None, gdal: GdalSource | None = None, wfs: WfsSource | None = None, vector_tile: VectorTileSource | None = None, xyz: XYZSource | None = None) -> None

Datasets dataclass

Bases: BaseInterface

Source code in src/qgis_server_light/interface/exporter/extract.py 
615
616
617
618
619
620
621
622
623
624
625
626
627
628
629
630
631
632
@dataclass(repr=False)
class Datasets(BaseInterface):
    vector: list[Vector] = field(
        default_factory=list,
        metadata={"type": "Element"},
    )
    raster: list[Raster] = field(
        default_factory=list,
        metadata={"type": "Element"},
    )
    custom: list[Custom] = field(
        default_factory=list,
        metadata={"type": "Element"},
    )
    group: list[Group] = field(
        default_factory=list,
        metadata={"type": "Element"},
    )

custom: list[Custom] = field(default_factory=list, metadata={'type': 'Element'}) class-attribute instance-attribute

group: list[Group] = field(default_factory=list, metadata={'type': 'Element'}) class-attribute instance-attribute

raster: list[Raster] = field(default_factory=list, metadata={'type': 'Element'}) class-attribute instance-attribute

vector: list[Vector] = field(default_factory=list, metadata={'type': 'Element'}) class-attribute instance-attribute

__init__(vector: list[Vector] = list(), raster: list[Raster] = list(), custom: list[Custom] = list(), group: list[Group] = list()) -> None

Field dataclass

Bases: BaseInterface

Transportable (serializable) form of a QGIS vector job_layer_definition fiel (attribute). It contains the information of the original data datatype and its translated versions and the editor widget one as well.

Attributes:

  • name (str) –

    Machine readable name of the field

  • type (str) –

    Original type as defined by data source (PostGIS, GPKG, etc.)

  • is_primary_key (bool) –

    if the field is considered to be primary key.

  • type_wfs (Optional[str]) –

    Translated type for further usage. Based on the simple types of XSD spec.

  • type_oapif (Optional[str]) –

    Translated type based on the types of the OpenAPI Spec

  • type_oapif_format (Optional[str]) –

    Format of the above-mentioned type based on the OpenAPI Spec

  • alias (Optional[str]) –

    Human readable name.

  • comment (Optional[str]) –

    Field description.

  • nullable (bool) –

    If this field can be NULL or not.

  • length (Optional[int]) –

    The limitation in length on the field value.

  • precision (Optional[int]) –

    The precision of the field value (float types)

  • editor_widget_type (Optional[str]) –

    The original type how it is defined in the QGIS form.

  • editor_widget_type_wfs (Optional[str]) –

    The translated type based on the simple types of XSD spec.

  • editor_widget_type_oapif (Optional[str]) –

    Translated type based on the types of the OpenAPI Spec

  • editor_widget_type_oapif_format (Optional[str]) –

    Format of the above-mentioned type based on the OpenAPI Spec

Source code in src/qgis_server_light/interface/exporter/extract.py 
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
@dataclass(repr=False)
class Field(BaseInterface):
    """
    Transportable (serializable) form of a QGIS vector job_layer_definition fiel (attribute). It contains the information of
    the original data datatype and its translated versions and the editor widget one as well.

    Attributes:
        name: Machine readable name of the field
        type: Original type as defined by data source (PostGIS, GPKG, etc.)
        is_primary_key: if the field is considered to be primary key.
        type_wfs: Translated type for further usage. Based on the simple types of
            [XSD spec](https://www.w3.org/TR/xmlschema11-2/#built-in-primitive-datatypes).
        type_oapif: Translated type based on the types of the
            [OpenAPI Spec](https://spec.openapis.org/oas/latest.html#data-types)
        type_oapif_format: Format of the above-mentioned type based on the
            [OpenAPI Spec](https://spec.openapis.org/oas/latest.html#data-types)
        alias: Human readable name.
        comment: Field description.
        nullable: If this field can be NULL or not.
        length: The limitation in length on the field value.
        precision: The precision of the field value (float types)
        editor_widget_type: The original type how it is defined in the QGIS form.
        editor_widget_type_wfs: The translated type based on the simple types of
            [XSD spec](https://www.w3.org/TR/xmlschema11-2/#built-in-primitive-datatypes).
        editor_widget_type_oapif: Translated type based on the types of the
            [OpenAPI Spec](https://spec.openapis.org/oas/latest.html#data-types)
        editor_widget_type_oapif_format: Format of the above-mentioned type based on the
            [OpenAPI Spec](https://spec.openapis.org/oas/latest.html#data-types)
    """

    name: str = field(metadata={"type": "Element"})
    type: str = field(metadata={"type": "Element"})
    is_primary_key: bool = field(
        default=False,
        metadata={"type": "Element"},
    )
    type_wfs: Optional[str] = field(default=None, metadata={"type": "Element"})
    type_oapif: Optional[str] = field(default=None, metadata={"type": "Element"})
    type_oapif_format: Optional[str] = field(default=None, metadata={"type": "Element"})
    alias: Optional[str] = field(default=None, metadata={"type": "Element"})
    comment: Optional[str] = field(default=None, metadata={"type": "Element"})
    nullable: bool = field(default=True, metadata={"type": "Element"})
    length: Optional[int] = field(default=None, metadata={"type": "Element"})
    precision: Optional[int] = field(default=None, metadata={"type": "Element"})
    editor_widget_type: Optional[str] = field(
        default=None, metadata={"type": "Element"}
    )
    editor_widget_type_wfs: Optional[str] = field(
        default=None, metadata={"type": "Element"}
    )
    editor_widget_type_oapif: Optional[str] = field(
        default=None, metadata={"type": "Element"}
    )
    editor_widget_type_oapif_format: Optional[str] = field(
        default=None, metadata={"type": "Element"}
    )

alias: Optional[str] = field(default=None, metadata={'type': 'Element'}) class-attribute instance-attribute

comment: Optional[str] = field(default=None, metadata={'type': 'Element'}) class-attribute instance-attribute

editor_widget_type: Optional[str] = field(default=None, metadata={'type': 'Element'}) class-attribute instance-attribute

editor_widget_type_oapif: Optional[str] = field(default=None, metadata={'type': 'Element'}) class-attribute instance-attribute

editor_widget_type_oapif_format: Optional[str] = field(default=None, metadata={'type': 'Element'}) class-attribute instance-attribute

editor_widget_type_wfs: Optional[str] = field(default=None, metadata={'type': 'Element'}) class-attribute instance-attribute

is_primary_key: bool = field(default=False, metadata={'type': 'Element'}) class-attribute instance-attribute

length: Optional[int] = field(default=None, metadata={'type': 'Element'}) class-attribute instance-attribute

name: str = field(metadata={'type': 'Element'}) class-attribute instance-attribute

nullable: bool = field(default=True, metadata={'type': 'Element'}) class-attribute instance-attribute

precision: Optional[int] = field(default=None, metadata={'type': 'Element'}) class-attribute instance-attribute

type: str = field(metadata={'type': 'Element'}) class-attribute instance-attribute

type_oapif: Optional[str] = field(default=None, metadata={'type': 'Element'}) class-attribute instance-attribute

type_oapif_format: Optional[str] = field(default=None, metadata={'type': 'Element'}) class-attribute instance-attribute

type_wfs: Optional[str] = field(default=None, metadata={'type': 'Element'}) class-attribute instance-attribute

__init__(name: str, type: str, is_primary_key: bool = False, type_wfs: Optional[str] = None, type_oapif: Optional[str] = None, type_oapif_format: Optional[str] = None, alias: Optional[str] = None, comment: Optional[str] = None, nullable: bool = True, length: Optional[int] = None, precision: Optional[int] = None, editor_widget_type: Optional[str] = None, editor_widget_type_wfs: Optional[str] = None, editor_widget_type_oapif: Optional[str] = None, editor_widget_type_oapif_format: Optional[str] = None) -> None

GdalSource dataclass

Bases: Source

Source code in src/qgis_server_light/interface/exporter/extract.py 
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
@dataclass(repr=False)
class GdalSource(Source):
    path: str = field(metadata={"type": "Element"})
    layer_name: str | None = field(default=None, metadata={"type": "Element"})
    vsi_prefix: str | None = field(default=None, metadata={"type": "Element"})

    @property
    def remote(self):
        return self.decide_remote(self.path)

    @property
    def to_qgis_decoded_uri(self) -> dict:
        connection_dict = {"path": self.path}
        if self.layer_name is not None:
            connection_dict["layerName"] = self.layer_name
        if self.vsi_prefix is not None:
            connection_dict["vsiPrefix"] = self.vsi_prefix
        return connection_dict

    @classmethod
    def from_qgis_decoded_uri(cls, decoded_uri: dict):
        return cls(
            path=decoded_uri["path"],
            layer_name=decoded_uri.get("layerName"),
            vsi_prefix=decoded_uri.get("vsiPrefix"),
        )

layer_name: str | None = field(default=None, metadata={'type': 'Element'}) class-attribute instance-attribute

path: str = field(metadata={'type': 'Element'}) class-attribute instance-attribute

remote property

to_qgis_decoded_uri: dict property

vsi_prefix: str | None = field(default=None, metadata={'type': 'Element'}) class-attribute instance-attribute

__init__(path: str, layer_name: str | None = None, vsi_prefix: str | None = None) -> None

from_qgis_decoded_uri(decoded_uri: dict) classmethod

Source code in src/qgis_server_light/interface/exporter/extract.py 
146
147
148
149
150
151
152
@classmethod
def from_qgis_decoded_uri(cls, decoded_uri: dict):
    return cls(
        path=decoded_uri["path"],
        layer_name=decoded_uri.get("layerName"),
        vsi_prefix=decoded_uri.get("vsiPrefix"),
    )

Group dataclass

Bases: AbstractDataset

Source code in src/qgis_server_light/interface/exporter/extract.py 
528
529
530
@dataclass(repr=False)
class Group(AbstractDataset):
    pass

__init__(id: str, name: str, title: str) -> None

LayerLike dataclass

Bases: BaseInterface

Source code in src/qgis_server_light/interface/exporter/extract.py 
15
16
17
18
@dataclass(repr=False)
class LayerLike(BaseInterface):
    id: str = field(metadata={"type": "Element"})
    name: str = field(metadata={"type": "Element"})

id: str = field(metadata={'type': 'Element'}) class-attribute instance-attribute

name: str = field(metadata={'type': 'Element'}) class-attribute instance-attribute

__init__(id: str, name: str) -> None

MetaData dataclass

Bases: BaseInterface

Source code in src/qgis_server_light/interface/exporter/extract.py 
569
570
571
572
573
574
575
576
577
578
579
580
581
582
583
584
585
586
587
588
589
590
591
592
@dataclass(repr=False)
class MetaData(BaseInterface):
    service: Service = field(metadata={"type": "Element"})
    links: Optional[List[str]] = field(
        default_factory=list,
        metadata={"type": "Element"},
    )
    language: Optional[str] = field(
        default=None,
        metadata={"type": "Element"},
    )
    categories: Optional[List[str]] = field(
        default_factory=list,
        metadata={"type": "Element"},
    )
    creationDateTime: str = field(
        default=None,
        metadata={"type": "Element"},
    )
    author: Optional[str] = field(default=None, metadata={"type": "Element"})

    def __post_init__(self):
        if self.creationDateTime is None:
            self.creationDateTime = datetime.now(UTC).isoformat()

author: Optional[str] = field(default=None, metadata={'type': 'Element'}) class-attribute instance-attribute

categories: Optional[List[str]] = field(default_factory=list, metadata={'type': 'Element'}) class-attribute instance-attribute

creationDateTime: str = field(default=None, metadata={'type': 'Element'}) class-attribute instance-attribute

language: Optional[str] = field(default=None, metadata={'type': 'Element'}) class-attribute instance-attribute

service: Service = field(metadata={'type': 'Element'}) class-attribute instance-attribute

__init__(service: Service, links: Optional[List[str]] = list(), language: Optional[str] = None, categories: Optional[List[str]] = list(), creationDateTime: str = None, author: Optional[str] = None) -> None

__post_init__()

Source code in src/qgis_server_light/interface/exporter/extract.py 
590
591
592
def __post_init__(self):
    if self.creationDateTime is None:
        self.creationDateTime = datetime.now(UTC).isoformat()

OgrSource dataclass

Bases: GdalSource

Source code in src/qgis_server_light/interface/exporter/extract.py 
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
@dataclass(repr=False)
class OgrSource(GdalSource):
    layer_id: str | None = field(default=None, metadata={"type": "Element"})
    subset: str | None = field(default=None, metadata={"type": "Element"})

    @property
    def to_qgis_decoded_uri(self) -> dict:
        connection_dict = super().to_qgis_decoded_uri
        if self.layer_id:
            connection_dict["layerId"] = self.layer_id
        if self.subset:
            connection_dict["subset"] = self.subset
        return connection_dict

    @classmethod
    def from_qgis_decoded_uri(cls, decoded_uri: dict):
        base_class_instance = GdalSource.from_qgis_decoded_uri(decoded_uri)
        return cls(
            path=base_class_instance.path,
            layer_name=base_class_instance.layer_name,
            vsi_prefix=base_class_instance.vsi_prefix,
            layer_id=decoded_uri.get("layerId"),
            subset=decoded_uri.get("subset"),
        )

    @property
    def encoded_uri_separator(self) -> str:
        return "|"

encoded_uri_separator: str property

layer_id: str | None = field(default=None, metadata={'type': 'Element'}) class-attribute instance-attribute

subset: str | None = field(default=None, metadata={'type': 'Element'}) class-attribute instance-attribute

to_qgis_decoded_uri: dict property

__init__(path: str, layer_name: str | None = None, vsi_prefix: str | None = None, layer_id: str | None = None, subset: str | None = None) -> None

from_qgis_decoded_uri(decoded_uri: dict) classmethod

Source code in src/qgis_server_light/interface/exporter/extract.py 
169
170
171
172
173
174
175
176
177
178
@classmethod
def from_qgis_decoded_uri(cls, decoded_uri: dict):
    base_class_instance = GdalSource.from_qgis_decoded_uri(decoded_uri)
    return cls(
        path=base_class_instance.path,
        layer_name=base_class_instance.layer_name,
        vsi_prefix=base_class_instance.vsi_prefix,
        layer_id=decoded_uri.get("layerId"),
        subset=decoded_uri.get("subset"),
    )

PostgresSource dataclass

Bases: Source

Source code in src/qgis_server_light/interface/exporter/extract.py 
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
@dataclass(repr=False)
class PostgresSource(Source):
    key: str = field(metadata={"type": "Element"})
    schema: str = field(metadata={"type": "Element"})
    table: str = field(metadata={"type": "Element"})
    geometry_column: str | None = field(default=None, metadata={"type": "Element"})
    dbname: str | None = field(default=None, metadata={"type": "Element"})
    host: str | None = field(default=None, metadata={"type": "Element"})
    password: str | None = field(default=None, metadata={"type": "Element"})
    port: int | None = field(default=None, metadata={"type": "Element"})
    type: int | None = field(default=None, metadata={"type": "Element"})
    username: str | None = field(default=None, metadata={"type": "Element"})
    srid: str | None = field(default=None, metadata={"type": "Element"})
    sslmode: int | None = field(default=None, metadata={"type": "Element"})
    ssl_mode_text: str | None = field(default=None, metadata={"type": "Element"})
    service: str | None = field(default=None, metadata={"type": "Element"})
    check_primary_key_unicity: str | None = field(
        default=None, metadata={"type": "Element"}
    )
    sql: str | None = field(default=None, metadata={"type": "Element"})

    @property
    def redacted_fields(self) -> set:
        return {"password"}

    @property
    def to_qgis_decoded_uri(self) -> dict:
        connection_dict = {"key": self.key, "schema": self.schema, "table": self.table}
        if self.geometry_column is not None:
            connection_dict["geometrycolumn"] = self.geometry_column
        if self.dbname is not None:
            connection_dict["dbname"] = self.dbname
        if self.host is not None:
            connection_dict["host"] = self.host
        if self.password is not None:
            connection_dict["password"] = self.password
        if self.port is not None:
            connection_dict["port"] = self.port
        if self.type is not None:
            connection_dict["type"] = self.type
        if self.username is not None:
            connection_dict["username"] = self.username
        if self.srid is not None:
            connection_dict["srid"] = self.srid
        if self.sslmode is not None:
            connection_dict["sslmode"] = self.sslmode
        if self.service is not None:
            connection_dict["service"] = self.service
        if self.check_primary_key_unicity is not None:
            connection_dict["checkPrimaryKeyUnicity"] = self.check_primary_key_unicity
        if self.sql is not None:
            connection_dict["sql"] = self.sql
        return connection_dict

    @classmethod
    def from_qgis_decoded_uri(cls, decoded_uri: dict):
        return cls(
            key=decoded_uri["key"],
            schema=decoded_uri["schema"],
            table=decoded_uri["table"],
            geometry_column=decoded_uri.get("geometrycolumn"),
            dbname=decoded_uri.get("dbname"),
            host=decoded_uri.get("host"),
            password=decoded_uri.get("password"),
            port=int(decoded_uri.get("port"))
            if decoded_uri.get("port") is not None
            else None,
            type=int(decoded_uri.get("type"))
            if decoded_uri.get("type") is not None
            else None,
            username=decoded_uri.get("username"),
            srid=decoded_uri.get("srid"),
            sslmode=int(decoded_uri.get("sslmode", 2)),
            service=decoded_uri.get("service"),
            check_primary_key_unicity=decoded_uri.get("check_primary_key_unicity"),
            sql=decoded_uri.get("sql"),
        )

    @property
    def remote(self):
        return True

check_primary_key_unicity: str | None = field(default=None, metadata={'type': 'Element'}) class-attribute instance-attribute

dbname: str | None = field(default=None, metadata={'type': 'Element'}) class-attribute instance-attribute

geometry_column: str | None = field(default=None, metadata={'type': 'Element'}) class-attribute instance-attribute

host: str | None = field(default=None, metadata={'type': 'Element'}) class-attribute instance-attribute

key: str = field(metadata={'type': 'Element'}) class-attribute instance-attribute

password: str | None = field(default=None, metadata={'type': 'Element'}) class-attribute instance-attribute

port: int | None = field(default=None, metadata={'type': 'Element'}) class-attribute instance-attribute

redacted_fields: set property

remote property

schema: str = field(metadata={'type': 'Element'}) class-attribute instance-attribute

service: str | None = field(default=None, metadata={'type': 'Element'}) class-attribute instance-attribute

sql: str | None = field(default=None, metadata={'type': 'Element'}) class-attribute instance-attribute

srid: str | None = field(default=None, metadata={'type': 'Element'}) class-attribute instance-attribute

ssl_mode_text: str | None = field(default=None, metadata={'type': 'Element'}) class-attribute instance-attribute

sslmode: int | None = field(default=None, metadata={'type': 'Element'}) class-attribute instance-attribute

table: str = field(metadata={'type': 'Element'}) class-attribute instance-attribute

to_qgis_decoded_uri: dict property

type: int | None = field(default=None, metadata={'type': 'Element'}) class-attribute instance-attribute

username: str | None = field(default=None, metadata={'type': 'Element'}) class-attribute instance-attribute

__init__(key: str, schema: str, table: str, geometry_column: str | None = None, dbname: str | None = None, host: str | None = None, password: str | None = None, port: int | None = None, type: int | None = None, username: str | None = None, srid: str | None = None, sslmode: int | None = None, ssl_mode_text: str | None = None, service: str | None = None, check_primary_key_unicity: str | None = None, sql: str | None = None) -> None

from_qgis_decoded_uri(decoded_uri: dict) classmethod

Source code in src/qgis_server_light/interface/exporter/extract.py 
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
@classmethod
def from_qgis_decoded_uri(cls, decoded_uri: dict):
    return cls(
        key=decoded_uri["key"],
        schema=decoded_uri["schema"],
        table=decoded_uri["table"],
        geometry_column=decoded_uri.get("geometrycolumn"),
        dbname=decoded_uri.get("dbname"),
        host=decoded_uri.get("host"),
        password=decoded_uri.get("password"),
        port=int(decoded_uri.get("port"))
        if decoded_uri.get("port") is not None
        else None,
        type=int(decoded_uri.get("type"))
        if decoded_uri.get("type") is not None
        else None,
        username=decoded_uri.get("username"),
        srid=decoded_uri.get("srid"),
        sslmode=int(decoded_uri.get("sslmode", 2)),
        service=decoded_uri.get("service"),
        check_primary_key_unicity=decoded_uri.get("check_primary_key_unicity"),
        sql=decoded_uri.get("sql"),
    )

Project dataclass

Bases: BaseInterface

Source code in src/qgis_server_light/interface/exporter/extract.py 
595
596
597
598
@dataclass(repr=False)
class Project(BaseInterface):
    version: str = field(metadata={"type": "Element"})
    name: str = field(metadata={"type": "Element"})

name: str = field(metadata={'type': 'Element'}) class-attribute instance-attribute

version: str = field(metadata={'type': 'Element'}) class-attribute instance-attribute

__init__(version: str, name: str) -> None

Raster dataclass

Bases: DataSet

A real QGIS Raster job_layer_definition. That are usually all QgsRasterLayer in opposition to QgsVectorTileLayer which is not a real QgsRasterLayer.

Source code in src/qgis_server_light/interface/exporter/extract.py 
488
489
490
491
492
493
@dataclass(repr=False)
class Raster(DataSet):
    """
    A real QGIS Raster job_layer_definition. That are usually all `QgsRasterLayer` in opposition to `QgsVectorTileLayer`
    which is not a real `QgsRasterLayer`.
    """

__init__(id: str, name: str, title: str, source: DataSource, driver: str, bbox: BBox | None = None, bbox_wgs84: BBox | None = None, crs: Crs | None = None, styles: List[Style] = list(), minimum_scale: float | None = None, maximum_scale: float | None = None, style_name: str = 'default', is_spatial: bool = True) -> None

Service dataclass

Bases: BaseInterface

Source code in src/qgis_server_light/interface/exporter/extract.py 
533
534
535
536
537
538
539
540
541
542
543
544
545
546
547
548
549
550
551
552
553
554
555
556
557
558
559
560
561
562
563
564
565
566
@dataclass(repr=False)
class Service(BaseInterface):
    contact_organization: Optional[str] = field(metadata={"type": "Element"})
    contact_mail: Optional[str] = field(metadata={"type": "Element"})
    contact_person: Optional[str] = field(
        default=None,
        metadata={"type": "Element"},
    )
    contact_phone: Optional[str] = field(
        default=None,
        metadata={"type": "Element"},
    )
    contact_position: Optional[str] = field(
        default=None,
        metadata={"type": "Element"},
    )
    fees: Optional[str] = field(default=None, metadata={"type": "Element"})
    keyword_list: Optional[str] = field(
        default=None,
        metadata={"type": "Element"},
    )
    online_resource: Optional[str] = field(
        default=None,
        metadata={"type": "Element"},
    )
    service_abstract: Optional[str] = field(
        default=None,
        metadata={"type": "Element"},
    )
    service_title: Optional[str] = field(
        default=None,
        metadata={"type": "Element"},
    )
    resource_url: Optional[str] = field(default=None, metadata={"type": "Element"})

contact_mail: Optional[str] = field(metadata={'type': 'Element'}) class-attribute instance-attribute

contact_organization: Optional[str] = field(metadata={'type': 'Element'}) class-attribute instance-attribute

contact_person: Optional[str] = field(default=None, metadata={'type': 'Element'}) class-attribute instance-attribute

contact_phone: Optional[str] = field(default=None, metadata={'type': 'Element'}) class-attribute instance-attribute

contact_position: Optional[str] = field(default=None, metadata={'type': 'Element'}) class-attribute instance-attribute

fees: Optional[str] = field(default=None, metadata={'type': 'Element'}) class-attribute instance-attribute

keyword_list: Optional[str] = field(default=None, metadata={'type': 'Element'}) class-attribute instance-attribute

online_resource: Optional[str] = field(default=None, metadata={'type': 'Element'}) class-attribute instance-attribute

resource_url: Optional[str] = field(default=None, metadata={'type': 'Element'}) class-attribute instance-attribute

service_abstract: Optional[str] = field(default=None, metadata={'type': 'Element'}) class-attribute instance-attribute

service_title: Optional[str] = field(default=None, metadata={'type': 'Element'}) class-attribute instance-attribute

__init__(contact_organization: Optional[str], contact_mail: Optional[str], contact_person: Optional[str] = None, contact_phone: Optional[str] = None, contact_position: Optional[str] = None, fees: Optional[str] = None, keyword_list: Optional[str] = None, online_resource: Optional[str] = None, service_abstract: Optional[str] = None, service_title: Optional[str] = None, resource_url: Optional[str] = None) -> None

Source dataclass

Bases: BaseInterface, ABC

Source code in src/qgis_server_light/interface/exporter/extract.py 
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
@dataclass(repr=False)
class Source(BaseInterface, ABC):
    @staticmethod
    def decide_remote(path: str) -> bool:
        return path.startswith("http")

    @property
    def to_qgis_decoded_uri(self) -> dict:
        raise NotImplementedError(
            "This is a base class, the method has to be defined at implementation level."
        )

    @classmethod
    def from_qgis_decoded_uri(cls, decoded_uri: dict):
        raise NotImplementedError(
            "This is a base class, the method has to be defined at implementation level."
        )

to_qgis_decoded_uri: dict property

__init__() -> None

decide_remote(path: str) -> bool staticmethod

Source code in src/qgis_server_light/interface/exporter/extract.py 
110
111
112
@staticmethod
def decide_remote(path: str) -> bool:
    return path.startswith("http")

from_qgis_decoded_uri(decoded_uri: dict) classmethod

Source code in src/qgis_server_light/interface/exporter/extract.py 
120
121
122
123
124
@classmethod
def from_qgis_decoded_uri(cls, decoded_uri: dict):
    raise NotImplementedError(
        "This is a base class, the method has to be defined at implementation level."
    )

Tree dataclass

Bases: BaseInterface

Source code in src/qgis_server_light/interface/exporter/extract.py 
601
602
603
604
605
606
607
608
609
610
611
612
@dataclass(repr=False)
class Tree(BaseInterface):
    members: list[TreeGroup] = field(
        default_factory=list,
        metadata={"type": "Element"},
    )

    def find_by_name(self, name: str) -> TreeGroup | None:
        for member in self.members:
            if member.name == name:
                return member
        return None

members: list[TreeGroup] = field(default_factory=list, metadata={'type': 'Element'}) class-attribute instance-attribute

__init__(members: list[TreeGroup] = list()) -> None

find_by_name(name: str) -> TreeGroup | None

Source code in src/qgis_server_light/interface/exporter/extract.py 
608
609
610
611
612
def find_by_name(self, name: str) -> TreeGroup | None:
    for member in self.members:
        if member.name == name:
            return member
    return None

TreeGroup dataclass

Bases: TreeLayer

Source code in src/qgis_server_light/interface/exporter/extract.py 
26
27
28
29
30
31
@dataclass(repr=False)
class TreeGroup(TreeLayer):
    children: List[str] = field(
        default_factory=list,
        metadata={"type": "Element"},
    )

children: List[str] = field(default_factory=list, metadata={'type': 'Element'}) class-attribute instance-attribute

__init__(id: str, name: str, children: List[str] = list()) -> None

TreeLayer dataclass

Bases: LayerLike

Source code in src/qgis_server_light/interface/exporter/extract.py 
21
22
23
@dataclass(repr=False)
class TreeLayer(LayerLike):
    pass

__init__(id: str, name: str) -> None

Vector dataclass

Bases: DataSet

A real QGIS Vector job_layer_definition. That are usually all QgsVectorLayer in opposition to QgsVectorTileLayer which is not a real QgsVectorLayer.

Source code in src/qgis_server_light/interface/exporter/extract.py 
496
497
498
499
500
501
502
503
504
505
506
507
508
509
510
511
512
513
514
515
516
517
518
519
520
@dataclass(repr=False)
class Vector(DataSet):
    """
    A real QGIS Vector job_layer_definition. That are usually all `QgsVectorLayer` in opposition to `QgsVectorTileLayer`
    which is not a real `QgsVectorLayer`.
    """

    fields: Optional[List[Field]] = field(
        default_factory=list,
        metadata={"type": "Element"},
    )
    geometry_type_simple: Optional[str] = field(
        default=None,
        metadata={"type": "Element"},
    )
    geometry_type_wkb: Optional[str] = field(
        default=None,
        metadata={"type": "Element"},
    )

    def get_field_by_name(self, name: str) -> Field | None:
        for dataclass_field in self.fields:
            if dataclass_field.name == name:
                return dataclass_field
        return None

fields: Optional[List[Field]] = field(default_factory=list, metadata={'type': 'Element'}) class-attribute instance-attribute

geometry_type_simple: Optional[str] = field(default=None, metadata={'type': 'Element'}) class-attribute instance-attribute

geometry_type_wkb: Optional[str] = field(default=None, metadata={'type': 'Element'}) class-attribute instance-attribute

__init__(id: str, name: str, title: str, source: DataSource, driver: str, bbox: BBox | None = None, bbox_wgs84: BBox | None = None, crs: Crs | None = None, styles: List[Style] = list(), minimum_scale: float | None = None, maximum_scale: float | None = None, style_name: str = 'default', is_spatial: bool = True, fields: Optional[List[Field]] = list(), geometry_type_simple: Optional[str] = None, geometry_type_wkb: Optional[str] = None) -> None

get_field_by_name(name: str) -> Field | None

Source code in src/qgis_server_light/interface/exporter/extract.py 
516
517
518
519
520
def get_field_by_name(self, name: str) -> Field | None:
    for dataclass_field in self.fields:
        if dataclass_field.name == name:
            return dataclass_field
    return None

VectorTileSource dataclass

Bases: Source

Source code in src/qgis_server_light/interface/exporter/extract.py 
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
@dataclass(repr=False)
class VectorTileSource(Source):
    type: str = field(metadata={"type": "Element"})
    zmin: int | None = field(metadata={"type": "Element"})
    zmax: int | None = field(metadata={"type": "Element"})
    url: str | None = field(default=None, metadata={"type": "Element"})
    path: str | None = field(default=None, metadata={"type": "Element"})
    style_url: str | None = field(default=None, metadata={"type": "Element"})

    @property
    def remote(self):
        return self.decide_remote(self.url)

    @property
    def to_qgis_decoded_uri(self) -> dict:
        connection_dict = {"type": self.type, "zmin": self.zmin, "zmax": self.zmax}
        if self.url is not None:
            connection_dict["url"] = self.url
        if self.path is not None:
            connection_dict["path"] = self.path
        if self.style_url is not None:
            connection_dict["styleUrl"] = self.style_url
        return connection_dict

    @classmethod
    def from_qgis_decoded_uri(cls, decoded_uri: dict):
        return cls(
            type=decoded_uri["type"],
            zmin=decoded_uri.get("zmin"),
            zmax=decoded_uri.get("zmax"),
            url=decoded_uri.get("url"),
            path=decoded_uri.get("path"),
            style_url=decoded_uri.get("styleUrl"),
        )

path: str | None = field(default=None, metadata={'type': 'Element'}) class-attribute instance-attribute

remote property

style_url: str | None = field(default=None, metadata={'type': 'Element'}) class-attribute instance-attribute

to_qgis_decoded_uri: dict property

type: str = field(metadata={'type': 'Element'}) class-attribute instance-attribute

url: str | None = field(default=None, metadata={'type': 'Element'}) class-attribute instance-attribute

zmax: int | None = field(metadata={'type': 'Element'}) class-attribute instance-attribute

zmin: int | None = field(metadata={'type': 'Element'}) class-attribute instance-attribute

__init__(type: str, zmin: int | None, zmax: int | None, url: str | None = None, path: str | None = None, style_url: str | None = None) -> None

from_qgis_decoded_uri(decoded_uri: dict) classmethod

Source code in src/qgis_server_light/interface/exporter/extract.py 
415
416
417
418
419
420
421
422
423
424
@classmethod
def from_qgis_decoded_uri(cls, decoded_uri: dict):
    return cls(
        type=decoded_uri["type"],
        zmin=decoded_uri.get("zmin"),
        zmax=decoded_uri.get("zmax"),
        url=decoded_uri.get("url"),
        path=decoded_uri.get("path"),
        style_url=decoded_uri.get("styleUrl"),
    )

WfsSource dataclass

Bases: BaseInterface

Source code in src/qgis_server_light/interface/exporter/extract.py 
185
186
187
188
189
@dataclass(repr=False)
class WfsSource(BaseInterface):
    # currently not implemented because qgis does not allow to
    # use the decode uri approach on that URI
    pass

__init__() -> None

WmsSource dataclass

Bases: Source

Source code in src/qgis_server_light/interface/exporter/extract.py 
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
@dataclass(repr=False)
class WmsSource(Source):
    crs: str = field(metadata={"type": "Element"})
    format: str = field(metadata={"type": "Element"})
    layers: str = field(metadata={"type": "Element"})
    url: str = field(metadata={"type": "Element"})
    dpi_mode: str | None = field(default=None, metadata={"type": "Element"})
    feature_count: int | None = field(default=None, metadata={"type": "Element"})
    contextual_wms_legend: str | None = field(
        default=None, metadata={"type": "Element"}
    )
    styles: str | None = field(default=None, metadata={"type": "Element"})

    @property
    def to_qgis_decoded_uri(self) -> dict:
        connection_dict = {
            "crs": self.crs,
            "format": self.format,
            "layers": self.layers,
            "url": self.url,
            "styles": self.styles,
        }
        if self.dpi_mode is not None:
            connection_dict["dpiMode"] = self.dpi_mode
        if self.feature_count is not None:
            connection_dict["featureCount"] = self.feature_count
        if self.contextual_wms_legend is not None:
            connection_dict["contextualWMSLegend"] = self.contextual_wms_legend
        return connection_dict

    @classmethod
    def from_qgis_decoded_uri(cls, decoded_uri: dict):
        return cls(
            crs=decoded_uri["crs"],
            format=decoded_uri["format"],
            layers=decoded_uri["layers"],
            url=decoded_uri["url"],
            dpi_mode=decoded_uri.get("dpiMode"),
            feature_count=decoded_uri.get("featureCount"),
            contextual_wms_legend=decoded_uri.get("contextualWMSLegend"),
            styles=decoded_uri.get("styles"),
        )

    @property
    def remote(self):
        return True

contextual_wms_legend: str | None = field(default=None, metadata={'type': 'Element'}) class-attribute instance-attribute

crs: str = field(metadata={'type': 'Element'}) class-attribute instance-attribute

dpi_mode: str | None = field(default=None, metadata={'type': 'Element'}) class-attribute instance-attribute

feature_count: int | None = field(default=None, metadata={'type': 'Element'}) class-attribute instance-attribute

format: str = field(metadata={'type': 'Element'}) class-attribute instance-attribute

layers: str = field(metadata={'type': 'Element'}) class-attribute instance-attribute

remote property

styles: str | None = field(default=None, metadata={'type': 'Element'}) class-attribute instance-attribute

to_qgis_decoded_uri: dict property

url: str = field(metadata={'type': 'Element'}) class-attribute instance-attribute

__init__(crs: str, format: str, layers: str, url: str, dpi_mode: str | None = None, feature_count: int | None = None, contextual_wms_legend: str | None = None, styles: str | None = None) -> None

from_qgis_decoded_uri(decoded_uri: dict) classmethod

Source code in src/qgis_server_light/interface/exporter/extract.py 
253
254
255
256
257
258
259
260
261
262
263
264
@classmethod
def from_qgis_decoded_uri(cls, decoded_uri: dict):
    return cls(
        crs=decoded_uri["crs"],
        format=decoded_uri["format"],
        layers=decoded_uri["layers"],
        url=decoded_uri["url"],
        dpi_mode=decoded_uri.get("dpiMode"),
        feature_count=decoded_uri.get("featureCount"),
        contextual_wms_legend=decoded_uri.get("contextualWMSLegend"),
        styles=decoded_uri.get("styles"),
    )

WmtsSource dataclass

Bases: WmsSource

Source code in src/qgis_server_light/interface/exporter/extract.py 
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
@dataclass(repr=False, kw_only=True)
class WmtsSource(WmsSource):
    tile_matrix_set: str = field(metadata={"type": "Element"})
    tile_dimensions: str | None = field(
        default=None,
        metadata={"type": "Element"},
    )
    tile_pixel_ratio: str | None = field(default=None, metadata={"type": "Element"})

    @property
    def to_qgis_decoded_uri(self) -> dict:
        connection_dict = super().to_qgis_decoded_uri
        connection_dict["tileMatrixSet"] = self.tile_matrix_set
        if self.tile_dimensions is not None:
            connection_dict["tileDimensions"] = self.tile_dimensions
        if self.tile_pixel_ratio is not None:
            connection_dict["tilePixelRatio"] = self.tile_pixel_ratio
        return connection_dict

    @classmethod
    def from_qgis_decoded_uri(cls, decoded_uri: dict):
        base_class_instance = WmsSource.from_qgis_decoded_uri(decoded_uri)
        return cls(
            crs=base_class_instance.crs,
            format=base_class_instance.format,
            layers=base_class_instance.layers,
            url=base_class_instance.url,
            dpi_mode=base_class_instance.dpi_mode,
            feature_count=base_class_instance.feature_count,
            contextual_wms_legend=base_class_instance.contextual_wms_legend,
            styles=base_class_instance.styles,
            tile_matrix_set=decoded_uri["tileMatrixSet"],
            tile_dimensions=decoded_uri.get("tileDimensions"),
            tile_pixel_ratio=decoded_uri.get("tilePixelRatio"),
        )

tile_dimensions: str | None = field(default=None, metadata={'type': 'Element'}) class-attribute instance-attribute

tile_matrix_set: str = field(metadata={'type': 'Element'}) class-attribute instance-attribute

tile_pixel_ratio: str | None = field(default=None, metadata={'type': 'Element'}) class-attribute instance-attribute

to_qgis_decoded_uri: dict property

__init__(crs: str, format: str, layers: str, url: str, dpi_mode: str | None = None, feature_count: int | None = None, contextual_wms_legend: str | None = None, styles: str | None = None, *, tile_matrix_set: str, tile_dimensions: str | None = None, tile_pixel_ratio: str | None = None) -> None

from_qgis_decoded_uri(decoded_uri: dict) classmethod

Source code in src/qgis_server_light/interface/exporter/extract.py 
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
@classmethod
def from_qgis_decoded_uri(cls, decoded_uri: dict):
    base_class_instance = WmsSource.from_qgis_decoded_uri(decoded_uri)
    return cls(
        crs=base_class_instance.crs,
        format=base_class_instance.format,
        layers=base_class_instance.layers,
        url=base_class_instance.url,
        dpi_mode=base_class_instance.dpi_mode,
        feature_count=base_class_instance.feature_count,
        contextual_wms_legend=base_class_instance.contextual_wms_legend,
        styles=base_class_instance.styles,
        tile_matrix_set=decoded_uri["tileMatrixSet"],
        tile_dimensions=decoded_uri.get("tileDimensions"),
        tile_pixel_ratio=decoded_uri.get("tilePixelRatio"),
    )

XYZSource dataclass

Bases: Source

Source code in src/qgis_server_light/interface/exporter/extract.py 
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
@dataclass(repr=False)
class XYZSource(Source):
    url: str = field(metadata={"type": "Element"})
    zmin: int | None = field(default=None, metadata={"type": "Element"})
    zmax: int | None = field(default=None, metadata={"type": "Element"})
    type: str | None = field(default=None, metadata={"type": "Element"})

    @property
    def to_qgis_decoded_uri(self) -> dict:
        connection_dict = {
            "url": self.url,
            "zmin": self.zmin,
            "zmax": self.zmax,
            "type": self.type,
        }
        return connection_dict

    @classmethod
    def from_qgis_decoded_uri(cls, decoded_uri: dict):
        return cls(
            url=decoded_uri["url"],
            zmin=decoded_uri.get("zmin"),
            zmax=decoded_uri.get("zmax"),
            type=decoded_uri.get("type"),
        )

    @property
    def remote(self):
        return self.decide_remote(self.url)

remote property

to_qgis_decoded_uri: dict property

type: str | None = field(default=None, metadata={'type': 'Element'}) class-attribute instance-attribute

url: str = field(metadata={'type': 'Element'}) class-attribute instance-attribute

zmax: int | None = field(default=None, metadata={'type': 'Element'}) class-attribute instance-attribute

zmin: int | None = field(default=None, metadata={'type': 'Element'}) class-attribute instance-attribute

__init__(url: str, zmin: int | None = None, zmax: int | None = None, type: str | None = None) -> None

from_qgis_decoded_uri(decoded_uri: dict) classmethod

Source code in src/qgis_server_light/interface/exporter/extract.py 
209
210
211
212
213
214
215
216
@classmethod
def from_qgis_decoded_uri(cls, decoded_uri: dict):
    return cls(
        url=decoded_uri["url"],
        zmin=decoded_uri.get("zmin"),
        zmax=decoded_uri.get("zmax"),
        type=decoded_uri.get("type"),
    )