geoservercloud 0.7.3.dev4__tar.gz → 0.7.4.dev4__tar.gz

{geoservercloud-0.7.3.dev4 → geoservercloud-0.7.4.dev4}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: geoservercloud
-Version: 0.7.3.dev4
+Version: 0.7.4.dev4
 Summary: Lightweight Python client to interact with GeoServer Cloud REST API, GeoServer ACL and OGC services
 License: BSD-2-Clause
 Author: Camptocamp

{geoservercloud-0.7.3.dev4 → geoservercloud-0.7.4.dev4}/geoservercloud/geoservercloud.py

@@ -10,7 +10,7 @@ from geoservercloud import utils
 from geoservercloud.models.common import TimeDimensionInfo
 from geoservercloud.models.coverage import Coverage
 from geoservercloud.models.coveragestore import CoverageStore
-from geoservercloud.models.datastore import PostGisDataStore
+from geoservercloud.models.datastore import DataStore
 from geoservercloud.models.featuretype import FeatureType
 from geoservercloud.models.layer import Layer
 from geoservercloud.models.layergroup import LayerGroup
@@ -272,19 +272,94 @@ class GeoServerCloud:
             return datastores, status_code
         return datastores.aslist(), status_code
 
-    def get_pg_datastore(
+    def get_datastore(
         self, workspace_name: str, datastore_name: str
     ) -> tuple[dict[str, Any] | str, int]:
         """
         Get a datastore by workspace and name
         """
-        datastore, status_code = self.rest_service.get_pg_datastore(
+        datastore, status_code = self.rest_service.get_datastore(
             workspace_name, datastore_name
         )
         if isinstance(datastore, str):
             return datastore, status_code
         return datastore.asdict(), status_code
 
+    def get_pg_datastore(
+        self, workspace_name: str, datastore_name: str
+    ) -> tuple[dict[str, Any] | str, int]:
+        """
+        Get a datastore by workspace and name
+        """
+        return self.get_datastore(workspace_name, datastore_name)
+
+    def create_datastore(
+        self,
+        workspace_name: str,
+        datastore_name: str,
+        datastore_type: str,
+        connection_parameters: dict[str, Any],
+        description: str | None = None,
+        enabled: bool = True,
+        set_default_datastore: bool = False,
+    ) -> tuple[str, int]:
+        """
+        Create a generic datastore of any type in GeoServer, or update if it already exists. This method
+        accepts flexible connection parameters, allowing to create any type of datastore.
+
+        :param workspace_name: Name of the workspace
+        :type workspace_name: str
+        :param datastore_name: Name for the datastore
+        :type datastore_name: str
+        :param datastore_type: Type of datastore (e.g., "PostGIS", "Shapefile", "Directory of spatial files (shapefiles)")
+        :type datastore_type: str
+        :param connection_parameters: Dict of connection parameters specific to the datastore type
+        :type connection_parameters: dict
+        :param description: Optional description
+        :type description: str, optional
+        :param enabled: Whether the datastore should be enabled (default: True)
+        :type enabled: bool, optional
+        :param set_default_datastore: Whether to set as default datastore (default: False)
+        :type set_default_datastore: bool, optional
+
+        :return: Tuple of (datastore_name, status_code)
+        :rtype: tuple
+
+        :Example:
+
+        >>> create_datastore(
+        ...     workspace_name="myworkspace",
+        ...     datastore_name="my_store",
+        ...     datastore_type="PostGIS",
+        ...     connection_parameters={
+        ...         "dbtype": "postgis",
+        ...         "host": "localhost",
+        ...         "port": 5432,
+        ...         "database": "mydb",
+        ...         "user": "user",
+        ...         "passwd": "password",
+        ...         "schema": "public",
+        ...         "Expose primary keys": "true",
+        ...     }
+        ... )
+        """
+        datastore = DataStore(
+            workspace_name,
+            datastore_name,
+            connection_parameters=connection_parameters,
+            type=datastore_type,
+            description=description,
+            enabled=enabled,
+        )
+        content, status_code = self.rest_service.create_datastore(
+            workspace_name, datastore
+        )
+
+        if set_default_datastore:
+            self.default_datastore = datastore_name
+
+        return content, status_code
+
     def create_pg_datastore(
         self,
         workspace_name: str,
@@ -301,7 +376,7 @@ class GeoServerCloud:
         """
         Create a PostGIS datastore from the DB connection parameters, or update it if it already exist.
         """
-        datastore = PostGisDataStore(
+        datastore = DataStore(
             workspace_name,
             datastore_name,
             connection_parameters={
@@ -318,7 +393,7 @@ class GeoServerCloud:
             type="PostGIS",
             description=description,
         )
-        content, status_code = self.rest_service.create_pg_datastore(
+        content, status_code = self.rest_service.create_datastore(
             workspace_name, datastore
         )
 
@@ -339,7 +414,7 @@ class GeoServerCloud:
         """
         Create a PostGIS datastore from JNDI resource, or update it if it already exist.
         """
-        datastore = PostGisDataStore(
+        datastore = DataStore(
             workspace_name,
             datastore_name,
             connection_parameters={
@@ -352,15 +427,104 @@ class GeoServerCloud:
             type="PostGIS (JNDI)",
             description=description,
         )
-        content, code = self.rest_service.create_jndi_datastore(
-            workspace_name, datastore
-        )
+        content, code = self.rest_service.create_datastore(workspace_name, datastore)
 
         if set_default_datastore:
             self.default_datastore = datastore_name
 
         return content, code
 
+    def create_pmtiles_datastore(
+        self,
+        workspace_name: str,
+        datastore_name: str,
+        pmtiles_url: str,
+        description: str | None = None,
+        range_reader_provider: str = "file",
+        caching_enabled: bool = True,
+        caching_block_aligned: bool = True,
+        http_timeout_millis: int = 5000,
+        http_trust_all_certificates: bool = False,
+        s3_use_default_credentials_provider: bool = False,
+        s3_force_path_style: bool = True,
+        gcs_default_credentials_chain: bool = False,
+    ) -> tuple[str, int]:
+        """
+        Create a PMTiles datastore, or update it if it already exists.
+
+        :param workspace_name: Name of the workspace
+        :type workspace_name: str
+        :param datastore_name: Name for the PMTiles datastore
+        :type datastore_name: str
+        :param pmtiles_url: URL or path to the PMTiles file
+        :type pmtiles_url: str
+        :param description: Optional description for the datastore
+        :type description: str, optional
+        :param range_reader_provider: Range reader provider type (default: "file")
+        :type range_reader_provider: str, optional
+        :param caching_enabled: Enable caching for range reader (default: True)
+        :type caching_enabled: bool, optional
+        :param caching_block_aligned: Enable block-aligned caching (default: True)
+        :type caching_block_aligned: bool, optional
+        :param http_timeout_millis: HTTP timeout in milliseconds (default: 5000)
+        :type http_timeout_millis: int, optional
+        :param http_trust_all_certificates: Trust all SSL certificates for HTTP (default: False)
+        :type http_trust_all_certificates: bool, optional
+        :param s3_use_default_credentials_provider: Use default AWS credentials provider for S3 (default: False)
+        :type s3_use_default_credentials_provider: bool, optional
+        :param s3_force_path_style: Force path-style access for S3 (default: True)
+        :type s3_force_path_style: bool, optional
+        :param gcs_default_credentials_chain: Use default credentials chain for Google Cloud Storage (default: False)
+        :type gcs_default_credentials_chain: bool, optional
+
+        :return: Tuple of (datastore_name, status_code)
+        :rtype: tuple
+
+        :Example:
+
+        >>> create_pmtiles_datastore(
+        ...     workspace_name="pmtiles_workspace",
+        ...     datastore_name="pmtiles_store",
+        ...     pmtiles_url="file:///mnt/pmtiles/mypmtilesfile.pmtiles",
+        ...     description="My PMTiles datastore",
+        ...     range_reader_provider="file",
+        ... )
+        """
+
+        datastore = DataStore(
+            workspace_name,
+            datastore_name,
+            connection_parameters={
+                "pmtiles": pmtiles_url,
+                "namespace": f"http://{workspace_name}",
+                "io.tileverse.rangereader.provider": range_reader_provider,
+                "io.tileverse.rangereader.caching.enabled": str(
+                    caching_enabled
+                ).lower(),
+                "io.tileverse.rangereader.caching.blockaligned": str(
+                    caching_block_aligned
+                ).lower(),
+                "io.tileverse.rangereader.http.timeout-millis": str(
+                    http_timeout_millis
+                ),
+                "io.tileverse.rangereader.http.trust-all-certificates": str(
+                    http_trust_all_certificates
+                ).lower(),
+                "io.tileverse.rangereader.s3.use-default-credentials-provider": str(
+                    s3_use_default_credentials_provider
+                ).lower(),
+                "io.tileverse.rangereader.s3.force-path-style": str(
+                    s3_force_path_style
+                ).lower(),
+                "io.tileverse.rangereader.gcs.default-credentials-chain": str(
+                    gcs_default_credentials_chain
+                ).lower(),
+            },
+            type="PMTiles",
+            description=description,
+        )
+        return self.rest_service.create_datastore(workspace_name, datastore)
+
     def get_wms_store(
         self, workspace_name: str, datastore_name: str
     ) -> tuple[dict[str, Any] | str, int]:
@@ -650,8 +814,8 @@ class GeoServerCloud:
         layer_name: str,
         workspace_name: str | None = None,
         datastore_name: str | None = None,
-        title: str | dict = "Default title",
-        abstract: str | dict = "Default abstract",
+        title: str | dict | None = None,
+        abstract: str | dict | None = None,
         attributes: dict | None = None,
         epsg: int = 4326,
         keywords: list[str] = [],
@@ -719,9 +883,10 @@ class GeoServerCloud:
         self,
         group: str,
         workspace_name: str | None,
-        layers: list[str],
-        title: str | dict,
-        abstract: str | dict,
+        layers: list[str] | None = None,
+        styles: list[str] | None = None,
+        title: str | dict | None = None,
+        abstract: str | dict | None = None,
         epsg: int = 4326,
         mode: str = "SINGLE",
         enabled: bool = True,
@@ -733,10 +898,15 @@ class GeoServerCloud:
         workspace_name = workspace_name or self.default_workspace
         if not workspace_name:
             raise ValueError("Workspace not provided")
-        if not mode in LayerGroup.modes:
+        if mode not in LayerGroup.modes:
             raise ValueError(
                 f"Invalid mode: {mode}, possible values are: {LayerGroup.modes}"
             )
+        if not layers and not styles:
+            raise ValueError(
+                "Either layers or styles must be provided for a layer group"
+            )
+
         bounds = {
             "minx": utils.EPSG_BBOX[epsg]["nativeBoundingBox"]["minx"],
             "maxx": utils.EPSG_BBOX[epsg]["nativeBoundingBox"]["maxx"],
@@ -744,13 +914,23 @@ class GeoServerCloud:
             "maxy": utils.EPSG_BBOX[epsg]["nativeBoundingBox"]["maxy"],
             "crs": f"EPSG:{epsg}",
         }
+
+        publishables = None
+        if layers:
+            publishables = [f"{workspace_name}:{layer}" for layer in layers]
+
+        formatted_styles = None
+        if styles:
+            formatted_styles = [f"{workspace_name}:{style}" for style in styles]
+
         layer_group = LayerGroup(
             name=group,
             mode=mode,
             workspace_name=workspace_name,
             title=title,
             abstract=abstract,
-            publishables=[f"{workspace_name}:{layer}" for layer in layers],
+            publishables=publishables,
+            styles=formatted_styles,
             bounds=bounds,
             enabled=enabled,
             advertised=advertised,
@@ -830,9 +1010,15 @@ class GeoServerCloud:
         style_name: str,
         filename: str,
         workspace_name: str | None = None,
+        format: str = "sld",
     ) -> tuple[str, int]:
         """Create a style definition"""
-        style = Style(name=style_name, filename=filename, workspace_name=workspace_name)
+        style = Style(
+            name=style_name,
+            filename=filename,
+            workspace_name=workspace_name,
+            format=format,
+        )
         return self.rest_service.create_style_definition(
             style_name=style_name, style=style, workspace_name=workspace_name
         )
@@ -859,21 +1045,31 @@ class GeoServerCloud:
         file: str,
         workspace_name: str | None = None,
     ) -> tuple[str, int]:
-        """Create a style (SLD) from a file, or update it if it already exists.
-        Supported file extensions are .sld and .zip."""
-        file_base_name = Path(file).name
-        file_ext = Path(file).suffix
-        content, code = self.create_style_definition(
-            style_name, f"{file_base_name}.sld", workspace_name
-        )
-        if code >= 400:
-            return content, code
+        """Create a style from a file, or update it if it already exists.
+        Supported file extensions are .sld, .zip and .mbstyle."""
+        file_ext = Path(file).suffix.lower()
         if file_ext == ".sld":
+            style_format = "sld"
+            style_definition_filename = f"{style_name}.sld"
             file_format = "sld"
         elif file_ext == ".zip":
+            style_format = "sld"
+            style_definition_filename = f"{style_name}.sld"
             file_format = "zip"
+        elif file_ext == ".mbstyle":
+            style_format = "mbstyle"
+            style_definition_filename = f"{style_name}.mbstyle"
+            file_format = "mbstyle"
         else:
             raise ValueError(f"Unsupported file extension: {file_ext}")
+        content, code = self.create_style_definition(
+            style_name,
+            style_definition_filename,
+            workspace_name,
+            format=style_format,
+        )
+        if code >= 400:
+            return content, code
         with open(f"{file}", "rb") as fs:
             style: bytes = fs.read()
         return self.rest_service.create_style(

{geoservercloud-0.7.3.dev4 → geoservercloud-0.7.4.dev4}/geoservercloud/geoservercloudsync.py

@@ -106,12 +106,12 @@ class GeoServerCloudSync:
         Copy a datastore from source to destination GeoServer instance
         If deep_copy is True, copy all feature types and the corresponding layers
         """
-        datastore, status_code = self.src_instance.get_pg_datastore(
+        datastore, status_code = self.src_instance.get_datastore(
             workspace_name, datastore_name
         )
         if isinstance(datastore, str):
             return datastore, status_code
-        new_ds, new_ds_status_code = self.dst_instance.create_pg_datastore(
+        new_ds, new_ds_status_code = self.dst_instance.create_datastore(
             workspace_name, datastore
         )
         if self.not_ok(new_ds_status_code):

{geoservercloud-0.7.3.dev4 → geoservercloud-0.7.4.dev4}/geoservercloud/models/datastore.py

@@ -8,13 +8,13 @@ from geoservercloud.models.common import (
 )
 
 
-class PostGisDataStore(EntityModel):
+class DataStore(EntityModel):
     def __init__(
         self,
         workspace_name: str,
         name: str,
         connection_parameters: dict,
-        type: str = "PostGIS",
+        type: str,
         enabled: bool = True,
         description: str | None = None,
         default: bool | None = None,
@@ -73,7 +73,7 @@ class PostGisDataStore(EntityModel):
             data_store["workspace"]["name"],
             data_store["name"],
             connection_parameters,
-            data_store.get("type", "PostGIS"),
+            data_store["type"],
             data_store.get("enabled", True),
             data_store.get("description", None),
             data_store.get("_default", None),

{geoservercloud-0.7.3.dev4 → geoservercloud-0.7.4.dev4}/geoservercloud/models/layergroup.py

@@ -93,6 +93,10 @@ class LayerGroup(EntityModel):
                     {"@type": "layer", "name": p.name} for p in self.publishables
                 ]
             }
+        elif self.styles:
+            # Style group: empty publishables with styles
+            content["publishables"] = {"published": ""}
+
         if self.styles:
             content["styles"] = {"style": [s.asdict() for s in self.styles]}
         elif self.publishables:

{geoservercloud-0.7.3.dev4 → geoservercloud-0.7.4.dev4}/geoservercloud/services/restservice.py

@@ -9,7 +9,7 @@ from geoservercloud.models.common import BaseModel
 from geoservercloud.models.coverage import Coverage
 from geoservercloud.models.coverages import Coverages
 from geoservercloud.models.coveragestore import CoverageStore
-from geoservercloud.models.datastore import PostGisDataStore
+from geoservercloud.models.datastore import DataStore
 from geoservercloud.models.datastores import DataStores
 from geoservercloud.models.featuretype import FeatureType
 from geoservercloud.models.featuretypes import FeatureTypes
@@ -113,33 +113,16 @@ class RestService:
         )
         return self.deserialize_response(response, DataStores)
 
-    def get_pg_datastore(
+    def get_datastore(
         self, workspace_name: str, datastore_name: str
-    ) -> tuple[PostGisDataStore | str, int]:
+    ) -> tuple[DataStore | str, int]:
         response: Response = self.rest_client.get(
             self.rest_endpoints.datastore(workspace_name, datastore_name)
         )
-        return self.deserialize_response(response, PostGisDataStore)
+        return self.deserialize_response(response, DataStore)
 
-    def create_pg_datastore(
-        self, workspace_name: str, datastore: PostGisDataStore
-    ) -> tuple[str, int]:
-        if not self.resource_exists(
-            self.rest_endpoints.datastore(workspace_name, datastore.name)
-        ):
-            response: Response = self.rest_client.post(
-                self.rest_endpoints.datastores(workspace_name),
-                json=datastore.post_payload(),
-            )
-        else:
-            response = self.rest_client.put(
-                self.rest_endpoints.datastore(workspace_name, datastore.name),
-                json=datastore.put_payload(),
-            )
-        return response.content.decode(), response.status_code
-
-    def create_jndi_datastore(
-        self, workspace_name: str, datastore: PostGisDataStore
+    def create_datastore(
+        self, workspace_name: str, datastore: DataStore
     ) -> tuple[str, int]:
         if not self.resource_exists(
             self.rest_endpoints.datastore(workspace_name, datastore.name)
@@ -620,6 +603,8 @@ class RestService:
             headers = {"Content-Type": "application/vnd.ogc.sld+xml"}
         elif format == "zip":
             headers = {"Content-Type": "application/zip"}
+        elif format == "mbstyle":
+            headers = {"Content-Type": "application/vnd.geoserver.mbstyle+json"}
         # Do not check for existence because GeoServer throws a 500 if the style definition exists and not
         # the SLD. Besides PUT is also supported on creation
         response: Response = self.rest_client.put(
@@ -932,7 +917,7 @@ class RestService:
                 url: str = f"{self.base_url}/styles/{style_name}"
             else:
                 url = f"{self.base_url}/workspaces/{workspace_name}/styles/{style_name}"
-            if format in ("json", "sld"):
+            if format in ("json", "sld", "mbstyle"):
                 return f"{url}.{format}"
             return url
 

{geoservercloud-0.7.3.dev4 → geoservercloud-0.7.4.dev4}/pyproject.toml

@@ -1,6 +1,6 @@
 [tool.poetry]
 name = "geoservercloud"
-version = "0.7.3.dev4"
+version = "0.7.4.dev4"
 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"