geoservercloud 0.1.0.dev1__tar.gz

geoservercloud-0.1.0.dev1/LICENSE

@@ -0,0 +1,22 @@
+Copyright (c) 2024, Camptocamp SA
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+1. Redistributions of source code must retain the above copyright notice, this
+    list of conditions and the following disclaimer.
+2. Redistributions in binary form must reproduce the above copyright notice,
+    this list of conditions and the following disclaimer in the documentation
+    and/or other materials provided with the distribution.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR 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.

geoservercloud-0.1.0.dev1/PKG-INFO

@@ -0,0 +1,21 @@
+Metadata-Version: 2.1
+Name: geoservercloud
+Version: 0.1.0.dev1
+Summary: Lightweight Python client to interact with GeoServer Cloud REST API, GeoServer ACL and OGC services
+License: BSD-2-Clause
+Author: Camptocamp
+Author-email: info@camptocamp.com
+Requires-Python: >=3.9
+Classifier: License :: OSI Approved :: BSD License
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Requires-Dist: OWSLib
+Requires-Dist: requests
+Requires-Dist: xmltodict
+Description-Content-Type: text/markdown
+
+# python-geoservercloud
+

geoservercloud-0.1.0.dev1/README.md

@@ -0,0 +1 @@
+# python-geoservercloud

geoservercloud-0.1.0.dev1/geoservercloud/__init__.py

@@ -0,0 +1,3 @@
+from .geoservercloud import GeoServerCloud
+
+__all__: list[str] = ["GeoServerCloud"]

geoservercloud-0.1.0.dev1/geoservercloud/geoservercloud.py

@@ -0,0 +1,657 @@
+import os.path
+from pathlib import Path
+from typing import Any
+
+import xmltodict
+from owslib.map.wms130 import WebMapService_1_3_0
+from owslib.util import ResponseWrapper
+from owslib.wmts import WebMapTileService
+from requests import Response
+
+from geoservercloud import utils
+from geoservercloud.restservice import RestService
+from geoservercloud.templates import Templates
+
+
+class GeoServerCloud:
+    def __init__(
+        self,
+        url: str = "http://localhost:9090/geoserver/cloud/",
+        user: str = "admin",
+        password: str = "geoserver",
+    ) -> None:
+
+        self.url: str = url
+        self.user: str = user
+        self.password: str = password
+        self.auth: tuple[str, str] = (user, password)
+        self.rest_service: RestService = RestService(url, self.auth)
+        self.wms: WebMapService_1_3_0 | None = None
+        self.wmts: WebMapTileService | None = None
+        self.default_workspace: str | None = None
+        self.default_datastore: str | None = None
+
+    @staticmethod
+    def workspace_wms_settings_path(workspace: str) -> str:
+        return f"/rest/services/wms/workspaces/{workspace}/settings.json"
+
+    @staticmethod
+    def get_wmts_layer_bbox(
+        url: str, layer_name: str
+    ) -> tuple[float, float, float, float] | None:
+        wmts = WebMapTileService(url)
+        try:
+            return wmts[layer_name].boundingBoxWGS84
+        except (KeyError, AttributeError):
+            return None
+
+    def create_wms(self) -> None:
+        if self.default_workspace:
+            path: str = f"/{self.default_workspace}/wms"
+        else:
+            path = "/wms"
+        self.wms = WebMapService_1_3_0(
+            f"{self.url}{path}",
+            username=self.user,
+            password=self.password,
+            timeout=240,
+        )
+
+    def create_wmts(self) -> None:
+        path = "/gwc/service/wmts"
+        self.wmts = WebMapTileService(
+            f"{self.url}{path}",
+            version="1.0.0",
+            username=self.user,
+            password=self.password,
+        )
+
+    def create_workspace(
+        self,
+        workspace: str,
+        isolated: bool = False,
+        set_default_workspace: bool = False,
+    ) -> Response:
+        """
+        Create a workspace in GeoServer, if it does not already exist.
+        It if exists, update it
+        """
+        payload: dict[str, dict[str, Any]] = {
+            "workspace": {
+                "name": workspace,
+                "isolated": isolated,
+            }
+        }
+        response: Response = self.post_request("/rest/workspaces.json", json=payload)
+        if response.status_code == 409:
+            response = self.put_request(
+                f"/rest/workspaces/{workspace}.json", json=payload
+            )
+        if set_default_workspace:
+            self.default_workspace = workspace
+        return response
+
+    def delete_workspace(self, workspace: str) -> Response:
+        path: str = f"/rest/workspaces/{workspace}.json?recurse=true"
+        response: Response = self.delete_request(path)
+        if self.default_workspace == workspace:
+            self.default_workspace = None
+            self.wms = None
+            self.wmts = None
+        return response
+
+    def recreate_workspace(
+        self, workspace: str, set_default_workspace: bool = False
+    ) -> None:
+        """
+        Create a workspace in GeoServer, and first delete it if it already exists.
+        """
+        self.delete_workspace(workspace)
+        self.create_workspace(workspace, set_default_workspace=set_default_workspace)
+
+    def publish_workspace(self, workspace) -> Response:
+        path: str = f"{self.workspace_wms_settings_path(workspace)}"
+
+        data: dict[str, dict[str, Any]] = Templates.workspace_wms(workspace)
+        return self.put_request(path, json=data)
+
+    def set_default_locale_for_service(
+        self, workspace: str, locale: str | None
+    ) -> None:
+        path: str = self.workspace_wms_settings_path(workspace)
+        data: dict[str, dict[str, Any]] = {
+            "wms": {
+                "defaultLocale": locale,
+            }
+        }
+        self.put_request(path, json=data)
+
+    def unset_default_locale_for_service(self, workspace) -> None:
+        self.set_default_locale_for_service(workspace, None)
+
+    def create_pg_datastore(
+        self,
+        workspace: str,
+        datastore: str,
+        pg_host: str,
+        pg_port: int,
+        pg_db: str,
+        pg_user: str,
+        pg_password: str,
+        pg_schema: str = "public",
+        set_default_datastore: bool = False,
+    ) -> Response | None:
+        """
+        Create a PostGIS datastore from the DB connection parameters, or update it if it already exist.
+        """
+        response: None | Response = None
+        path = f"/rest/workspaces/{workspace}/datastores.json"
+        resource_path = f"/rest/workspaces/{workspace}/datastores/{datastore}.json"
+        payload: dict[str, dict[str, Any]] = Templates.postgis_data_store(
+            datastore=datastore,
+            pg_host=pg_host,
+            pg_port=pg_port,
+            pg_db=pg_db,
+            pg_user=pg_user,
+            pg_password=pg_password,
+            namespace=f"http://{workspace}",
+            pg_schema=pg_schema,
+        )
+        if not self.resource_exists(resource_path):
+            response = self.post_request(path, json=payload)
+        else:
+            response = self.put_request(resource_path, json=payload)
+
+        if set_default_datastore:
+            self.default_datastore = datastore
+
+        return response
+
+    def create_jndi_datastore(
+        self,
+        workspace: str,
+        datastore: str,
+        jndi_reference: str,
+        pg_schema: str = "public",
+        description: str | None = None,
+        set_default_datastore: bool = False,
+    ) -> Response | None:
+        """
+        Create a PostGIS datastore from JNDI resource, or update it if it already exist.
+        """
+        response: None | Response = None
+        path = f"/rest/workspaces/{workspace}/datastores.json"
+        resource_path = f"/rest/workspaces/{workspace}/datastores/{datastore}.json"
+        payload: dict[str, dict[str, Any]] = Templates.postgis_jndi_data_store(
+            datastore=datastore,
+            jndi_reference=jndi_reference,
+            namespace=f"http://{workspace}",
+            pg_schema=pg_schema,
+            description=description,
+        )
+        if not self.resource_exists(resource_path):
+            response = self.post_request(path, json=payload)
+        else:
+            response = self.put_request(resource_path, json=payload)
+
+        if set_default_datastore:
+            self.default_datastore = datastore
+
+        return response
+
+    def create_wmts_store(
+        self,
+        workspace: str,
+        name: str,
+        capabilities: str,
+    ) -> Response | None:
+        """
+        Create a cascaded WMTS store, or update it if it already exist.
+        """
+        response: None | Response = None
+        path = f"/rest/workspaces/{workspace}/wmtsstores.json"
+        resource_path = f"/rest/workspaces/{workspace}/wmtsstores/{name}.json"
+        payload = Templates.wmts_store(workspace, name, capabilities)
+        if not self.resource_exists(resource_path):
+            return self.post_request(path, json=payload)
+        else:
+            return self.put_request(resource_path, json=payload)
+
+    def create_feature_type(
+        self,
+        layer: str,
+        workspace: str | None = None,
+        datastore: str | None = None,
+        title: str | dict = "Default title",
+        abstract: str | dict = "Default abstract",
+        attributes: dict = Templates.geom_point_attribute(),
+        epsg: int = 4326,
+    ) -> Response | None:
+        """
+        Create a feature type or update it if it already exist.
+        """
+        workspace = workspace or self.default_workspace
+        if not workspace:
+            raise ValueError("Workspace not provided")
+        datastore = datastore or self.default_datastore
+        if not datastore:
+            raise ValueError("Datastore not provided")
+        path: str = (
+            f"/rest/workspaces/{workspace}/datastores/{datastore}/featuretypes.json"
+        )
+        resource_path: str = (
+            f"/rest/workspaces/{workspace}/datastores/{datastore}/featuretypes/{layer}.json"
+        )
+        payload: dict[str, dict[str, Any]] = Templates.feature_type(
+            layer=layer,
+            workspace=workspace,
+            datastore=datastore,
+            attributes=utils.convert_attributes(attributes),
+            epsg=epsg,
+        )
+        if type(title) is dict:
+            payload["featureType"]["internationalTitle"] = title
+        else:
+            payload["featureType"]["title"] = title
+        if type(abstract) is dict:
+            payload["featureType"]["internationalAbstract"] = abstract
+        else:
+            payload["featureType"]["abstract"] = abstract
+
+        if not self.resource_exists(resource_path):
+            return self.post_request(path, json=payload)
+        else:
+            return self.put_request(resource_path, json=payload)
+
+    def create_layer_group(
+        self,
+        group: str,
+        workspace: str | None,
+        layers: list[str],
+        title: str | dict,
+        abstract: str | dict,
+        epsg: int = 4326,
+    ) -> Response | None:
+        """
+        Create a layer group if it does not already exist.
+        """
+        workspace = workspace or self.default_workspace
+        if not workspace:
+            raise ValueError("Workspace not provided")
+        path: str = f"/rest/workspaces/{workspace}/layergroups.json"
+        resource_path: str = f"/rest/workspaces/{workspace}/layergroups/{group}.json"
+        payload: dict[str, dict[str, Any]] = Templates.layer_group(
+            group=group,
+            layers=layers,
+            workspace=workspace,
+            title=title,
+            abstract=abstract,
+            epsg=epsg,
+        )
+        if not self.resource_exists(resource_path):
+            return self.post_request(path, json=payload)
+        else:
+            return self.put_request(resource_path, json=payload)
+
+    def create_wmts_layer(
+        self,
+        workspace: str,
+        wmts_store: str,
+        native_layer: str,
+        published_layer: str | None = None,
+        epsg: int = 4326,
+    ) -> Response | None:
+        """
+        Publish a remote WMTS layer if it does not already exist.
+        """
+        if not published_layer:
+            published_layer = native_layer
+        if self.resource_exists(
+            f"/rest/workspaces/{workspace}/wmtsstores/{wmts_store}/layers/{published_layer}.json"
+        ):
+            return None
+        wmts_store_path = f"/rest/workspaces/{workspace}/wmtsstores/{wmts_store}.json"
+        capabilities_url = (
+            self.get_request(wmts_store_path)
+            .json()
+            .get("wmtsStore")
+            .get("capabilitiesURL")
+        )
+        wgs84_bbox = self.get_wmts_layer_bbox(capabilities_url, native_layer)
+
+        path = f"/rest/workspaces/{workspace}/wmtsstores/{wmts_store}/layers"
+        payload = Templates.wmts_layer(
+            published_layer, native_layer, wgs84_bbox=wgs84_bbox, epsg=epsg
+        )
+
+        return self.post_request(path, json=payload)
+
+    def publish_gwc_layer(
+        self, workspace: str, layer: str, epsg: int = 4326
+    ) -> Response | None:
+        # Reload config to make sure GWC is aware of GeoServer layers
+        self.post_request(
+            "/gwc/rest/reload",
+            headers={"Content-Type": "application/json"},
+            data="reload_configuration=1",
+        )
+        payload = Templates.gwc_layer(workspace, layer, f"EPSG:{epsg}")
+        return self.put_request(
+            f"/gwc/rest/layers/{workspace}:{layer}.json",
+            json=payload,
+        )
+
+    def create_style_from_file(
+        self,
+        style: str,
+        file: str,
+        workspace: str | None = None,
+    ) -> Response:
+        """Create a style from a file, or update it if it already exists.
+        Supported file extensions are .sld and .zip."""
+        path = (
+            "/rest/styles" if not workspace else f"/rest/workspaces/{workspace}/styles"
+        )
+        resource_path = (
+            f"/rest/styles/{style}.json"
+            if not workspace
+            else f"/rest/workspaces/{workspace}/styles/{style}.json"
+        )
+
+        file_ext = os.path.splitext(file)[1]
+        if file_ext == ".sld":
+            content_type = "application/vnd.ogc.sld+xml"
+        elif file_ext == ".zip":
+            content_type = "application/zip"
+        else:
+            raise ValueError(f"Unsupported file extension: {file_ext}")
+        with open(f"{file}", "rb") as fs:
+            data: bytes = fs.read()
+        headers: dict[str, str] = {"Content-Type": content_type}
+
+        if not self.resource_exists(resource_path):
+            return self.post_request(path, data=data, headers=headers)
+        else:
+            return self.put_request(resource_path, data=data, headers=headers)
+
+    def set_default_layer_style(
+        self, layer: str, workspace: str, style: str
+    ) -> Response:
+        path = f"/rest/layers/{workspace}:{layer}.json"
+        data = {"layer": {"defaultStyle": {"name": style}}}
+        return self.put_request(path, json=data)
+
+    def get_wms_capabilities(
+        self, workspace: str, accept_languages=None
+    ) -> dict[str, Any]:
+        path: str = f"/{workspace}/wms"
+        params: dict[str, str] = {
+            "service": "WMS",
+            "version": "1.3.0",
+            "request": "GetCapabilities",
+        }
+        if accept_languages:
+            params["AcceptLanguages"] = accept_languages
+        response: Response = self.get_request(path, params=params)
+        return xmltodict.parse(response.content)
+
+    def get_wms_layers(
+        self, workspace: str, accept_languages: str | None = None
+    ) -> Any | dict[str, Any]:
+        capabilities: dict[str, Any] = self.get_wms_capabilities(
+            workspace, accept_languages
+        )
+        try:
+            return capabilities["WMS_Capabilities"]["Capability"]["Layer"]
+        except KeyError:
+            return capabilities
+
+    def get_wfs_capabilities(self, workspace: str) -> dict[str, Any]:
+        path: str = f"/{workspace}/wfs"
+        params: dict[str, str] = {
+            "service": "WFS",
+            "version": "1.1.0",
+            "request": "GetCapabilities",
+        }
+        response: Response = self.get_request(path, params=params)
+        return xmltodict.parse(response.content)
+
+    def get_wfs_layers(self, workspace: str) -> Any | dict[str, Any]:
+        capabilities: dict[str, Any] = self.get_wfs_capabilities(workspace)
+        try:
+            return capabilities["wfs:WFS_Capabilities"]["FeatureTypeList"]
+        except KeyError:
+            return capabilities
+
+    def get_map(
+        self,
+        layers: list[str],
+        bbox: tuple[float, float, float, float],
+        size: tuple[int, int],
+        srs: str = "EPSG:2056",
+        format: str = "image/png",
+        transparent: bool = True,
+        styles: list[str] | None = None,
+        language: str | None = None,
+    ) -> ResponseWrapper | None:
+        if not self.wms:
+            self.create_wms()
+        params: dict[str, Any] = {
+            "layers": layers,
+            "srs": srs,
+            "bbox": bbox,
+            "size": size,
+            "format": format,
+            "transparent": transparent,
+            "styles": styles,
+        }
+        if language is not None:
+            params["language"] = language
+        if self.wms:
+            return self.wms.getmap(
+                **params,
+                timeout=120,
+            )
+
+    def get_feature_info(
+        self,
+        layers: list[str],
+        bbox: tuple[float, float, float, float],
+        size: tuple[int, int],
+        srs: str = "EPSG:2056",
+        info_format: str = "application/json",
+        transparent: bool = True,
+        styles: list[str] | None = None,
+        xy: list[float] = [0, 0],
+    ) -> ResponseWrapper | None:
+        if not self.wms:
+            self.create_wms()
+        params = {
+            "layers": layers,
+            "srs": srs,
+            "bbox": bbox,
+            "size": size,
+            "info_format": info_format,
+            "transparent": transparent,
+            "styles": styles,
+            "xy": xy,
+        }
+        if self.wms:
+            return self.wms.getfeatureinfo(
+                **params,
+            )
+
+    def get_legend_graphic(
+        self,
+        layer: list[str],
+        format: str = "image/png",
+        language: str | None = None,
+        style: str | None = None,
+        workspace: str | None = None,
+    ) -> Response:
+        if not workspace:
+            path = "/wms"
+        else:
+            path: str = f"/{workspace}/wms"
+        params: dict[str, Any] = {
+            "service": "WMS",
+            "version": "1.3.0",
+            "request": "GetLegendGraphic",
+            "format": format,
+            "layer": layer,
+        }
+        if language:
+            params["language"] = language
+        if style:
+            params["style"] = style
+        response: Response = self.get_request(path, params=params)
+        return response
+
+    def get_tile(
+        self, layer, format, tile_matrix_set, tile_matrix, row, column
+    ) -> ResponseWrapper | None:
+        if not self.wmts:
+            self.create_wmts()
+        if self.wmts:
+            return self.wmts.gettile(
+                layer=layer,
+                format=format,
+                tilematrixset=tile_matrix_set,
+                tilematrix=tile_matrix,
+                row=row,
+                column=column,
+            )
+
+    def create_role(self, role_name: str):
+        self.post_request(f"/rest/security/roles/role/{role_name}")
+
+    def delete_role(self, role_name: str):
+        self.delete_request(f"/rest/security/roles/role/{role_name}")
+
+    def create_role_if_not_exists(self, role_name: str) -> Response | None:
+        if self.role_exists(role_name):
+            return None
+        return self.create_role(role_name)
+
+    def role_exists(self, role_name: str) -> bool:
+        response = self.get_request(
+            f"/rest/security/roles", headers={"Accept": "application/json"}
+        )
+        roles = response.json().get("roles", [])
+        return role_name in roles
+
+    def create_acl_admin_rule(
+        self,
+        priority: int = 0,
+        access: str = "ADMIN",
+        role: str | None = None,
+        user: str | None = None,
+        workspace: str | None = None,
+    ) -> Response:
+        path = "/acl/api/adminrules"
+        return self.post_request(
+            path,
+            json={
+                "priority": priority,
+                "access": access,
+                "role": role,
+                "user": user,
+                "workspace": workspace,
+            },
+        )
+
+    def delete_acl_admin_rule(self, id: int) -> Response:
+        path = f"/acl/api/adminrules/id/{id}"
+        return self.delete_request(path)
+
+    def delete_all_acl_admin_rules(self) -> Response:
+        path = "/acl/api/adminrules"
+        return self.delete_request(path)
+
+    def create_acl_rule(
+        self,
+        priority: int = 0,
+        access: str = "DENY",
+        role: str | None = None,
+        service: str | None = None,
+        workspace: str | None = None,
+    ) -> Response:
+        path = "/acl/api/rules"
+        return self.post_request(
+            path,
+            json={
+                "priority": priority,
+                "access": access,
+                "role": role,
+                "service": service,
+                "workspace": workspace,
+            },
+        )
+
+    def delete_all_acl_rules(self) -> Response:
+        path = "/acl/api/rules"
+        return self.delete_request(path)
+
+    def create_or_update_resource(self, path, resource_path, payload) -> Response:
+        if not self.resource_exists(resource_path):
+            return self.post_request(path, json=payload)
+        else:
+            return self.put_request(resource_path, json=payload)
+
+    def create_gridset(self, epsg: int) -> Response | None:
+        resource_path: str = f"/gwc/rest/gridsets/EPSG:{epsg}.xml"
+        if self.resource_exists(resource_path):
+            return None
+        file_path: Path = Path(__file__).parent / "gridsets" / f"{epsg}.xml"
+        headers: dict[str, str] = {"Content-Type": "application/xml"}
+        try:
+            data: bytes = file_path.read_bytes()
+        except FileNotFoundError:
+            raise ValueError(f"No gridset definition found for EPSG:{epsg}")
+        return self.put_request(resource_path, data=data, headers=headers)
+
+    def resource_exists(self, path: str) -> bool:
+        # GeoServer raises a 500 when posting to a datastore or feature type that already exists, so first do
+        # a get request
+        response = self.get_request(path)
+        return response.status_code == 200
+
+    def get_request(
+        self,
+        path,
+        params: dict[str, str] | None = None,
+        headers: dict[str, str] | None = None,
+    ) -> Response:
+        return self.rest_service.get(path, params=params, headers=headers)
+
+    def post_request(
+        self,
+        path: str,
+        params: dict[str, str] | None = None,
+        headers: dict[str, str] | None = None,
+        json: dict[str, Any] | None = None,
+        data: bytes | None = None,
+    ) -> Response:
+        return self.rest_service.post(
+            path, params=params, headers=headers, json=json, data=data
+        )
+
+    def put_request(
+        self,
+        path: str,
+        params: dict[str, str] | None = None,
+        headers: dict[str, str] | None = None,
+        json: dict[str, dict[str, Any]] | None = None,
+        data: bytes | None = None,
+    ) -> Response:
+        return self.rest_service.put(
+            path, params=params, headers=headers, json=json, data=data
+        )
+
+    def delete_request(
+        self,
+        path: str,
+        params: dict[str, str] | None = None,
+        headers: dict[str, str] | None = None,
+    ) -> Response:
+        return self.rest_service.delete(path, params=params, headers=headers)

geoservercloud-0.1.0.dev1/geoservercloud/gridsets/3857.xml

@@ -0,0 +1,92 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<gridSet>
+    <name>EPSG:3857</name>
+    <description>This well-known scale set has been defined to be compatible with Google Maps and
+        Microsoft Live Map projections and zoom levels. Level 0 allows representing the whole world
+        in a single 256x256 pixels. The next level represents the whole world in 2x2 tiles of
+        256x256 pixels and so on in powers of 2. Scale denominator is only accurate near the
+        equator.</description>
+    <srs>
+        <number>3857</number>
+    </srs>
+    <extent>
+        <coords>
+            <double>-2.003750834E7</double>
+            <double>-2.003750834E7</double>
+            <double>2.003750834E7</double>
+            <double>2.003750834E7</double>
+        </coords>
+    </extent>
+    <alignTopLeft>false</alignTopLeft>
+    <resolutions>
+        <double>156543.03390625</double>
+        <double>78271.516953125</double>
+        <double>39135.7584765625</double>
+        <double>19567.87923828125</double>
+        <double>9783.939619140625</double>
+        <double>4891.9698095703125</double>
+        <double>2445.9849047851562</double>
+        <double>1222.9924523925781</double>
+        <double>611.4962261962891</double>
+        <double>305.74811309814453</double>
+        <double>152.87405654907226</double>
+        <double>76.43702827453613</double>
+        <double>38.218514137268066</double>
+        <double>19.109257068634033</double>
+        <double>9.554628534317017</double>
+        <double>4.777314267158508</double>
+        <double>2.388657133579254</double>
+        <double>1.194328566789627</double>
+        <double>0.5971642833948135</double>
+        <double>0.29858214169740677</double>
+        <double>0.14929107084870338</double>
+        <double>0.07464553542435169</double>
+        <double>0.037322767712175846</double>
+        <double>0.018661383856087923</double>
+        <double>0.009330691928043961</double>
+        <double>0.004665345964021981</double>
+        <double>0.0023326729820109904</double>
+        <double>0.0011663364910054952</double>
+        <double>5.831682455027476E-4</double>
+        <double>2.915841227513738E-4</double>
+        <double>1.457920613756869E-4</double>
+    </resolutions>
+    <metersPerUnit>1.0</metersPerUnit>
+    <pixelSize>2.8E-4</pixelSize>
+    <scaleNames>
+        <string>EPSG:3857:0</string>
+        <string>EPSG:3857:1</string>
+        <string>EPSG:3857:2</string>
+        <string>EPSG:3857:3</string>
+        <string>EPSG:3857:4</string>
+        <string>EPSG:3857:5</string>
+        <string>EPSG:3857:6</string>
+        <string>EPSG:3857:7</string>
+        <string>EPSG:3857:8</string>
+        <string>EPSG:3857:9</string>
+        <string>EPSG:3857:10</string>
+        <string>EPSG:3857:11</string>
+        <string>EPSG:3857:12</string>
+        <string>EPSG:3857:13</string>
+        <string>EPSG:3857:14</string>
+        <string>EPSG:3857:15</string>
+        <string>EPSG:3857:16</string>
+        <string>EPSG:3857:17</string>
+        <string>EPSG:3857:18</string>
+        <string>EPSG:3857:19</string>
+        <string>EPSG:3857:20</string>
+        <string>EPSG:3857:21</string>
+        <string>EPSG:3857:22</string>
+        <string>EPSG:3857:23</string>
+        <string>EPSG:3857:24</string>
+        <string>EPSG:3857:25</string>
+        <string>EPSG:3857:26</string>
+        <string>EPSG:3857:27</string>
+        <string>EPSG:3857:28</string>
+        <string>EPSG:3857:29</string>
+        <string>EPSG:3857:30</string>
+    </scaleNames>
+    <tileHeight>256</tileHeight>
+    <tileWidth>256</tileWidth>
+    <yCoordinateFirst>false</yCoordinateFirst>
+</gridSet>

geoservercloud-0.1.0.dev1/geoservercloud/restservice.py

@@ -0,0 +1,81 @@
+from typing import Any
+
+import requests
+
+
+class RestService:
+    def __init__(self, url: str, auth: tuple[str, str]) -> None:
+        self.url: str = url
+        self.auth: tuple[str, str] = auth
+
+    def get(
+        self,
+        path: str,
+        params: dict[str, str] | None = None,
+        headers: dict[str, str] | None = None,
+    ) -> requests.Response:
+        response: requests.Response = requests.get(
+            f"{self.url}{path}",
+            params=params,
+            headers=headers,
+            auth=self.auth,
+        )
+        if response.status_code != 404:
+            response.raise_for_status()
+        return response
+
+    def post(
+        self,
+        path: str,
+        params: dict[str, str] | None = None,
+        headers: dict[str, str] | None = None,
+        json: dict[str, dict[str, Any]] | None = None,
+        data: bytes | None = None,
+    ) -> requests.Response:
+
+        response: requests.Response = requests.post(
+            f"{self.url}{path}",
+            params=params,
+            headers=headers,
+            json=json,
+            data=data,
+            auth=self.auth,
+        )
+        if response.status_code != 409:
+            response.raise_for_status()
+        return response
+
+    def put(
+        self,
+        path: str,
+        params: dict[str, str] | None = None,
+        headers: dict[str, str] | None = None,
+        json: dict[str, dict[str, Any]] | None = None,
+        data: bytes | None = None,
+    ) -> requests.Response:
+        response: requests.Response = requests.put(
+            f"{self.url}{path}",
+            params=params,
+            headers=headers,
+            json=json,
+            data=data,
+            auth=self.auth,
+        )
+        response.raise_for_status()
+        return response
+
+    def delete(
+        self,
+        path: str,
+        params: dict[str, str] | None = None,
+        headers: dict[str, str] | None = None,
+    ) -> requests.Response:
+        response: requests.Response = requests.delete(
+            f"{self.url}{path}",
+            params=params,
+            headers=headers,
+            auth=self.auth,
+        )
+        if response.status_code != 404:
+            response.raise_for_status()
+        return response

geoservercloud-0.1.0.dev1/geoservercloud/templates.py

@@ -0,0 +1,304 @@
+from typing import Any
+
+EPSG_BBOX = {
+    2056: {
+        "nativeBoundingBox": {
+            "crs": {"$": f"EPSG:2056", "@class": "projected"},
+            "maxx": 2837016.9329778464,
+            "maxy": 1299782.763494124,
+            "minx": 2485014.052451379,
+            "miny": 1074188.6943776933,
+        },
+        "latLonBoundingBox": {
+            "crs": "EPSG:4326",
+            "maxx": 10.603307860867739,
+            "maxy": 47.8485348773655,
+            "minx": 5.902662003204146,
+            "miny": 45.7779277267225,
+        },
+    },
+    4326: {
+        "nativeBoundingBox": {
+            "crs": {"$": f"EPSG:4326", "@class": "projected"},
+            "maxx": 180,
+            "maxy": 90,
+            "minx": -180,
+            "miny": -90,
+        },
+        "latLonBoundingBox": {
+            "crs": "EPSG:4326",
+            "maxx": 180,
+            "maxy": 90,
+            "minx": -180,
+            "miny": -90,
+        },
+    },
+}
+
+
+class Templates:
+
+    @staticmethod
+    def workspace_wms(workspace: str) -> dict[str, dict[str, Any]]:
+        return {
+            "wms": {
+                "workspace": {"name": workspace},
+                "enabled": True,
+                "name": "WMS",
+                "versions": {
+                    "org.geotools.util.Version": [
+                        {"version": "1.1.1"},
+                        {"version": "1.3.0"},
+                    ]
+                },
+                "citeCompliant": False,
+                "schemaBaseURL": "http://schemas.opengis.net",
+                "verbose": False,
+                "bboxForEachCRS": False,
+                "watermark": {
+                    "enabled": False,
+                    "position": "BOT_RIGHT",
+                    "transparency": 100,
+                },
+                "interpolation": "Nearest",
+                "getFeatureInfoMimeTypeCheckingEnabled": False,
+                "getMapMimeTypeCheckingEnabled": False,
+                "dynamicStylingDisabled": False,
+                "featuresReprojectionDisabled": False,
+                "maxBuffer": 0,
+                "maxRequestMemory": 0,
+                "maxRenderingTime": 0,
+                "maxRenderingErrors": 0,
+                "maxRequestedDimensionValues": 100,
+                "cacheConfiguration": {
+                    "enabled": False,
+                    "maxEntries": 1000,
+                    "maxEntrySize": 51200,
+                },
+                "remoteStyleMaxRequestTime": 60000,
+                "remoteStyleTimeout": 30000,
+                "defaultGroupStyleEnabled": True,
+                "transformFeatureInfoDisabled": False,
+                "autoEscapeTemplateValues": False,
+            }
+        }
+
+    @staticmethod
+    def postgis_data_store(
+        datastore: str,
+        pg_host: str,
+        pg_port: int,
+        pg_db: str,
+        pg_user: str,
+        pg_password: str,
+        namespace: str,
+        pg_schema: str = "public",
+    ) -> dict[str, dict[str, Any]]:
+        return {
+            "dataStore": {
+                "name": datastore,
+                "connectionParameters": {
+                    "entry": [
+                        {"@key": "dbtype", "$": "postgis"},
+                        {"@key": "host", "$": pg_host},
+                        {"@key": "port", "$": pg_port},
+                        {"@key": "database", "$": pg_db},
+                        {"@key": "user", "$": pg_user},
+                        {"@key": "passwd", "$": pg_password},
+                        {"@key": "schema", "$": pg_schema},
+                        {
+                            "@key": "namespace",
+                            "$": namespace,
+                        },
+                        {"@key": "Expose primary keys", "$": "true"},
+                    ]
+                },
+            }
+        }
+
+    @staticmethod
+    def postgis_jndi_data_store(
+        datastore: str,
+        jndi_reference: str,
+        namespace: str,
+        pg_schema: str = "public",
+        description: str | None = None,
+    ) -> dict[str, dict[str, Any]]:
+        return {
+            "dataStore": {
+                "name": datastore,
+                "description": description,
+                "connectionParameters": {
+                    "entry": [
+                        {"@key": "dbtype", "$": "postgis"},
+                        {
+                            "@key": "jndiReferenceName",
+                            "$": jndi_reference,
+                        },
+                        {
+                            "@key": "schema",
+                            "$": pg_schema,
+                        },
+                        {
+                            "@key": "namespace",
+                            "$": namespace,
+                        },
+                        {"@key": "Expose primary keys", "$": "true"},
+                    ]
+                },
+            }
+        }
+
+    @staticmethod
+    def wmts_store(
+        workspace: str, name: str, capabilities: str
+    ) -> dict[str, dict[str, Any]]:
+        return {
+            "wmtsStore": {
+                "name": name,
+                "type": "WMTS",
+                "capabilitiesURL": capabilities,
+                "workspace": {"name": workspace},
+                "enabled": True,
+                "metadata": {"entry": {"@key": "useConnectionPooling", "text": True}},
+            }
+        }
+
+    @staticmethod
+    def geom_point_attribute() -> dict[str, Any]:
+        return {
+            "geom": {
+                "type": "Point",
+                "required": True,
+            }
+        }
+
+    @staticmethod
+    def feature_type(
+        layer: str,
+        workspace: str,
+        datastore: str,
+        attributes: list[dict],
+        epsg: int = 4326,
+    ) -> dict[str, dict[str, Any]]:
+        return {
+            "featureType": {
+                "name": layer,
+                "nativeName": layer,
+                "srs": f"EPSG:{epsg}",
+                "enabled": True,
+                "store": {
+                    "name": f"{workspace}:{datastore}",
+                },
+                "attributes": {
+                    "attribute": attributes,
+                },
+                "nativeBoundingBox": {
+                    "crs": EPSG_BBOX[epsg]["nativeBoundingBox"]["crs"],
+                    "maxx": EPSG_BBOX[epsg]["nativeBoundingBox"]["maxx"],
+                    "maxy": EPSG_BBOX[epsg]["nativeBoundingBox"]["maxy"],
+                    "minx": EPSG_BBOX[epsg]["nativeBoundingBox"]["minx"],
+                    "miny": EPSG_BBOX[epsg]["nativeBoundingBox"]["miny"],
+                },
+                "latLonBoundingBox": {
+                    "crs": EPSG_BBOX[epsg]["latLonBoundingBox"]["crs"],
+                    "maxx": EPSG_BBOX[epsg]["latLonBoundingBox"]["maxx"],
+                    "maxy": EPSG_BBOX[epsg]["latLonBoundingBox"]["maxy"],
+                    "minx": EPSG_BBOX[epsg]["latLonBoundingBox"]["minx"],
+                    "miny": EPSG_BBOX[epsg]["latLonBoundingBox"]["miny"],
+                },
+            }
+        }
+
+    @staticmethod
+    def layer_group(
+        group: str,
+        layers: list[str],
+        workspace: str,
+        title: str | dict[str, Any],
+        abstract: str | dict[str, Any],
+        epsg: int = 4326,
+    ) -> dict[str, dict[str, Any]]:
+        template = {
+            "layerGroup": {
+                "name": group,
+                "workspace": {"name": workspace},
+                "mode": "SINGLE",
+                "publishables": {
+                    "published": [
+                        {"@type": "layer", "name": f"{workspace}:{layer}"}
+                        for layer in layers
+                    ]
+                },
+                "styles": {"style": [{"name": ""}] * len(layers)},
+                "bounds": {
+                    "minx": EPSG_BBOX[epsg]["nativeBoundingBox"]["minx"],
+                    "maxx": EPSG_BBOX[epsg]["nativeBoundingBox"]["maxx"],
+                    "miny": EPSG_BBOX[epsg]["nativeBoundingBox"]["miny"],
+                    "maxy": EPSG_BBOX[epsg]["nativeBoundingBox"]["maxy"],
+                    "crs": f"EPSG:{epsg}",
+                },
+                "enabled": True,
+                "advertised": True,
+            }
+        }
+        if title:
+            if type(title) is dict:
+                template["layerGroup"]["internationalTitle"] = title
+            else:
+                template["layerGroup"]["title"] = title
+        if abstract:
+            if type(abstract) is dict:
+                template["layerGroup"]["internationalAbstract"] = abstract
+            else:
+                template["layerGroup"]["abstract"] = abstract
+        return template
+
+    @staticmethod
+    def wmts_layer(
+        name: str,
+        native_name: str,
+        epsg: int = 4326,
+        wgs84_bbox: tuple[float, float, float, float] | None = None,
+    ) -> dict[str, dict[str, Any]]:
+        template = {
+            "wmtsLayer": {
+                "advertised": True,
+                "enabled": True,
+                "name": name,
+                "nativeName": native_name,
+                "projectionPolicy": "FORCE_DECLARED",
+                "serviceConfiguration": False,
+                "simpleConversionEnabled": False,
+                "srs": f"EPSG:{epsg}",
+            }
+        }
+        if wgs84_bbox:
+            template["wmtsLayer"]["latLonBoundingBox"] = {
+                "crs": "EPSG:4326",
+                "minx": wgs84_bbox[0],
+                "maxx": wgs84_bbox[2],
+                "miny": wgs84_bbox[1],
+                "maxy": wgs84_bbox[3],
+            }
+            if epsg == 4326:
+                template["wmtsLayer"]["nativeBoundingBox"] = {
+                    "crs": "EPSG:4326",
+                    "minx": wgs84_bbox[0],
+                    "maxx": wgs84_bbox[2],
+                    "miny": wgs84_bbox[1],
+                    "maxy": wgs84_bbox[3],
+                }
+        return template
+
+    @staticmethod
+    def gwc_layer(
+        workspace: str, layer: str, gridset: str
+    ) -> dict[str, dict[str, Any]]:
+        return {
+            "GeoServerLayer": {
+                "name": f"{workspace}:{layer}",
+                "enabled": "true",
+                "gridSubsets": {"gridSubset": [{"gridSetName": gridset}]},
+            }
+        }

geoservercloud-0.1.0.dev1/geoservercloud/utils.py

@@ -0,0 +1,36 @@
+def java_binding(data_type: str) -> str:
+    match data_type:
+        case "string":
+            return "java.lang.String"
+        case "integer":
+            return "java.lang.Integer"
+        case "float":
+            return "java.lang.Float"
+        case "datetime":
+            return "java.util.Date"
+        case "Point":
+            return "org.locationtech.jts.geom.Point"
+        case "Line":
+            return "org.locationtech.jts.geom.LineString"
+        case "Polygon":
+            return "org.locationtech.jts.geom.Polygon"
+        case "MultiPolygon":
+            return "org.locationtech.jts.geom.MultiPolygon"
+        case _:
+            return "java.lang.String"
+
+
+def convert_attributes(attributes: dict) -> list[dict]:
+    geoserver_attributes = []
+    for name, data in attributes.items():
+        required: bool = data.get("required", False)
+        geoserver_attributes.append(
+            {
+                "name": name,
+                "minOccurs": int(required),
+                "maxOccurs": 1,
+                "nillable": not required,
+                "binding": java_binding(data["type"]),
+            }
+        )
+    return geoserver_attributes

geoservercloud-0.1.0.dev1/pyproject.toml

@@ -0,0 +1,42 @@
+[tool.poetry]
+name = "geoservercloud"
+version = "0.1.0.dev1"
+description = "Lightweight Python client to interact with GeoServer Cloud REST API, GeoServer ACL and OGC services"
+authors = ["Camptocamp <info@camptocamp.com>"]
+license = "BSD-2-Clause"
+readme = "README.md"
+packages = [{include = "geoservercloud"}]
+
+[tool.poetry.dependencies]
+python = ">=3.9,<4.0"
+requests = "2.32.3"
+OWSLib = "0.31.0"
+xmltodict = "0.13.0"
+
+[tool.poetry.group.dev.dependencies]
+pytest = "8.2.2"
+
+[build-system]
+requires = [
+  "poetry-core>=1.0.0",
+  "poetry-dynamic-versioning[plugin]",
+  "poetry-plugin-tweak-dependencies-version"
+]
+build-backend = "poetry.core.masonry.api"
+
+[tool.poetry-dynamic-versioning]
+enable = false
+vcs = "git"
+pattern = "^(?P<base>\\d+(\\.\\d+)*)"
+format-jinja = """
+{%- if env.get("VERSION_TYPE") == "version_branch" -%}
+{{serialize_pep440(bump_version(base, 1 if env.get("IS_MASTER") == "TRUE" else 2), dev=distance)}}
+{%- elif distance == 0 -%}
+{{serialize_pep440(base)}}
+{%- else -%}
+{{serialize_pep440(bump_version(base), dev=distance)}}
+{%- endif -%}
+"""
+
+[tool.poetry-plugin-tweak-dependencies-version]
+default = "present"